summary: add string_patterns to promote data event values into summary

Git's trace2 "data" events carry structured (category, key, value)
tuples that can contain important diagnostic information, such as
curl/SSL error details from gvfs-helper. Previously, these values
were only included in the OTLP output at higher detail levels:
"dl:process" for process-level data and "dl:verbose" for
region-level data. At the default "dl:summary" level, they were
silently dropped.

This is a problem for deployments that want lightweight telemetry
(summary level) but still need visibility into specific error
conditions reported via data events.

Add a new "string_patterns" rule type to the summary configuration,
alongside the existing "message_patterns" and "region_timers".
Each rule matches data events by exact category and key prefix,
and captures the event's actual value (not just a count) into the
summary. This is emitted at all detail levels via the existing
"trace2.process.summary" span attribute.

Key design decisions:

 - Values are always emitted as arrays for schema stability, even
   when only a single event matches. This avoids downstream parsers
   having to handle both scalar and array types for the same field.

 - Summary promotion runs before region attachment in
   apply__data_generic(), so matching is not skipped when region
   stack lookup fails (e.g. orphaned data events at nesting > 1).

 - Validation enforces that field names are unique across all three
   rule types (message_patterns, region_timers, string_patterns).

Example configuration:

  string_patterns:
    - category: "gvfs-helper"
      key_prefix: "error/"
      field_name: "gvfs_helper_errors"

For a data event like:

  {"event":"data", "category":"gvfs-helper",
   "key":"error/curl",
   "value":"(curl:35) SSL connect error [hard_fail]"}

The summary output will contain:

  {"gvfs_helper_errors":
    ["(curl:35) SSL connect error [hard_fail]"]}

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: derrickstolee

evt_apply.go

@@ -830,6 +830,14 @@ func apply__data_generic(tr2 *trace2Dataset, evt *TrEvent) (err error) {
 	// nesting level n-1 is stored at regionStack[n-2] (assuming the
 	// Git process properly sets things up).
 
+	// Promote matching data values into the summary regardless of
+	// nesting level. This must run before any early returns below
+	// so that promotion is not skipped when region attachment fails.
+	apply__summary_data(tr2,
+		evt.pm_generic_data.mf_category,
+		evt.pm_generic_data.mf_key,
+		evt.pm_generic_data.mf_generic_value)
+
 	if evt.pm_generic_data.mf_nesting <= 1 {
 		tr2.process.setGenericDataValue(evt.pm_generic_data.mf_category,
 			evt.pm_generic_data.mf_key, evt.pm_generic_data.mf_generic_value)

summary.go

@@ -15,6 +15,10 @@ type SummaryAccumulator struct {
 
 	// regionTimes maps field names to total time in seconds
 	regionTimes map[string]float64
+
+	// dataValues maps field names to collected values from matching
+	// data events. Always emitted as an array for schema stability.
+	dataValues map[string][]interface{}
 }
 
 // newSummaryAccumulator creates a new accumulator with
@@ -24,6 +28,7 @@ func newSummaryAccumulator() *SummaryAccumulator {
 		messageCounts: make(map[string]int64),
 		regionCounts:  make(map[string]int64),
 		regionTimes:   make(map[string]float64),
+		dataValues:    make(map[string][]interface{}),
 	}
 }
 
@@ -47,6 +52,11 @@ func configuredSummary(settings *SummarySettings) *SummaryAccumulator {
 		}
 	}
 
+	// Initialize dataValues with field names from StringPatterns
+	for _, rule := range settings.StringPatterns {
+		summary.dataValues[rule.FieldName] = nil
+	}
+
 	return summary
 }
 
@@ -68,6 +78,12 @@ func (csa *SummaryAccumulator) addRegionMetrics(countField string, timeField str
 	}
 }
 
+// appendDataValue appends a value from a matching data event to the
+// specified field name's value list.
+func (csa *SummaryAccumulator) appendDataValue(fieldName string, value interface{}) {
+	csa.dataValues[fieldName] = append(csa.dataValues[fieldName], value)
+}
+
 // toMap converts the accumulated metrics into a single map suitable
 // for JSON marshaling. The map contains all non-zero values across
 // all metric types (message counts, region counts, region times).
@@ -92,6 +108,12 @@ func (csa *SummaryAccumulator) toMap() map[string]interface{} {
 		}
 	}
 
+	for fieldName, values := range csa.dataValues {
+		if len(values) > 0 {
+			result[fieldName] = values
+		}
+	}
+
 	return result
 }
 
@@ -153,3 +175,29 @@ func apply__summary_region(tr2 *trace2Dataset, region *TrRegion) {
 		}
 	}
 }
+
+// apply__summary_data checks if a data event matches any
+// configured data pattern rules and appends the event's value
+// to the summary if a match is found. This promotes matching
+// data event values into the summary regardless of nesting level
+// or detail level.
+func apply__summary_data(tr2 *trace2Dataset, category string, key string, value interface{}) {
+	if tr2.process.summary == nil {
+		return
+	}
+
+	if tr2.rcvr_base == nil || tr2.rcvr_base.RcvrConfig == nil {
+		return
+	}
+
+	css := tr2.rcvr_base.RcvrConfig.summary
+	if css == nil {
+		return
+	}
+
+	for _, rule := range css.StringPatterns {
+		if category == rule.Category && strings.HasPrefix(key, rule.KeyPrefix) {
+			tr2.process.summary.appendDataValue(rule.FieldName, value)
+		}
+	}
+}

summary_settings.go

@@ -10,6 +10,7 @@ import (
 type SummarySettings struct {
 	MessagePatterns []MessagePatternRule `mapstructure:"message_patterns"`
 	RegionTimers    []RegionTimerRule    `mapstructure:"region_timers"`
+	StringPatterns  []StringPatternRule  `mapstructure:"string_patterns"`
 }
 
 // MessagePatternRule defines a rule for counting messages that match
@@ -46,6 +47,24 @@ type RegionTimerRule struct {
 	TimeField string `mapstructure:"time_field"`
 }
 
+// StringPatternRule defines a rule for promoting values from data events
+// that match a specific (category, key prefix) pair. When a data event's
+// category matches exactly and its key starts with the specified prefix,
+// the event's value is captured and emitted in the summary regardless of
+// detail level. Multiple matching values are collected into an array.
+type StringPatternRule struct {
+	// Category is the data event category to match (exact match)
+	Category string `mapstructure:"category"`
+
+	// KeyPrefix is the string prefix to match at the beginning of
+	// the data event's key field
+	KeyPrefix string `mapstructure:"key_prefix"`
+
+	// FieldName is the name of the field in the summary object
+	// where matched values will be stored (always as an array)
+	FieldName string `mapstructure:"field_name"`
+}
+
 // parseSummarySettings parses a summary configuration
 // from a YML file and validates the configuration.
 func parseSummarySettings(path string) (*SummarySettings, error) {
@@ -104,5 +123,22 @@ func parseSummarySettingsFromBuffer(data []byte, path string) (*SummarySettings,
 		}
 	}
 
+	// Validate string pattern rules
+	for i, rule := range css.StringPatterns {
+		if len(rule.Category) == 0 {
+			return nil, fmt.Errorf("string_patterns[%d]: category cannot be empty", i)
+		}
+		if len(rule.KeyPrefix) == 0 {
+			return nil, fmt.Errorf("string_patterns[%d]: key_prefix cannot be empty", i)
+		}
+		if len(rule.FieldName) == 0 {
+			return nil, fmt.Errorf("string_patterns[%d]: field_name cannot be empty", i)
+		}
+		if fieldNames[rule.FieldName] {
+			return nil, fmt.Errorf("string_patterns[%d]: duplicate field_name '%s'", i, rule.FieldName)
+		}
+		fieldNames[rule.FieldName] = true
+	}
+
 	return css, nil
 }