Struct Finding 

pub struct Finding {

    pub finding_type: FindingType,
    pub severity: Severity,
    pub trace_id: String,
    pub service: String,
    pub source_endpoint: String,
    pub pattern: Pattern,
    pub suggestion: String,
    pub first_timestamp: String,
    pub last_timestamp: String,
    pub green_impact: Option<GreenImpact>,
    pub confidence: Confidence,
    pub classification_method: Option<ClassificationMethod>,
    pub code_location: Option<CodeLocation>,
    pub instrumentation_scopes: Vec<String>,
    pub suggested_fix: Option<SuggestedFix>,
    pub signature: String,
}

A detected performance anti-pattern.

Fields

finding_type: FindingType

The anti-pattern category (N+1, redundant, slow, fanout, etc.).

severity: Severity

Severity level: critical, warning or info.

trace_id: String

Trace identifier where the anti-pattern was detected.

service: String

Name of the service emitting the spans involved in the finding.

source_endpoint: String

Normalized inbound endpoint (route template) hosting the pattern.

pattern: Pattern

Details of the matched pattern: template, occurrences, window, params.

suggestion: String

Human-readable remediation hint for this finding.

first_timestamp: String

Earliest timestamp among spans in the detected group.

last_timestamp: String

Latest timestamp among spans in the detected group.

green_impact: Option<GreenImpact>

GreenOps impact estimate. Absent when green scoring is disabled.

confidence: Confidence

Source context of this finding: CI batch run, staging daemon, or production daemon. Used by downstream consumers (perf-lint) to boost or reduce severity based on how the finding was produced.

Contract: detectors always emit Confidence::default() (= CiBatch); the real value is stamped by the pipeline caller (pipeline::analyze_with_traces for batch, daemon::process_traces for the daemon) after detection returns. This keeps the detector layer oblivious to runtime context.

classification_method: Option<ClassificationMethod>

How this finding’s type was classified.

None (default, omitted from JSON) means direct classification via the standard pipeline rules (distinct_params >= threshold for N+1, repeated identical (template, params) for redundant). Some(SanitizerHeuristic) means the type was inferred via the sanitizer-aware heuristic, because the OpenTelemetry agent collapsed every parameter to ? and the standard distinct-params signal was unusable. Operators can filter on this field to spot where the heuristic is firing.

code_location: Option<CodeLocation>

Source code location from OTel code.* span attributes. None when the instrumentation agent does not emit these attributes.

instrumentation_scopes: Vec<String>

OpenTelemetry instrumentation scope chain from the originating span and its ancestors (leaf to root, deduplicated). Primary framework signal for [suggestions::enrich]. Empty when the upstream format carries no scope info (Jaeger, Zipkin) or the trace is synthetic.

suggested_fix: Option<SuggestedFix>

Framework-specific actionable fix, populated by [suggestions::enrich] after the per-trace detectors run. None when no framework can be inferred or the (finding_type, framework) pair has no mapping in the fixes table.

signature: String

Canonical signature for ack matching, e.g. n_plus_one_sql:order-svc:POST_/api/orders:a3f8b2c1. Always present in JSON output so users can copy-paste it into .perf-sentinel-acknowledgments.toml. Filled by crate::acknowledgments::enrich_with_signatures at end of pipeline::analyze and after deserializing baselines.

Trait Implementations

impl Clone for Finding

fn clone(&self) -> Finding

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Finding

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Finding

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Finding

fn eq(&self, other: &Finding) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Finding

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Finding