mirror of
https://github.com/open-telemetry/opentelemetry-go.git
synced 2025-02-05 13:15:41 +02:00
002c0a4c03
Closes #5425 Our current log `Processor` interface contains more functionality than the [OTel spec](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/logs/sdk.md#logrecordprocessor-operations). The additional functionality allows processors to report back to the API if a Record should be constructed and emitted or not, which is quite helpful[^1][^2][^3][^4][^5]. This removes the `Enabled` method from the `Processor` type. It adds this functionality a new optional and experimental `FilterProcessor` interface type. The logger and provider are updated to check for this optional interface to be implemented with the configured processors and uses them to back the `Logger.Enabled` method, preserving existing functionality. By making this change: - The `Processor` interface is now compliant with the OTel spec and does not contain any additional unspecified behavior. - All `Processor` implementations are no longer required to implement an `Enabled` method. The default, when they do not implement this method, is to assume they are enabled. ### Benchmark ```terminal goos: linux goarch: amd64 pkg: go.opentelemetry.io/otel/sdk/log cpu: Intel(R) Core(TM) i7-8550U CPU @ 1.80GHz │ old.txt │ new7.txt │ │ sec/op │ sec/op vs base │ LoggerEnabled-8 133.30n ± 3% 32.36n ± 3% -75.72% (p=0.000 n=10) │ old.txt │ new7.txt │ │ B/op │ B/op vs base │ LoggerEnabled-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=10) ¹ ¹ all samples are equal │ old.txt │ new7.txt │ │ allocs/op │ allocs/op vs base │ LoggerEnabled-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=10) ¹ ¹ all samples are equal ``` This is a significant performance improvement due to the `Record` no longer being converted from the API version to the SDK version. [^1]: https://pkg.go.dev/go.opentelemetry.io/contrib/processors/minsev [^2]: https://pkg.go.dev/go.opentelemetry.io/otel/sdk/log#BatchProcessor.Enabled [^3]: https://pkg.go.dev/go.opentelemetry.io/otel/sdk/log#SimpleProcessor.Enabled [^4]:af75717ac4/bridges/otelslog/handler.go (L206-L211)[^5]:d0309ddd8c/bridges/otelzap/core.go (L142-L146)--------- Co-authored-by: Robert Pająk <pellared@hotmail.com> Co-authored-by: Sam Xie <sam@samxie.me>
105 lines
2.9 KiB
Go
105 lines
2.9 KiB
Go
// Copyright The OpenTelemetry Authors
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package log // import "go.opentelemetry.io/otel/sdk/log"
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"go.opentelemetry.io/otel"
|
|
"go.opentelemetry.io/otel/log"
|
|
"go.opentelemetry.io/otel/log/embedded"
|
|
"go.opentelemetry.io/otel/sdk/instrumentation"
|
|
"go.opentelemetry.io/otel/sdk/log/internal/x"
|
|
"go.opentelemetry.io/otel/trace"
|
|
)
|
|
|
|
var now = time.Now
|
|
|
|
// Compile-time check logger implements log.Logger.
|
|
var _ log.Logger = (*logger)(nil)
|
|
|
|
type logger struct {
|
|
embedded.Logger
|
|
|
|
provider *LoggerProvider
|
|
instrumentationScope instrumentation.Scope
|
|
}
|
|
|
|
func newLogger(p *LoggerProvider, scope instrumentation.Scope) *logger {
|
|
return &logger{
|
|
provider: p,
|
|
instrumentationScope: scope,
|
|
}
|
|
}
|
|
|
|
func (l *logger) Emit(ctx context.Context, r log.Record) {
|
|
newRecord := l.newRecord(ctx, r)
|
|
for _, p := range l.provider.processors {
|
|
if err := p.OnEmit(ctx, &newRecord); err != nil {
|
|
otel.Handle(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enabled returns true if at least one Processor held by the LoggerProvider
|
|
// that created the logger will process the record for the provided context.
|
|
//
|
|
// If it is not possible to definitively determine the record will be
|
|
// processed, true will be returned by default. A value of false will only be
|
|
// returned if it can be positively verified that no Processor will process the
|
|
// record.
|
|
func (l *logger) Enabled(ctx context.Context, record log.Record) bool {
|
|
fltrs := l.provider.filterProcessors()
|
|
// If there are more Processors than FilterProcessors we cannot be sure
|
|
// that all Processors will drop the record. Therefore, return true.
|
|
//
|
|
// If all Processors are FilterProcessors, check if any is enabled.
|
|
return len(l.provider.processors) > len(fltrs) || anyEnabled(ctx, record, fltrs)
|
|
}
|
|
|
|
func anyEnabled(ctx context.Context, r log.Record, fltrs []x.FilterProcessor) bool {
|
|
for _, f := range fltrs {
|
|
if f.Enabled(ctx, r) {
|
|
// At least one Processor will process the Record.
|
|
return true
|
|
}
|
|
}
|
|
// No Processor will process the record
|
|
return false
|
|
}
|
|
|
|
func (l *logger) newRecord(ctx context.Context, r log.Record) Record {
|
|
sc := trace.SpanContextFromContext(ctx)
|
|
|
|
newRecord := Record{
|
|
timestamp: r.Timestamp(),
|
|
observedTimestamp: r.ObservedTimestamp(),
|
|
severity: r.Severity(),
|
|
severityText: r.SeverityText(),
|
|
body: r.Body(),
|
|
|
|
traceID: sc.TraceID(),
|
|
spanID: sc.SpanID(),
|
|
traceFlags: sc.TraceFlags(),
|
|
|
|
resource: l.provider.resource,
|
|
scope: &l.instrumentationScope,
|
|
attributeValueLengthLimit: l.provider.attributeValueLengthLimit,
|
|
attributeCountLimit: l.provider.attributeCountLimit,
|
|
}
|
|
|
|
// This field SHOULD be set once the event is observed by OpenTelemetry.
|
|
if newRecord.observedTimestamp.IsZero() {
|
|
newRecord.observedTimestamp = now()
|
|
}
|
|
|
|
r.WalkAttributes(func(kv log.KeyValue) bool {
|
|
newRecord.AddAttributes(kv)
|
|
return true
|
|
})
|
|
|
|
return newRecord
|
|
}
|