fix the changes

Author: avy252004

pkg/stanza/docs/operators/otelcol.md

@@ -168,7 +168,7 @@ Configuration:
 </tr>
 </table>
 
-#### Malformed trailing fields in a console-encoded line
+#### A message that legitimately contains a brace
 
 Configuration:
 ```yaml
@@ -182,7 +182,7 @@ Configuration:
 
 ```json
 {
-  "body": "2026-07-06T22:56:21Z\twarn\tbroken message\t{\"resource\": invalid}"
+  "body": "2026-07-06T22:56:21Z\twarn\tConfig value for pool {default} is missing\t{\"resource\":{\"k8s.pod.name\":\"otel-agent\"}}"
 }
 ```
 
@@ -193,9 +193,9 @@ Configuration:
 {
   "timestamp": "2026-07-06T22:56:21Z",
   "severity": "warn",
-  "body": "broken message\t{\"resource\": invalid}",
-  "attributes": {
-    "otelcol.self_log.malformed_trailing_json": true
+  "body": "Config value for pool {default} is missing",
+  "resource": {
+    "k8s.pod.name": "otel-agent"
   }
 }
 ```
@@ -204,4 +204,39 @@ Configuration:
 </tr>
 </table>
 
-The line is not dropped or errored on - the raw trailing text is preserved as-is in `body`, and the attribute above signals that the loss is visible rather than silent. This is the only case where malformed input does not follow the operator's normal [on_error](../types/on_error.md) behavior; any other unparseable line (e.g. invalid full-line JSON in `json` mode, or a line that doesn't match the `console` shape at all) still triggers `on_error` as usual.
+A `{` appearing in the message itself (not as the start of real trailing JSON) does not get mistaken for structured fields, and the real trailing `resource` object further along the line is still found and promoted correctly.
+
+#### Trailing text that looks like JSON but isn't valid
+
+Configuration:
+```yaml
+- type: otelcol
+```
+
+<table>
+<tr><td> Input body </td> <td> Output entry</td></tr>
+<tr>
+<td>
+
+```json
+{
+  "body": "2026-07-06T22:56:21Z\twarn\tbroken message\t{\"resource\": invalid}"
+}
+```
+
+</td>
+<td>
+
+```json
+{
+  "timestamp": "2026-07-06T22:56:21Z",
+  "severity": "warn",
+  "body": "broken message\t{\"resource\": invalid}"
+}
+```
+
+</td>
+</tr>
+</table>
+
+The line is not dropped or errored on: the message itself is still valid content, and only the optional trailing metadata failed to parse, so the raw remaining text is kept as-is in `body` rather than discarded. This is the one case where unparseable input does not raise `on_error` - any other failure (e.g. invalid full-line JSON in `json` mode, or a line that doesn't match the `console` shape at all) still triggers `on_error` as usual.

pkg/stanza/operator/parser/otelcol/config.go

@@ -42,8 +42,14 @@ type Config struct {
 
 // Build will build an otelcol parser operator.
 func (c Config) Build(set component.TelemetrySettings) (operator.Operator, error) {
+	// Schema is fixed, so none of these are user-configurable.
 	c.ParseFrom = entry.NewBodyField()
 	c.ParseTo = entry.RootableField{Field: entry.NewAttributeField()}
+	c.BodyField = nil
+	c.TimeParser = nil
+	c.SeverityConfig = nil
+	c.TraceParser = nil
+	c.ScopeNameParser = nil
 
 	parserOperator, err := c.ParserConfig.Build(set)
 	if err != nil {

pkg/stanza/operator/parser/otelcol/parser.go

@@ -23,18 +23,15 @@ const (
 	formatAuto    = "auto"
 	formatJSON    = "json"
 	formatConsole = "console"
-
-	// malformedTrailingFieldsAttr is set on the entry's leftover attributes
-	// whenever a console-encoded line ended with what looked like an attempt
-	// at structured trailing fields (i.e. the line ends in "}"), but the
-	// trailing text never resolved into valid JSON.
-	malformedTrailingFieldsAttr = "otelcol.self_log.malformed_trailing_json"
 )
 
 // consoleLinePrefixRegex matches zap's console encoding up through the message:
 // <ts> <level> [<caller>] <rest>. It does not attempt to locate any trailing
 // JSON fields - regex alone can't tell whether a "{" is real JSON or just
-// part of the message text (e.g. "Config value for pool {default}").
+// part of the message text (e.g. "Config value for pool {default}"), since
+// that requires tracking brace nesting and string literals. Splitting the
+// trailing JSON out of <rest> is handled separately, structurally, by
+// splitConsoleMessageAndFields.
 var consoleLinePrefixRegex = regexp.MustCompile(`^(\S+)\s+(\S+)\s+(?:(\S+:\d+)\s+)?(.*)$`)
 
 // Parser is an operator that parses otelcol self-logs and promotes the resource field onto the entry's Resource.
@@ -95,6 +92,9 @@ func detectFormat(line string) string {
 }
 
 // parseJSONLine parses a line where the entire line is a single JSON object.
+// Since the whole line is fed to a real JSON decoder here, braces inside
+// string values (e.g. a "msg" field containing "{") are already handled
+// correctly - this function was never affected by the console-line bug.
 func parseJSONLine(line string) (map[string]any, error) {
 	var parsed map[string]any
 	if err := json.Unmarshal([]byte(line), &parsed); err != nil {
@@ -111,7 +111,7 @@ func parseConsoleLine(line string) (map[string]any, error) {
 		return nil, errors.New("line cannot be parsed as a console-encoded otelcol self-log")
 	}
 
-	msg, fields, malformed := splitConsoleMessageAndFields(match[4])
+	msg, fields := splitConsoleMessageAndFields(match[4])
 
 	result := map[string]any{
 		"ts":    match[1],
@@ -121,27 +121,25 @@ func parseConsoleLine(line string) (map[string]any, error) {
 	if caller := match[3]; caller != "" {
 		result["caller"] = caller
 	}
-	if malformed {
-		result[malformedTrailingFieldsAttr] = true
-	}
 	maps.Copy(result, fields)
 
 	return result, nil
 }
 
 // splitConsoleMessageAndFields separates a message from an optional trailing
-// JSON object, using a real JSON decoder rather than a regex, so that:
+// JSON object, so that:
 //   - braces inside the message text (e.g. "pool {default} is missing") don't
 //     get mistaken for the start of structured fields, and
 //   - nested objects inside the real trailing fields (e.g. "resource":{...})
 //     are matched to their correct closing brace, not the first "}" found.
-
-func splitConsoleMessageAndFields(rest string) (msg string, fields map[string]any, malformed bool) {
+func splitConsoleMessageAndFields(rest string) (msg string, fields map[string]any) {
 	rest = strings.TrimSpace(rest)
 
-	looksLikeTrailingJSON := strings.HasSuffix(rest, "}")
+	//  skip scanning entirely if "}" missing.
+	if !strings.HasSuffix(rest, "}") {
+		return rest, nil
+	}
 
-	sawUnresolvedBrace := false
 	searchFrom := 0
 	for {
 		idx := strings.IndexByte(rest[searchFrom:], '{')
@@ -155,17 +153,14 @@ func splitConsoleMessageAndFields(rest string) (msg string, fields map[string]an
 		var decoded map[string]any
 		if err := dec.Decode(&decoded); err == nil {
 			if strings.TrimSpace(candidate[dec.InputOffset():]) == "" {
-				return strings.TrimSpace(rest[:idx]), decoded, false
+				return strings.TrimSpace(rest[:idx]), decoded
 			}
 		}
 
-		if looksLikeTrailingJSON {
-			sawUnresolvedBrace = true
-		}
 		searchFrom = idx + 1
 	}
 
-	return rest, nil, sawUnresolvedBrace
+	return rest, nil
 }
 
 // postProcess promotes the ts, level, msg, and resource fields of a parsed otelcol self-log