mirror of
https://github.com/open-telemetry/opentelemetry-go.git
synced 2024-12-14 10:13:10 +02:00
347 lines
9.1 KiB
Go
347 lines
9.1 KiB
Go
// 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 jaeger
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"os"
|
|
"sort"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/grpc/codes"
|
|
|
|
"go.opentelemetry.io/otel/api/global"
|
|
"go.opentelemetry.io/otel/api/kv"
|
|
apitrace "go.opentelemetry.io/otel/api/trace"
|
|
gen "go.opentelemetry.io/otel/exporters/trace/jaeger/internal/gen-go/jaeger"
|
|
ottest "go.opentelemetry.io/otel/internal/testing"
|
|
export "go.opentelemetry.io/otel/sdk/export/trace"
|
|
"go.opentelemetry.io/otel/sdk/resource"
|
|
sdktrace "go.opentelemetry.io/otel/sdk/trace"
|
|
)
|
|
|
|
func TestNewExporterPipelineWithRegistration(t *testing.T) {
|
|
tp, fn, err := NewExportPipeline(
|
|
WithCollectorEndpoint("http://localhost:14268/api/traces"),
|
|
RegisterAsGlobal(),
|
|
)
|
|
defer fn()
|
|
assert.NoError(t, err)
|
|
assert.Same(t, tp, global.TraceProvider())
|
|
}
|
|
|
|
func TestNewExporterPipelineWithoutRegistration(t *testing.T) {
|
|
tp, fn, err := NewExportPipeline(
|
|
WithCollectorEndpoint("http://localhost:14268/api/traces"),
|
|
)
|
|
defer fn()
|
|
assert.NoError(t, err)
|
|
assert.NotEqual(t, tp, global.TraceProvider())
|
|
}
|
|
|
|
func TestNewExporterPipelineWithSDK(t *testing.T) {
|
|
tp, fn, err := NewExportPipeline(
|
|
WithCollectorEndpoint("http://localhost:14268/api/traces"),
|
|
WithSDK(&sdktrace.Config{
|
|
DefaultSampler: sdktrace.AlwaysSample(),
|
|
}),
|
|
)
|
|
defer fn()
|
|
assert.NoError(t, err)
|
|
_, span := tp.Tracer("jaeger test").Start(context.Background(), "always-on")
|
|
spanCtx := span.SpanContext()
|
|
assert.True(t, spanCtx.IsSampled())
|
|
span.End()
|
|
|
|
tp2, fn, err := NewExportPipeline(
|
|
WithCollectorEndpoint("http://localhost:14268/api/traces"),
|
|
WithSDK(&sdktrace.Config{
|
|
DefaultSampler: sdktrace.NeverSample(),
|
|
}),
|
|
)
|
|
defer fn()
|
|
assert.NoError(t, err)
|
|
_, span2 := tp2.Tracer("jaeger test").Start(context.Background(), "never")
|
|
span2Ctx := span2.SpanContext()
|
|
assert.False(t, span2Ctx.IsSampled())
|
|
span2.End()
|
|
}
|
|
|
|
func TestNewRawExporter(t *testing.T) {
|
|
const (
|
|
collectorEndpoint = "http://localhost"
|
|
serviceName = "test-service"
|
|
tagKey = "key"
|
|
tagVal = "val"
|
|
)
|
|
// Create Jaeger Exporter
|
|
exp, err := NewRawExporter(
|
|
WithCollectorEndpoint(collectorEndpoint),
|
|
WithProcess(Process{
|
|
ServiceName: serviceName,
|
|
Tags: []kv.KeyValue{
|
|
kv.String(tagKey, tagVal),
|
|
},
|
|
}),
|
|
)
|
|
|
|
assert.NoError(t, err)
|
|
assert.EqualValues(t, serviceName, exp.process.ServiceName)
|
|
assert.Len(t, exp.process.Tags, 1)
|
|
}
|
|
|
|
func TestNewRawExporterShouldFailIfCollectorEndpointEmpty(t *testing.T) {
|
|
// Record and restore env
|
|
envStore := ottest.NewEnvStore()
|
|
envStore.Record(envEndpoint)
|
|
defer func() {
|
|
require.NoError(t, envStore.Restore())
|
|
}()
|
|
|
|
// If the user sets the environment variable JAEGER_ENDPOINT, endpoint will always get a value.
|
|
require.NoError(t, os.Unsetenv(envEndpoint))
|
|
|
|
_, err := NewRawExporter(
|
|
WithCollectorEndpoint(""),
|
|
)
|
|
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
type testCollectorEnpoint struct {
|
|
spansUploaded []*gen.Span
|
|
}
|
|
|
|
func (c *testCollectorEnpoint) upload(batch *gen.Batch) error {
|
|
c.spansUploaded = append(c.spansUploaded, batch.Spans...)
|
|
return nil
|
|
}
|
|
|
|
var _ batchUploader = (*testCollectorEnpoint)(nil)
|
|
|
|
func withTestCollectorEndpoint() func() (batchUploader, error) {
|
|
return func() (batchUploader, error) {
|
|
return &testCollectorEnpoint{}, nil
|
|
}
|
|
}
|
|
|
|
func TestExporter_ExportSpan(t *testing.T) {
|
|
const (
|
|
serviceName = "test-service"
|
|
tagKey = "key"
|
|
tagVal = "val"
|
|
)
|
|
// Create Jaeger Exporter
|
|
exp, err := NewRawExporter(
|
|
withTestCollectorEndpoint(),
|
|
WithProcess(Process{
|
|
ServiceName: serviceName,
|
|
Tags: []kv.KeyValue{
|
|
kv.String(tagKey, tagVal),
|
|
},
|
|
}),
|
|
)
|
|
|
|
assert.NoError(t, err)
|
|
|
|
tp, err := sdktrace.NewProvider(
|
|
sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}),
|
|
sdktrace.WithSyncer(exp))
|
|
|
|
assert.NoError(t, err)
|
|
|
|
global.SetTraceProvider(tp)
|
|
_, span := global.Tracer("test-tracer").Start(context.Background(), "test-span")
|
|
span.End()
|
|
|
|
assert.True(t, span.SpanContext().IsValid())
|
|
|
|
exp.Flush()
|
|
tc := exp.uploader.(*testCollectorEnpoint)
|
|
assert.True(t, len(tc.spansUploaded) == 1)
|
|
}
|
|
|
|
func TestNewRawExporterWithAgentEndpoint(t *testing.T) {
|
|
const agentEndpoint = "localhost:6831"
|
|
// Create Jaeger Exporter
|
|
_, err := NewRawExporter(
|
|
WithAgentEndpoint(agentEndpoint),
|
|
)
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestNewRawExporterWithAgentShouldFailIfEndpointInvalid(t *testing.T) {
|
|
//empty
|
|
_, err := NewRawExporter(
|
|
WithAgentEndpoint(""),
|
|
)
|
|
assert.Error(t, err)
|
|
|
|
//invalid endpoint addr
|
|
_, err = NewRawExporter(
|
|
WithAgentEndpoint("http://localhost"),
|
|
)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func Test_spanDataToThrift(t *testing.T) {
|
|
now := time.Now()
|
|
traceID, _ := apitrace.IDFromHex("0102030405060708090a0b0c0d0e0f10")
|
|
spanID, _ := apitrace.SpanIDFromHex("0102030405060708")
|
|
|
|
linkTraceID, _ := apitrace.IDFromHex("0102030405060709090a0b0c0d0e0f11")
|
|
linkSpanID, _ := apitrace.SpanIDFromHex("0102030405060709")
|
|
|
|
eventNameValue := "event-test"
|
|
keyValue := "value"
|
|
statusCodeValue := int64(2)
|
|
doubleValue := 123.456
|
|
boolTrue := true
|
|
statusMessage := "this is a problem"
|
|
spanKind := "client"
|
|
rv1 := "rv11"
|
|
rv2 := int64(5)
|
|
|
|
tests := []struct {
|
|
name string
|
|
data *export.SpanData
|
|
want *gen.Span
|
|
}{
|
|
{
|
|
name: "no parent",
|
|
data: &export.SpanData{
|
|
SpanContext: apitrace.SpanContext{
|
|
TraceID: traceID,
|
|
SpanID: spanID,
|
|
},
|
|
Name: "/foo",
|
|
StartTime: now,
|
|
EndTime: now,
|
|
Links: []apitrace.Link{
|
|
{
|
|
SpanContext: apitrace.SpanContext{
|
|
TraceID: linkTraceID,
|
|
SpanID: linkSpanID,
|
|
},
|
|
},
|
|
},
|
|
Attributes: []kv.KeyValue{
|
|
kv.String("key", keyValue),
|
|
kv.Float64("double", doubleValue),
|
|
// Jaeger doesn't handle Uint tags, this should be ignored.
|
|
kv.Uint64("ignored", 123),
|
|
},
|
|
MessageEvents: []export.Event{
|
|
{Name: eventNameValue, Attributes: []kv.KeyValue{kv.String("k1", keyValue)}, Time: now},
|
|
},
|
|
StatusCode: codes.Unknown,
|
|
StatusMessage: statusMessage,
|
|
SpanKind: apitrace.SpanKindClient,
|
|
Resource: resource.New(kv.String("rk1", rv1), kv.Int64("rk2", rv2)),
|
|
},
|
|
want: &gen.Span{
|
|
TraceIdLow: 651345242494996240,
|
|
TraceIdHigh: 72623859790382856,
|
|
SpanId: 72623859790382856,
|
|
OperationName: "/foo",
|
|
StartTime: now.UnixNano() / 1000,
|
|
Duration: 0,
|
|
Tags: []*gen.Tag{
|
|
{Key: "double", VType: gen.TagType_DOUBLE, VDouble: &doubleValue},
|
|
{Key: "key", VType: gen.TagType_STRING, VStr: &keyValue},
|
|
{Key: "error", VType: gen.TagType_BOOL, VBool: &boolTrue},
|
|
{Key: "status.code", VType: gen.TagType_LONG, VLong: &statusCodeValue},
|
|
{Key: "status.message", VType: gen.TagType_STRING, VStr: &statusMessage},
|
|
{Key: "span.kind", VType: gen.TagType_STRING, VStr: &spanKind},
|
|
{Key: "rk1", VType: gen.TagType_STRING, VStr: &rv1},
|
|
{Key: "rk2", VType: gen.TagType_LONG, VLong: &rv2},
|
|
},
|
|
References: []*gen.SpanRef{
|
|
{
|
|
RefType: gen.SpanRefType_CHILD_OF,
|
|
TraceIdHigh: int64(binary.BigEndian.Uint64(linkTraceID[0:8])),
|
|
TraceIdLow: int64(binary.BigEndian.Uint64(linkTraceID[8:16])),
|
|
SpanId: int64(binary.BigEndian.Uint64(linkSpanID[:])),
|
|
},
|
|
},
|
|
Logs: []*gen.Log{
|
|
{
|
|
Timestamp: now.UnixNano() / 1000,
|
|
Fields: []*gen.Tag{
|
|
{
|
|
Key: "k1",
|
|
VStr: &keyValue,
|
|
VType: gen.TagType_STRING,
|
|
},
|
|
{
|
|
Key: "name",
|
|
VStr: &eventNameValue,
|
|
VType: gen.TagType_STRING,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got := spanDataToThrift(tt.data)
|
|
sort.Slice(got.Tags, func(i, j int) bool {
|
|
return got.Tags[i].Key < got.Tags[j].Key
|
|
})
|
|
sort.Slice(tt.want.Tags, func(i, j int) bool {
|
|
return tt.want.Tags[i].Key < tt.want.Tags[j].Key
|
|
})
|
|
if diff := cmp.Diff(got, tt.want); diff != "" {
|
|
t.Errorf("Diff%v", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNewExporterPipelineWithDisabled(t *testing.T) {
|
|
tp, fn, err := NewExportPipeline(
|
|
WithCollectorEndpoint("http://localhost:14268/api/traces"),
|
|
WithDisabled(true),
|
|
)
|
|
defer fn()
|
|
assert.NoError(t, err)
|
|
assert.IsType(t, &apitrace.NoopProvider{}, tp)
|
|
}
|
|
|
|
func TestNewExporterPipelineWithDisabledFromEnv(t *testing.T) {
|
|
envStore, err := ottest.SetEnvVariables(map[string]string{
|
|
envDisabled: "true",
|
|
})
|
|
require.NoError(t, err)
|
|
envStore.Record(envDisabled)
|
|
defer func() {
|
|
require.NoError(t, envStore.Restore())
|
|
}()
|
|
|
|
tp, fn, err := NewExportPipeline(
|
|
WithCollectorEndpoint("http://localhost:14268/api/traces"),
|
|
)
|
|
defer fn()
|
|
assert.NoError(t, err)
|
|
assert.IsType(t, &apitrace.NoopProvider{}, tp)
|
|
}
|