From 8430168e48fda085c370e8b6b3d0e60fb41ede6a Mon Sep 17 00:00:00 2001 From: Eliott Bouhana Date: Fri, 31 Jan 2025 13:30:52 +0100 Subject: [PATCH] add more changes to make the telemetry client work Signed-off-by: Eliott Bouhana --- .../internal/telemetrytest/telemetry_test.go | 7 ++-- ddtrace/opentelemetry/telemetry_test.go | 8 +++-- ddtrace/opentelemetry/tracer.go | 2 +- ddtrace/opentelemetry/tracer_test.go | 6 ++-- ddtrace/opentracer/tracer.go | 4 +-- ddtrace/opentracer/tracer_test.go | 4 ++- ddtrace/tracer/log_test.go | 36 +++++++++---------- ddtrace/tracer/otel_dd_mappings_test.go | 8 +++-- ddtrace/tracer/remote_config_test.go | 30 ++++++++-------- ddtrace/tracer/spancontext_test.go | 10 +++--- ddtrace/tracer/textmap_test.go | 10 +++--- ddtrace/tracer/tracer_test.go | 14 ++++---- 12 files changed, 72 insertions(+), 67 deletions(-) diff --git a/contrib/internal/telemetrytest/telemetry_test.go b/contrib/internal/telemetrytest/telemetry_test.go index 123b2a73ca..237b582a76 100644 --- a/contrib/internal/telemetrytest/telemetry_test.go +++ b/contrib/internal/telemetrytest/telemetry_test.go @@ -14,6 +14,7 @@ import ( "gopkg.in/DataDog/dd-trace-go.v1/contrib/gorilla/mux" "gopkg.in/DataDog/dd-trace-go.v1/internal/telemetry" + "gopkg.in/DataDog/dd-trace-go.v1/internal/telemetry/telemetrytest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -23,13 +24,13 @@ import ( // sends the correct data to the telemetry client. func TestIntegrationInfo(t *testing.T) { // mux.NewRouter() uses the net/http and gorilla/mux integration + client := new(telemetrytest.MockClient) + telemetry.SwapClient(client) mux.NewRouter() - integrations := telemetry.Integrations() + integrations := client.Integrations require.Len(t, integrations, 2) assert.Equal(t, integrations[0].Name, "net/http") - assert.True(t, integrations[0].Enabled) assert.Equal(t, integrations[1].Name, "gorilla/mux") - assert.True(t, integrations[1].Enabled) } type contribPkg struct { diff --git a/ddtrace/opentelemetry/telemetry_test.go b/ddtrace/opentelemetry/telemetry_test.go index 573d6ea699..4d61b40743 100644 --- a/ddtrace/opentelemetry/telemetry_test.go +++ b/ddtrace/opentelemetry/telemetry_test.go @@ -74,15 +74,17 @@ func TestTelemetry(t *testing.T) { t.Setenv(k, v) } telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + original := telemetry.GlobalClient() + telemetry.SwapClient(telemetryClient) + defer telemetry.SwapClient(original) p := NewTracerProvider() p.Tracer("") defer p.Shutdown() assert.True(t, telemetryClient.Started) - telemetry.Check(t, telemetryClient.Configuration, "trace_propagation_style_inject", test.expectedInject) - telemetry.Check(t, telemetryClient.Configuration, "trace_propagation_style_extract", test.expectedExtract) + assert.Contains(t, telemetryClient.Configuration, telemetry.Configuration{Name: "trace_propagation_style_inject", Value: test.expectedInject}) + assert.Contains(t, telemetryClient.Configuration, telemetry.Configuration{Name: "trace_propagation_style_extract", Value: test.expectedExtract}) }) } diff --git a/ddtrace/opentelemetry/tracer.go b/ddtrace/opentelemetry/tracer.go index 42df8e2b6f..bf050b72bf 100644 --- a/ddtrace/opentelemetry/tracer.go +++ b/ddtrace/opentelemetry/tracer.go @@ -50,7 +50,7 @@ func (t *oteltracer) Start(ctx context.Context, spanName string, opts ...oteltra if k := ssConfig.SpanKind(); k != 0 { ddopts = append(ddopts, tracer.Tag(ext.SpanKind, k.String())) } - telemetry.GlobalClient.Count(telemetry.NamespaceTracers, "spans_created", 1.0, telemetryTags, true) + telemetry.Count(telemetry.NamespaceTracers, "spans_created", telemetryTags).Submit(1.0) var cfg ddtrace.StartSpanConfig cfg.Tags = make(map[string]interface{}) for _, attr := range ssConfig.Attributes() { diff --git a/ddtrace/opentelemetry/tracer_test.go b/ddtrace/opentelemetry/tracer_test.go index 9099fc132e..c6139ba5e7 100644 --- a/ddtrace/opentelemetry/tracer_test.go +++ b/ddtrace/opentelemetry/tracer_test.go @@ -196,12 +196,14 @@ func TestShutdownOnce(t *testing.T) { func TestSpanTelemetry(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + original := telemetry.GlobalClient() + telemetry.SwapClient(telemetryClient) + defer telemetry.SwapClient(original) tp := NewTracerProvider() otel.SetTracerProvider(tp) tr := otel.Tracer("") _, _ = tr.Start(context.Background(), "otel.span") - telemetryClient.AssertCalled(t, "Count", telemetry.NamespaceTracers, "spans_created", 1.0, telemetryTags, true) + telemetryClient.AssertCalled(t, "Count", telemetry.NamespaceTracers, "spans_created", telemetryTags) telemetryClient.AssertNumberOfCalls(t, "Count", 1) } diff --git a/ddtrace/opentracer/tracer.go b/ddtrace/opentracer/tracer.go index d91191ebe0..8764d625b4 100644 --- a/ddtrace/opentracer/tracer.go +++ b/ddtrace/opentracer/tracer.go @@ -32,7 +32,7 @@ import ( "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer" "gopkg.in/DataDog/dd-trace-go.v1/internal/telemetry" - opentracing "github.com/opentracing/opentracing-go" + "github.com/opentracing/opentracing-go" ) // New creates, instantiates and returns an Opentracing compatible version of the @@ -67,7 +67,7 @@ func (t *opentracer) StartSpan(operationName string, options ...opentracing.Star for k, v := range sso.Tags { opts = append(opts, tracer.Tag(k, v)) } - telemetry.GlobalClient.Count(telemetry.NamespaceTracers, "spans_created", 1.0, telemetryTags, true) + telemetry.Count(telemetry.NamespaceTracers, "spans_created", telemetryTags).Submit(1.0) return &span{ Span: t.Tracer.StartSpan(operationName, opts...), opentracer: t, diff --git a/ddtrace/opentracer/tracer_test.go b/ddtrace/opentracer/tracer_test.go index 6a57d9a6d3..dfc8574c0e 100644 --- a/ddtrace/opentracer/tracer_test.go +++ b/ddtrace/opentracer/tracer_test.go @@ -116,7 +116,9 @@ func TestExtractError(t *testing.T) { func TestSpanTelemetry(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + original := telemetry.GlobalClient() + telemetry.SwapClient(telemetryClient) + defer telemetry.SwapClient(original) opentracing.SetGlobalTracer(New()) _ = opentracing.StartSpan("opentracing.span") telemetryClient.AssertCalled(t, "Count", telemetry.NamespaceTracers, "spans_created", 1.0, telemetryTags, true) diff --git a/ddtrace/tracer/log_test.go b/ddtrace/tracer/log_test.go index 0b94b91494..dac4da3252 100644 --- a/ddtrace/tracer/log_test.go +++ b/ddtrace/tracer/log_test.go @@ -11,13 +11,11 @@ import ( "regexp" "testing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace" "gopkg.in/DataDog/dd-trace-go.v1/internal/globalconfig" "gopkg.in/DataDog/dd-trace-go.v1/internal/log" - "gopkg.in/DataDog/dd-trace-go.v1/internal/telemetry" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" ) const logPrefixRegexp = `Datadog Tracer v[0-9]+\.[0-9]+\.[0-9]+(-(rc\.[0-9]+|dev))?` @@ -30,7 +28,7 @@ func TestStartupLog(t *testing.T) { defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) assert.Regexp(logPrefixRegexp+` INFO: DATADOG TRACER CONFIGURATION {"date":"[^"]*","os_name":"[^"]*","os_version":"[^"]*","version":"[^"]*","lang":"Go","lang_version":"[^"]*","env":"","service":"tracer\.test(\.exe)?","agent_url":"http://localhost:9/v0.4/traces","agent_error":"Post .*","debug":false,"analytics_enabled":false,"sample_rate":"NaN","sample_rate_limit":"disabled","trace_sampling_rules":null,"span_sampling_rules":null,"sampling_rules_error":"","service_mappings":null,"tags":{"runtime-id":"[^"]*"},"runtime_metrics_enabled":false,"runtime_metrics_v2_enabled":false,"profiler_code_hotspots_enabled":((false)|(true)),"profiler_endpoints_enabled":((false)|(true)),"dd_version":"","architecture":"[^"]*","global_service":"","lambda_mode":"false","appsec":((true)|(false)),"agent_features":{"DropP0s":((true)|(false)),"Stats":((true)|(false)),"StatsdPort":(0|8125)},"integrations":{.*},"partial_flush_enabled":false,"partial_flush_min_spans":1000,"orchestrion":{"enabled":false},"feature_flags":\[\],"propagation_style_inject":"datadog,tracecontext","propagation_style_extract":"datadog,tracecontext","tracing_as_transport":false,"dogstatsd_address":"localhost:8125"}`, tp.Logs()[1]) @@ -62,7 +60,7 @@ func TestStartupLog(t *testing.T) { defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) assert.Regexp(logPrefixRegexp+` INFO: DATADOG TRACER CONFIGURATION {"date":"[^"]*","os_name":"[^"]*","os_version":"[^"]*","version":"[^"]*","lang":"Go","lang_version":"[^"]*","env":"configuredEnv","service":"configured.service","agent_url":"http://localhost:9/v0.4/traces","agent_error":"Post .*","debug":true,"analytics_enabled":true,"sample_rate":"0\.123000","sample_rate_limit":"100","trace_sampling_rules":\[{"service":"mysql","sample_rate":0\.75}\],"span_sampling_rules":null,"sampling_rules_error":"","service_mappings":{"initial_service":"new_service"},"tags":{"runtime-id":"[^"]*","tag":"value","tag2":"NaN"},"runtime_metrics_enabled":true,"runtime_metrics_v2_enabled":false,"profiler_code_hotspots_enabled":((false)|(true)),"profiler_endpoints_enabled":((false)|(true)),"dd_version":"2.3.4","architecture":"[^"]*","global_service":"configured.service","lambda_mode":"false","appsec":((true)|(false)),"agent_features":{"DropP0s":false,"Stats":false,"StatsdPort":(0|8125)},"integrations":{.*},"partial_flush_enabled":false,"partial_flush_min_spans":1000,"orchestrion":{"enabled":true,"metadata":{"version":"v1"}},"feature_flags":\["discovery"\],"propagation_style_inject":"datadog,tracecontext","propagation_style_extract":"datadog,tracecontext","tracing_as_transport":false,"dogstatsd_address":"localhost:8125"}`, tp.Logs()[1]) @@ -92,7 +90,7 @@ func TestStartupLog(t *testing.T) { defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) assert.Regexp(logPrefixRegexp+` INFO: DATADOG TRACER CONFIGURATION {"date":"[^"]*","os_name":"[^"]*","os_version":"[^"]*","version":"[^"]*","lang":"Go","lang_version":"[^"]*","env":"configuredEnv","service":"configured.service","agent_url":"http://localhost:9/v0.4/traces","agent_error":"Post .*","debug":true,"analytics_enabled":true,"sample_rate":"0\.123000","sample_rate_limit":"1000.001","trace_sampling_rules":\[{"service":"mysql","sample_rate":0\.75}\],"span_sampling_rules":null,"sampling_rules_error":"","service_mappings":{"initial_service":"new_service"},"tags":{"runtime-id":"[^"]*","tag":"value","tag2":"NaN"},"runtime_metrics_enabled":true,"runtime_metrics_v2_enabled":false,"profiler_code_hotspots_enabled":((false)|(true)),"profiler_endpoints_enabled":((false)|(true)),"dd_version":"2.3.4","architecture":"[^"]*","global_service":"configured.service","lambda_mode":"false","appsec":((true)|(false)),"agent_features":{"DropP0s":false,"Stats":false,"StatsdPort":(0|8125)},"integrations":{.*},"partial_flush_enabled":false,"partial_flush_min_spans":1000,"orchestrion":{"enabled":false},"feature_flags":\[\],"propagation_style_inject":"datadog,tracecontext","propagation_style_extract":"datadog,tracecontext","tracing_as_transport":false,"dogstatsd_address":"localhost:8125"}`, tp.Logs()[1]) @@ -106,7 +104,7 @@ func TestStartupLog(t *testing.T) { defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) fmt.Println(tp.Logs()[1]) @@ -120,7 +118,7 @@ func TestStartupLog(t *testing.T) { defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) assert.Len(tp.Logs(), 1) assert.Regexp(logPrefixRegexp+` INFO: DATADOG TRACER CONFIGURATION {"date":"[^"]*","os_name":"[^"]*","os_version":"[^"]*","version":"[^"]*","lang":"Go","lang_version":"[^"]*","env":"","service":"tracer\.test(\.exe)?","agent_url":"http://localhost:9/v0.4/traces","agent_error":"","debug":false,"analytics_enabled":false,"sample_rate":"NaN","sample_rate_limit":"disabled","trace_sampling_rules":null,"span_sampling_rules":null,"sampling_rules_error":"","service_mappings":null,"tags":{"runtime-id":"[^"]*"},"runtime_metrics_enabled":false,"runtime_metrics_v2_enabled":false,"profiler_code_hotspots_enabled":((false)|(true)),"profiler_endpoints_enabled":((false)|(true)),"dd_version":"","architecture":"[^"]*","global_service":"","lambda_mode":"true","appsec":((true)|(false)),"agent_features":{"DropP0s":false,"Stats":false,"StatsdPort":(0|8125)},"integrations":{.*},"partial_flush_enabled":false,"partial_flush_min_spans":1000,"orchestrion":{"enabled":false},"feature_flags":\[\],"propagation_style_inject":"datadog,tracecontext","propagation_style_extract":"datadog,tracecontext","tracing_as_transport":false,"dogstatsd_address":"localhost:8125"}`, tp.Logs()[0]) @@ -132,7 +130,7 @@ func TestStartupLog(t *testing.T) { tracer, _, _, stop := startTestTracer(t, WithLogger(tp)) defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) @@ -146,7 +144,7 @@ func TestStartupLog(t *testing.T) { func TestLogSamplingRules(t *testing.T) { assert := assert.New(t) tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") t.Setenv("DD_TRACE_SAMPLING_RULES", `[{"service": "some.service", "sample_rate": 0.234}, {"service": "other.service"}, {"service": "last.service", "sample_rate": 0.56}, {"odd": "pairs"}, {"sample_rate": 9.10}]`) _, _, _, stop := startTestTracer(t, WithLogger(tp), WithEnv("test")) defer stop() @@ -158,7 +156,7 @@ func TestLogSamplingRules(t *testing.T) { func TestLogDefaultSampleRate(t *testing.T) { assert := assert.New(t) tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") log.UseLogger(tp) t.Setenv("DD_TRACE_SAMPLE_RATE", ``) _, _, _, stop := startTestTracer(t, WithLogger(tp), WithEnv("test")) @@ -173,7 +171,7 @@ func TestLogAgentReachable(t *testing.T) { tracer, _, _, stop := startTestTracer(t, WithLogger(tp)) defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) assert.Regexp(logPrefixRegexp+` WARN: DIAGNOSTICS Unable to reach agent intake: Post`, tp.Logs()[0]) @@ -186,7 +184,7 @@ func TestLogFormat(t *testing.T) { tracer, _, _, stop := startTestTracer(t, WithLogger(tp), WithRuntimeMetrics(), WithDebugMode(true)) defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") tracer.StartSpan("test", ServiceName("test-service"), ResourceName("/"), WithSpanID(12345)) assert.Len(tp.Logs(), 1) assert.Regexp(logPrefixRegexp+` DEBUG: Started Span: dd.trace_id="12345" dd.span_id="12345" dd.parent_id="0", Operation: test, Resource: /, Tags: map.*, map.*`, tp.Logs()[0]) @@ -257,7 +255,7 @@ func setup(t *testing.T, customProp Propagator) string { } defer stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) require.Len(t, tp.Logs(), 2) return tp.Logs()[1] @@ -278,7 +276,7 @@ func TestAgentURL(t *testing.T) { tracer := newTracer(WithLogger(tp), WithUDS("var/run/datadog/apm.socket")) defer tracer.Stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) logEntry, found := findLogEntry(tp.Logs(), `"agent_url":"unix://var/run/datadog/apm.socket"`) if !found { @@ -294,7 +292,7 @@ func TestAgentURLFromEnv(t *testing.T) { tracer := newTracer(WithLogger(tp)) defer tracer.Stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) logEntry, found := findLogEntry(tp.Logs(), `"agent_url":"unix://var/run/datadog/apm.socket"`) if !found { @@ -311,7 +309,7 @@ func TestInvalidAgentURL(t *testing.T) { tracer := newTracer(WithLogger(tp)) defer tracer.Stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) logEntry, found := findLogEntry(tp.Logs(), `"agent_url":"http://localhost:8126/v0.4/traces"`) if !found { @@ -328,7 +326,7 @@ func TestAgentURLConflict(t *testing.T) { tracer := newTracer(WithLogger(tp), WithUDS("var/run/datadog/apm.socket"), WithAgentAddr("localhost:8126")) defer tracer.Stop() tp.Reset() - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") logStartup(tracer) logEntry, found := findLogEntry(tp.Logs(), `"agent_url":"http://localhost:8126/v0.4/traces"`) if !found { diff --git a/ddtrace/tracer/otel_dd_mappings_test.go b/ddtrace/tracer/otel_dd_mappings_test.go index 3f85dffa50..65fe5c87ec 100644 --- a/ddtrace/tracer/otel_dd_mappings_test.go +++ b/ddtrace/tracer/otel_dd_mappings_test.go @@ -30,7 +30,9 @@ func TestAssessSource(t *testing.T) { }) t.Run("both", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + original := telemetry.GlobalClient() + telemetry.SwapClient(telemetryClient) + defer telemetry.SwapClient(original) // DD_SERVICE prevails t.Setenv("DD_SERVICE", "abc") t.Setenv("OTEL_SERVICE_NAME", "123") @@ -40,7 +42,9 @@ func TestAssessSource(t *testing.T) { }) t.Run("invalid-ot", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + original := telemetry.GlobalClient() + telemetry.SwapClient(telemetryClient) + defer telemetry.SwapClient(original) t.Setenv("OTEL_LOG_LEVEL", "nonesense") v := getDDorOtelConfig("debugMode") assert.Equal(t, "", v) diff --git a/ddtrace/tracer/remote_config_test.go b/ddtrace/tracer/remote_config_test.go index d64c2666fe..76437404f2 100644 --- a/ddtrace/tracer/remote_config_test.go +++ b/ddtrace/tracer/remote_config_test.go @@ -25,7 +25,7 @@ import ( func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("RC sampling rate = 0.5 is applied and can be reverted", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) defer stop() @@ -96,7 +96,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("DD_TRACE_SAMPLE_RATE=0.1 and RC sampling rate = 0.2", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() t.Setenv("DD_TRACE_SAMPLE_RATE", "0.1") tracer, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) @@ -145,7 +145,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("DD_TRACE_SAMPLING_RULES rate=0.1 and RC trace sampling rules rate = 1.0", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() t.Setenv("DD_TRACE_SAMPLING_RULES", `[{ "service": "my-service", @@ -205,7 +205,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("DD_TRACE_SAMPLING_RULES=0.1 and RC rule rate=1.0 and revert", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() t.Setenv("DD_TRACE_SAMPLING_RULES", `[{ "service": "my-service", @@ -288,7 +288,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("RC rule with tags", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) defer stop() @@ -301,7 +301,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { "provenance": "customer", "sample_rate": 1.0, "tags": [{"key": "tag-a", "value_glob": "tv-a??"}] - }]}, + }]}, "service_target": {"service": "my-service", "env": "my-env"}}`), } applyStatus := tracer.onRemoteConfigUpdate(input) @@ -334,7 +334,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("RC header tags = X-Test-Header:my-tag-name is applied and can be reverted", func(t *testing.T) { defer globalconfig.ClearHeaderTags() telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) defer stop() @@ -380,7 +380,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("RC tracing_enabled = false is applied", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tr, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) defer stop() @@ -437,7 +437,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { func(t *testing.T) { defer globalconfig.ClearHeaderTags() telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() t.Setenv("DD_TRACE_HEADER_TAGS", "X-Test-Header:my-tag-name-from-env") tracer, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) @@ -490,7 +490,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { func(t *testing.T) { defer globalconfig.ClearHeaderTags() telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer( t, @@ -544,7 +544,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("Invalid payload", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer(t, WithService("my-service"), WithEnv("my-env")) defer stop() @@ -566,7 +566,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("Service mismatch", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer(t, WithServiceName("my-service"), WithEnv("my-env")) defer stop() @@ -586,7 +586,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("Env mismatch", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() tracer, _, _, stop := startTestTracer(t, WithServiceName("my-service"), WithEnv("my-env")) defer stop() @@ -606,7 +606,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("DD_TAGS=key0:val0,key1:val1, WithGlobalTag=key2:val2 and RC tags = key3:val3,key4:val4", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() t.Setenv("DD_TAGS", "key0:val0,key1:val1") tracer, _, _, stop := startTestTracer( @@ -677,7 +677,7 @@ func TestOnRemoteConfigUpdate(t *testing.T) { t.Run("Deleted config", func(t *testing.T) { defer globalconfig.ClearHeaderTags() telemetryClient := new(telemetrytest.MockClient) - defer telemetry.MockGlobalClient(telemetryClient)() + defer mockGlobalClient(telemetryClient)() t.Setenv("DD_TRACE_SAMPLE_RATE", "0.1") t.Setenv("DD_TRACE_HEADER_TAGS", "X-Test-Header:my-tag-from-env") diff --git a/ddtrace/tracer/spancontext_test.go b/ddtrace/tracer/spancontext_test.go index 7e86d9fdb1..e6e8d7a51d 100644 --- a/ddtrace/tracer/spancontext_test.go +++ b/ddtrace/tracer/spancontext_test.go @@ -39,7 +39,7 @@ func TestNewSpanContextPushError(t *testing.T) { defer setupteardown(2, 2)() tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") _, _, _, stop := startTestTracer(t, WithLogger(tp), WithLambdaMode(true), WithEnv("testEnv")) defer stop() parent := newBasicSpan("test1") // 1st span in trace @@ -173,8 +173,8 @@ func TestPartialFlush(t *testing.T) { t.Setenv("DD_TRACE_PARTIAL_FLUSH_MIN_SPANS", "2") t.Run("WithFlush", func(t *testing.T) { telemetryClient := new(telemetrytest.MockClient) - telemetryClient.ProductChange(telemetry.NamespaceTracers, true, nil) - defer telemetry.MockGlobalClient(telemetryClient)() + telemetryClient.ProductStarted(telemetry.NamespaceTracers) + defer mockGlobalClient(telemetryClient)() tracer, transport, flush, stop := startTestTracer(t) defer stop() @@ -242,7 +242,7 @@ func TestSpanTracePushNoFinish(t *testing.T) { assert := assert.New(t) tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") _, _, _, stop := startTestTracer(t, WithLogger(tp), WithLambdaMode(true), WithEnv("testEnv")) defer stop() @@ -756,7 +756,7 @@ func TestSpanContextPushFull(t *testing.T) { defer func(old int) { traceMaxSize = old }(traceMaxSize) traceMaxSize = 2 tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") _, _, _, stop := startTestTracer(t, WithLogger(tp), WithLambdaMode(true), WithEnv("testEnv")) defer stop() diff --git a/ddtrace/tracer/textmap_test.go b/ddtrace/tracer/textmap_test.go index 74038fc0c7..f4e6357d16 100644 --- a/ddtrace/tracer/textmap_test.go +++ b/ddtrace/tracer/textmap_test.go @@ -16,16 +16,14 @@ import ( "sync" "testing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/ext" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/internal" "gopkg.in/DataDog/dd-trace-go.v1/internal/httpmem" "gopkg.in/DataDog/dd-trace-go.v1/internal/log" "gopkg.in/DataDog/dd-trace-go.v1/internal/samplernames" - "gopkg.in/DataDog/dd-trace-go.v1/internal/telemetry" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/DataDog/datadog-go/v5/statsd" ) @@ -2092,7 +2090,7 @@ func TestNonePropagator(t *testing.T) { t.Run("inject/none,b3", func(t *testing.T) { t.Setenv(headerPropagationStyleInject, "none,b3") tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") tracer := newTracer(WithLogger(tp), WithEnv("test")) defer tracer.Stop() // reinitializing to capture log output, since propagators are parsed before logger is set @@ -2378,7 +2376,7 @@ func FuzzComposeTracestate(f *testing.F) { if strings.HasSuffix(v, " ") { t.Skipf("Skipping invalid tags") } - totalLen += (len(k) + len(v)) + totalLen += len(k) + len(v) if totalLen > 128 { break } diff --git a/ddtrace/tracer/tracer_test.go b/ddtrace/tracer/tracer_test.go index dd1820621e..408fc628a1 100644 --- a/ddtrace/tracer/tracer_test.go +++ b/ddtrace/tracer/tracer_test.go @@ -26,6 +26,9 @@ import ( pb "github.com/DataDog/datadog-agent/pkg/proto/pbgo/trace" "github.com/DataDog/datadog-go/v5/statsd" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/tinylib/msgp/msgp" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/ext" "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/internal" @@ -33,11 +36,6 @@ import ( "gopkg.in/DataDog/dd-trace-go.v1/internal/globalconfig" "gopkg.in/DataDog/dd-trace-go.v1/internal/log" "gopkg.in/DataDog/dd-trace-go.v1/internal/statsdtest" - "gopkg.in/DataDog/dd-trace-go.v1/internal/telemetry" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - "github.com/tinylib/msgp/msgp" ) func (t *tracer) newEnvSpan(service, env string) *span { @@ -712,7 +710,7 @@ func TestSamplingDecision(t *testing.T) { func TestTracerRuntimeMetrics(t *testing.T) { t.Run("on", func(t *testing.T) { tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") tracer := newTracer(WithRuntimeMetrics(), WithLogger(tp), WithDebugMode(true), WithEnv("test")) defer tracer.Stop() assert.Contains(t, tp.Logs()[0], "DEBUG: Runtime metrics enabled") @@ -721,7 +719,7 @@ func TestTracerRuntimeMetrics(t *testing.T) { t.Run("dd-env", func(t *testing.T) { t.Setenv("DD_RUNTIME_METRICS_ENABLED", "true") tp := new(log.RecordLogger) - tp.Ignore("appsec: ", telemetry.LogPrefix) + tp.Ignore("appsec: ", "telemetry") tracer := newTracer(WithLogger(tp), WithDebugMode(true), WithEnv("test")) defer tracer.Stop() assert.Contains(t, tp.Logs()[0], "DEBUG: Runtime metrics enabled") @@ -1486,7 +1484,7 @@ func TestTracerRace(t *testing.T) { // different orders, and modifying spans after creation. for n := 0; n < total; n++ { i := n // keep local copy - odd := ((i % 2) != 0) + odd := (i % 2) != 0 go func() { if i%11 == 0 { time.Sleep(time.Microsecond)