go/opentelemetry-go
go/opentelemetry-go
1
0
Fork 0
mirror of https://github.com/open-telemetry/opentelemetry-go.git synced 2024-12-02 08:52:21 +02:00
Code Issues Releases Activity

Revert Adding attributes to the instrumentation scope.

Browse Source 
Revert "Add instrumentation scope attributes (#3131)" (#3154)

This reverts commit 0078faeb0e.

Revert "Add WithScopeAttributes MeterOption to metric API package (#3132)"

This reverts commit 81a9bab814.
This commit is contained in:
Aaron Clawson 2022-09-09 09:06:58 -05:00 committed by GitHub
parent 13906ace5d
commit 7aba25d651
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 17 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -14,9 +14,6 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
Include compatibility testing and document support. (#3077)
- Support the OTLP ExportTracePartialSuccess response; these are passed to the registered error handler. (#3106)
- Upgrade go.opentelemetry.io/proto/otlp from v0.18.0 to v0.19.0 (#3107)
- Add an `Attribute` field to the `Scope` type in `go.opentelemetry.io/otel/sdk/instrumentation`. (#3131)
- Add the `WithScopeAttributes` `TracerOption` to the `go.opentelemetry.io/otel/trace` package. (#3131)
- Add the `WithScopeAttributes` `MeterOption` to the `go.opentelemetry.io/otel/metric` package. (#3132)
### Changed
@ -25,7 +22,6 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
exact upper-inclusive boundary support following the [corresponding
specification change](https://github.com/open-telemetry/opentelemetry-specification/pull/2633). (#2982)
- Attempting to start a span with a nil `context` will no longer cause a panic. (#3110)
- Export scope attributes for all exporters provided by `go.opentelemetry.io/otel/exporters/otlp/otlptrace`. (#3131)
## [1.9.0/0.0.3] - 2022-08-01

1
exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go
View File

@ -26,6 +26,5 @@ func InstrumentationScope(il instrumentation.Scope) *commonpb.InstrumentationSco
return &commonpb.InstrumentationScope{
Name: il.Name,
Version: il.Version,
Attributes: Iterator(il.Attributes.Iter()),
}
}

52
exporters/otlp/otlptrace/internal/tracetransform/instrumentation_test.go
View File

@ -1,52 +0,0 @@
// Copyright The OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package tracetransform // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform"
import (
"testing"
"github.com/stretchr/testify/assert"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/sdk/instrumentation"
commonpb "go.opentelemetry.io/proto/otlp/common/v1"
)
func TestInstrumentationScope(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Nil(t, InstrumentationScope(instrumentation.Scope{}))
})
t.Run("Mapping", func(t *testing.T) {
var (
name = "instrumentation name"
version = "v0.1.0"
attr = attribute.NewSet(attribute.String("domain", "trace"))
attrPb = Iterator(attr.Iter())
)
expected := &commonpb.InstrumentationScope{
Name: name,
Version: version,
Attributes: attrPb,
}
actual := InstrumentationScope(instrumentation.Scope{
Name: name,
Version: version,
SchemaURL: "http://this.is.mapped.elsewhere.com",
Attributes: attr,
})
assert.Equal(t, expected, actual)
})
}

3
exporters/stdout/stdouttrace/trace_test.go
View File

@ -186,8 +186,7 @@ func expectedJSON(now time.Time) string {
"InstrumentationLibrary": {
"Name": "",
"Version": "",
"SchemaURL": "",
"Attributes": null
"SchemaURL": ""
}
}
`

18
metric/config.go
View File

@ -14,13 +14,10 @@
package metric // import "go.opentelemetry.io/otel/metric"
import "go.opentelemetry.io/otel/attribute"
// MeterConfig contains options for Meters.
type MeterConfig struct {
instrumentationVersion string
schemaURL string
attributes attribute.Set
}
// InstrumentationVersion is the version of the library providing instrumentation.
@ -33,11 +30,6 @@ func (cfg MeterConfig) SchemaURL() string {
return cfg.schemaURL
}
// Attributes returns the scope attribute set of the Meter.
func (t MeterConfig) Attributes() attribute.Set {
return t.attributes
}
// MeterOption is an interface for applying Meter options.
type MeterOption interface {
// applyMeter is used to set a MeterOption value of a MeterConfig.
@ -75,13 +67,3 @@ func WithSchemaURL(schemaURL string) MeterOption {
return config
})
}
// WithScopeAttributes sets the attributes for the scope of a Meter. The
// attributes are stored as an attribute set. Duplicate values are removed, the
// last value is used.
func WithScopeAttributes(attr ...attribute.KeyValue) MeterOption {
return meterOptionFunc(func(cfg MeterConfig) MeterConfig {
cfg.attributes = attribute.NewSet(attr...)
return cfg
})
}

69
metric/config_test.go
View File

@ -1,69 +0,0 @@
// Copyright The OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package metric // import "go.opentelemetry.io/otel/metric"
import (
"testing"
"github.com/stretchr/testify/assert"
"go.opentelemetry.io/otel/attribute"
)
func TestMeterConfig(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, NewMeterConfig(), MeterConfig{})
})
t.Run("InstrumentationVersion", func(t *testing.T) {
v0, v1 := "v0.1.0", "v1.0.0"
assert.Equal(t, NewMeterConfig(
WithInstrumentationVersion(v0),
).InstrumentationVersion(), v0)
assert.Equal(t, NewMeterConfig(
WithInstrumentationVersion(v0),
WithInstrumentationVersion(v1),
).InstrumentationVersion(), v1, "last option has precedence")
})
t.Run("SchemaURL", func(t *testing.T) {
s120 := "https://opentelemetry.io/schemas/1.2.0"
s130 := "https://opentelemetry.io/schemas/1.3.0"
assert.Equal(t, NewMeterConfig(
WithSchemaURL(s120),
).SchemaURL(), s120)
assert.Equal(t, NewMeterConfig(
WithSchemaURL(s120),
WithSchemaURL(s130),
).SchemaURL(), s130, "last option has precedence")
})
t.Run("Attributes", func(t *testing.T) {
one, two := attribute.Int("key", 1), attribute.Int("key", 2)
assert.Equal(t, NewMeterConfig(
WithScopeAttributes(one, two),
).Attributes(), attribute.NewSet(two), "last attribute is used")
assert.Equal(t, NewMeterConfig(
WithScopeAttributes(two),
WithScopeAttributes(one),
).Attributes(), attribute.NewSet(one), "last option has precedence")
})
}

51
metric/meter.go
View File

@ -24,50 +24,15 @@ import (
"go.opentelemetry.io/otel/metric/instrument/syncint64"
)
// MeterProvider provides Meters that are used by instrumentation code to
// create instruments that measure code operations.
//
// A MeterProvider is the collection destination of all measurements made from
// instruments the provided Meters created, it represents a unique telemetry
// collection pipeline. How that pipeline is defined, meaning how those
// measurements are collected, processed, and where they are exported, depends
// on its implementation. Instrumentation authors do not need to define this
// implementation, rather just use the provided Meters to instrument code.
//
// Commonly, instrumentation code will accept a MeterProvider implementation at
// runtime from its users or it can simply use the globally registered one (see
// https://pkg.go.dev/go.opentelemetry.io/otel/metric/global#MeterProvider).
//
// Warning: methods may be added to this interface in minor releases.
// MeterProvider provides access to named Meter instances, for instrumenting
// an application or library.
type MeterProvider interface {
// Meter returns a unique Meter scoped to be used by instrumentation code
// to measure code operations. The scope and identity of that
// instrumentation code is uniquely defined by the name and options passed.
//
// The passed name needs to uniquely identify instrumentation code.
// Therefore, it is recommended that name is the Go package name of the
// library providing instrumentation (note: not the code being
// instrumented). Instrumentation libraries can have multiple versions,
// therefore, the WithInstrumentationVersion option should be used to
// distinguish these different codebases. Additionally, instrumentation
// libraries may sometimes use metric measurements to communicate different
// domains of code operations data (i.e. using different Meters to
// communicate user experience and back-end operations). If this is the
// case, the WithScopeAttributes option should be used to uniquely identify
// Meters that handle the different domains of code operations data.
//
// If the same name and options are passed multiple times, the same Meter
// will be returned (it is up to the implementation if this will be the
// same underlying instance of that Meter or not). It is not necessary to
// call this multiple times with the same name and options to get an
// up-to-date Meter. All implementations will ensure any MeterProvider
// configuration changes are propagated to all provided Meters.
//
// If name is empty, then an implementation defined default name will be
// used instead.
//
// This method is safe to call concurrently.
Meter(name string, options ...MeterOption) Meter
// Meter creates an instance of a `Meter` interface. The instrumentationName
// must be the name of the library providing instrumentation. This name may
// be the same as the instrumented code only if that code provides built-in
// instrumentation. If the instrumentationName is empty, then a
// implementation defined default name will be used instead.
Meter(instrumentationName string, opts ...MeterOption) Meter
}
// Meter provides access to instrument instances for recording metrics.

18
sdk/instrumentation/scope.go
View File

@ -14,14 +14,7 @@
package instrumentation // import "go.opentelemetry.io/otel/sdk/instrumentation"
import "go.opentelemetry.io/otel/attribute"
// Scope represents the instrumentation source of OpenTelemetry data.
//
// Code that uses OpenTelemetry APIs or data-models to produce telemetry needs
// to be identifiable by the receiver of that data. A Scope is used for this
// purpose, it uniquely identifies that code as the source and the extent to
// which it is relevant.
// Scope represents the instrumentation scope.
type Scope struct {
// Name is the name of the instrumentation scope. This should be the
// Go package name of that scope.
@ -30,13 +23,4 @@ type Scope struct {
Version string
// SchemaURL of the telemetry emitted by the scope.
SchemaURL string
// Attributes describe the unique attributes of an instrumentation scope.
//
// These attributes are used to differentiate an instrumentation scope when
// it emits data that belong to different domains. For example, if both
// profiling data and client-side data are emitted as log records from the
// same instrumentation library, they may need to be differentiated by a
// telemetry receiver. In that case, these attributes are used to scope and
// differentiate the data.
Attributes attribute.Set
}

9
sdk/trace/provider.go
View File

@ -145,7 +145,6 @@ func (p *TracerProvider) Tracer(name string, opts ...trace.TracerOption) trace.T
Name: name,
Version: c.InstrumentationVersion(),
SchemaURL: c.SchemaURL(),
Attributes: c.Attributes(),
}
t, ok := p.namedTracer[is]
if !ok {
@ -154,13 +153,7 @@ func (p *TracerProvider) Tracer(name string, opts ...trace.TracerOption) trace.T
instrumentationScope: is,
}
p.namedTracer[is] = t
global.Info(
"Tracer created",
"name", name,
"version", c.InstrumentationVersion(),
"schemaURL", c.SchemaURL(),
"attributes", c.Attributes(),
)
global.Info("Tracer created", "name", name, "version", c.InstrumentationVersion(), "schemaURL", c.SchemaURL())
}
return t
}

2
sdk/trace/trace_test.go
View File

@ -911,8 +911,6 @@ func TestSetSpanStatusWithoutMessageWhenStatusIsNotError(t *testing.T) {
func cmpDiff(x, y interface{}) string {
return cmp.Diff(x, y,
cmp.AllowUnexported(snapshot{}),
cmp.AllowUnexported(attribute.Set{}),
cmp.AllowUnexported(attribute.Distinct{}),
cmp.AllowUnexported(attribute.Value{}),
cmp.AllowUnexported(Event{}),
cmp.AllowUnexported(trace.TraceState{}))

16
trace/config.go
View File

@ -25,7 +25,6 @@ type TracerConfig struct {
instrumentationVersion string
// Schema URL of the telemetry emitted by the Tracer.
schemaURL string
attributes attribute.Set
}
// InstrumentationVersion returns the version of the library providing instrumentation.
@ -38,11 +37,6 @@ func (t *TracerConfig) SchemaURL() string {
return t.schemaURL
}
// Attributes returns the scope attribute set of the Tracer.
func (t *TracerConfig) Attributes() attribute.Set {
return t.attributes
}
// NewTracerConfig applies all the options to a returned TracerConfig.
func NewTracerConfig(options ...TracerOption) TracerConfig {
var config TracerConfig
@ -320,13 +314,3 @@ func WithSchemaURL(schemaURL string) TracerOption {
return cfg
})
}
// WithScopeAttributes sets the attributes for the scope of a Tracer. The
// attributes are stored as an attribute set. Duplicate values are removed, the
// last value is used.
func WithScopeAttributes(attr ...attribute.KeyValue) TracerOption {
return tracerOptionFunc(func(cfg TracerConfig) TracerConfig {
cfg.attributes = attribute.NewSet(attr...)
return cfg
})
}

19
trace/config_test.go
View File

@ -211,7 +211,6 @@ func TestTracerConfig(t *testing.T) {
v1 := "semver:0.0.1"
v2 := "semver:1.0.0"
schemaURL := "https://opentelemetry.io/schemas/1.2.0"
one, two := attribute.Int("key", 1), attribute.Int("key", 2)
tests := []struct {
options []TracerOption
expected TracerConfig
@ -247,24 +246,6 @@ func TestTracerConfig(t *testing.T) {
schemaURL: schemaURL,
},
},
{
[]TracerOption{
WithScopeAttributes(one, two),
},
TracerConfig{
attributes: attribute.NewSet(two),
},
},
{
[]TracerOption{
WithScopeAttributes(two),
WithScopeAttributes(one),
},
TracerConfig{
attributes: attribute.NewSet(one),
},
},
}
for _, test := range tests {
config := NewTracerConfig(test.options...)