1
0
mirror of https://github.com/open-telemetry/opentelemetry-go.git synced 2024-12-24 20:14:40 +02:00
opentelemetry-go/bridge/opencensus/internal/tracer_test.go

162 lines
4.7 KiB
Go
Raw Normal View History

// 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 internal_test
import (
"context"
"testing"
octrace "go.opencensus.io/trace"
"go.opentelemetry.io/otel/bridge/opencensus/internal"
"go.opentelemetry.io/otel/bridge/opencensus/internal/oc2otel"
"go.opentelemetry.io/otel/bridge/opencensus/internal/otel2oc"
"go.opentelemetry.io/otel/trace"
)
type handler struct{ err error }
func (h *handler) Handle(e error) { h.err = e }
func withHandler() (*handler, func()) {
h := new(handler)
original := internal.Handle
internal.Handle = h.Handle
return h, func() { internal.Handle = original }
}
type tracer struct {
ctx context.Context
name string
opts []trace.SpanStartOption
}
func (t *tracer) Start(ctx context.Context, name string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
t.ctx, t.name, t.opts = ctx, name, opts
noop := trace.NewNoopTracerProvider().Tracer("testing")
return noop.Start(ctx, name, opts...)
}
type ctxKey string
func TestTracerStartSpan(t *testing.T) {
h, restore := withHandler()
defer restore()
otelTracer := &tracer{}
ocTracer := internal.NewTracer(otelTracer)
ctx := context.WithValue(context.Background(), ctxKey("key"), "value")
name := "testing span"
ocTracer.StartSpan(ctx, name, octrace.WithSpanKind(octrace.SpanKindClient))
if h.err != nil {
t.Fatalf("OC tracer.StartSpan errored: %v", h.err)
}
if otelTracer.ctx != ctx {
t.Error("OTel tracer.Start called with wrong context")
}
if otelTracer.name != name {
t.Error("OTel tracer.Start called with wrong name")
}
sk := trace.SpanKindClient
c := trace.NewSpanStartConfig(otelTracer.opts...)
if c.SpanKind() != sk {
t.Errorf("OTel tracer.Start called with wrong options: %#v", c)
}
}
func TestTracerStartSpanReportsErrors(t *testing.T) {
h, restore := withHandler()
defer restore()
ocTracer := internal.NewTracer(&tracer{})
ocTracer.StartSpan(context.Background(), "", octrace.WithSampler(octrace.AlwaysSample()))
if h.err == nil {
t.Error("OC tracer.StartSpan no error when converting Sampler")
}
}
func TestTracerStartSpanWithRemoteParent(t *testing.T) {
otelTracer := new(tracer)
ocTracer := internal.NewTracer(otelTracer)
sc := octrace.SpanContext{TraceID: [16]byte{1}, SpanID: [8]byte{1}}
converted := oc2otel.SpanContext(sc).WithRemote(true)
ocTracer.StartSpanWithRemoteParent(context.Background(), "", sc)
got := trace.SpanContextFromContext(otelTracer.ctx)
if !got.Equal(converted) {
t.Error("tracer.StartSpanWithRemoteParent failed to set remote parent")
}
}
func TestTracerFromContext(t *testing.T) {
sc := trace.NewSpanContext(trace.SpanContextConfig{
TraceID: [16]byte{1},
SpanID: [8]byte{1},
})
ctx := trace.ContextWithSpanContext(context.Background(), sc)
noop := trace.NewNoopTracerProvider().Tracer("TestTracerFromContext")
// Test using the fact that the No-Op span will propagate a span context .
ctx, _ = noop.Start(ctx, "test")
got := internal.NewTracer(noop).FromContext(ctx).SpanContext()
// Do not test the convedsion, only that the propagtion.
want := otel2oc.SpanContext(sc)
if got != want {
t.Errorf("tracer.FromContext returned wrong context: %#v", got)
}
}
func TestTracerNewContext(t *testing.T) {
sc := trace.NewSpanContext(trace.SpanContextConfig{
TraceID: [16]byte{1},
SpanID: [8]byte{1},
})
ctx := trace.ContextWithSpanContext(context.Background(), sc)
noop := trace.NewNoopTracerProvider().Tracer("TestTracerNewContext")
// Test using the fact that the No-Op span will propagate a span context .
_, s := noop.Start(ctx, "test")
ocTracer := internal.NewTracer(noop)
ctx = ocTracer.NewContext(context.Background(), internal.NewSpan(s))
got := trace.SpanContextFromContext(ctx)
if !got.Equal(sc) {
t.Error("tracer.NewContext did not attach Span to context")
}
}
type differentSpan struct {
octrace.SpanInterface
}
func (s *differentSpan) String() string { return "testing span" }
func TestTracerNewContextErrors(t *testing.T) {
h, restore := withHandler()
defer restore()
ocTracer := internal.NewTracer(&tracer{})
ocSpan := octrace.NewSpan(&differentSpan{})
ocTracer.NewContext(context.Background(), ocSpan)
if h.err == nil {
t.Error("tracer.NewContext did not error for unrecognized span")
}
}