From 9998f977463623033de12c887e710659a16d6c13 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 3 Sep 2025 13:56:26 -0400 Subject: [PATCH 01/25] migrating datadog-lambda-go --- contrib/aws/datadog-lambda-go/CONTRIBUTING.md | 19 + contrib/aws/datadog-lambda-go/README.md | 39 ++ .../aws/datadog-lambda-go/awslambdanorpc.go | 14 + .../aws/datadog-lambda-go/awslambdawithrpc.go | 14 + contrib/aws/datadog-lambda-go/ddlambda.go | 404 ++++++++++++++++++ .../ddlambda_example_test.go | 54 +++ .../aws/datadog-lambda-go/ddlambda_test.go | 205 +++++++++ .../internal/extension/extension.go | 236 ++++++++++ .../internal/extension/extension_test.go | 298 +++++++++++++ .../datadog-lambda-go/internal/logger/log.go | 86 ++++ .../datadog-lambda-go/internal/metrics/api.go | 152 +++++++ .../internal/metrics/api_test.go | 172 ++++++++ .../internal/metrics/batcher.go | 78 ++++ .../internal/metrics/batcher_test.go | 150 +++++++ .../internal/metrics/constants.go | 30 ++ .../internal/metrics/context.go | 29 ++ .../internal/metrics/context_test.go | 30 ++ .../internal/metrics/kms_decrypter.go | 102 +++++ .../internal/metrics/kms_decrypter_test.go | 76 ++++ .../internal/metrics/listener.go | 288 +++++++++++++ .../internal/metrics/listener_test.go | 292 +++++++++++++ .../internal/metrics/model.go | 96 +++++ .../internal/metrics/processor.go | 189 ++++++++ .../internal/metrics/processor_test.go | 259 +++++++++++ .../internal/metrics/time.go | 35 ++ .../testdata/apig-event-no-headers.json | 57 +++ .../testdata/apig-event-with-headers.json | 60 +++ .../internal/testdata/invalid.json | 3 + .../testdata/non-proxy-no-headers.json | 6 + .../testdata/non-proxy-with-headers.json | 11 + ...-proxy-with-missing-sampling-priority.json | 10 + .../non-proxy-with-mixed-case-headers.json | 11 + .../internal/trace/constants.go | 28 ++ .../internal/trace/context.go | 294 +++++++++++++ .../internal/trace/context_test.go | 302 +++++++++++++ .../internal/trace/listener.go | 203 +++++++++ .../internal/trace/listener_test.go | 176 ++++++++ .../internal/version/version.go | 11 + .../internal/wrapper/wrap_handler.go | 202 +++++++++ .../internal/wrapper/wrap_handler_test.go | 300 +++++++++++++ .../datadog-lambda-go/lambdatest/README.md | 16 + .../datadog-lambda-go/lambdatest/error/go.mod | 73 ++++ .../datadog-lambda-go/lambdatest/error/go.sum | 263 ++++++++++++ .../lambdatest/error/main.go | 22 + .../datadog-lambda-go/lambdatest/hello/go.mod | 79 ++++ .../datadog-lambda-go/lambdatest/hello/go.sum | 277 ++++++++++++ .../lambdatest/hello/main.go | 48 +++ .../input_events/api-gateway-get.json | 55 +++ .../datadog-lambda-go/lambdatest/package.json | 4 + .../lambdatest/parse-json.js | 17 + .../lambdatest/run_integration_tests.sh | 210 +++++++++ .../lambdatest/serverless.yml | 37 ++ .../lambdatest/snapshots/logs/error.log | 46 ++ .../lambdatest/snapshots/logs/hello.log | 45 ++ .../return_values/error_api-gateway-get.json | 1 + .../return_values/hello_api-gateway-get.json | 6 + go.mod | 21 + go.sum | 46 ++ go.work.sum | 1 + 59 files changed, 6288 insertions(+) create mode 100644 contrib/aws/datadog-lambda-go/CONTRIBUTING.md create mode 100644 contrib/aws/datadog-lambda-go/README.md create mode 100644 contrib/aws/datadog-lambda-go/awslambdanorpc.go create mode 100644 contrib/aws/datadog-lambda-go/awslambdawithrpc.go create mode 100644 contrib/aws/datadog-lambda-go/ddlambda.go create mode 100644 contrib/aws/datadog-lambda-go/ddlambda_example_test.go create mode 100644 contrib/aws/datadog-lambda-go/ddlambda_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/extension/extension.go create mode 100644 contrib/aws/datadog-lambda-go/internal/extension/extension_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/logger/log.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/api.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/api_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/batcher.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/constants.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/context.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/context_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/listener.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/model.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/processor.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/metrics/time.go create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/apig-event-no-headers.json create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/apig-event-with-headers.json create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/invalid.json create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-no-headers.json create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-headers.json create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-missing-sampling-priority.json create mode 100644 contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-mixed-case-headers.json create mode 100644 contrib/aws/datadog-lambda-go/internal/trace/constants.go create mode 100644 contrib/aws/datadog-lambda-go/internal/trace/context.go create mode 100644 contrib/aws/datadog-lambda-go/internal/trace/context_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/trace/listener.go create mode 100644 contrib/aws/datadog-lambda-go/internal/trace/listener_test.go create mode 100644 contrib/aws/datadog-lambda-go/internal/version/version.go create mode 100644 contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go create mode 100644 contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/README.md create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/error/go.mod create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/error/go.sum create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/error/main.go create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/hello/main.go create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/package.json create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/parse-json.js create mode 100755 contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/serverless.yml create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json create mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json diff --git a/contrib/aws/datadog-lambda-go/CONTRIBUTING.md b/contrib/aws/datadog-lambda-go/CONTRIBUTING.md new file mode 100644 index 0000000000..c1950c5d35 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/CONTRIBUTING.md @@ -0,0 +1,19 @@ +# Contributing + +We love pull requests. For new features, consider opening an issue to discuss the idea first. When you're ready to open a pull requset, here's a quick guide. + +1. Fork, clone and branch off: + ```bash + git clone git@github.com:/datadog-lambda-go.git + git checkout -b + ``` +1. Make your changes, update tests and ensure the tests pass: + ```bash + go test ./... + ``` +1. Build and test your own serverless application with your modified version of `datadog-lambda-go`. +1. Push to your fork and [submit a pull request][pr]. + +[pr]: https://github.com/your-username/datadog-lambda-go/compare/DataDog:main...main + +At this point you're waiting on us. We may suggest some changes or improvements or alternatives. diff --git a/contrib/aws/datadog-lambda-go/README.md b/contrib/aws/datadog-lambda-go/README.md new file mode 100644 index 0000000000..8c5c90fc9b --- /dev/null +++ b/contrib/aws/datadog-lambda-go/README.md @@ -0,0 +1,39 @@ +# datadog-lambda-go + +![build](https://github.com/DataDog/datadog-lambda-go/workflows/build/badge.svg) +[![Code Coverage](https://img.shields.io/codecov/c/github/DataDog/datadog-lambda-go)](https://codecov.io/gh/DataDog/datadog-lambda-go) +[![Slack](https://chat.datadoghq.com/badge.svg?bg=632CA6)](https://chat.datadoghq.com/) +[![Godoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/DataDog/datadog-lambda-go) +[![License](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/DataDog/datadog-lambda-go/blob/main/LICENSE) + +Datadog Lambda Library for Go enables enhanced Lambda metrics, distributed tracing, and custom metric submission from AWS Lambda functions. + +## Installation + +Follow the [installation instructions](https://docs.datadoghq.com/serverless/installation/go/), and view your function's enhanced metrics, traces and logs in Datadog. + +## Configurations + +See the [advanced configuration options](https://docs.datadoghq.com/serverless/configuration) to tag your telemetry, capture request/response payloads, filter or scrub sensitive information from logs or traces, and more. + +## Opening Issues + +If you encounter a bug with this package, we want to hear about it. Before opening a new issue, search the existing issues to avoid duplicates. + +When opening an issue, include the datadog-lambda-go version, `go version`, and stack trace if available. In addition, include the steps to reproduce when appropriate. + +You can also open an issue for a feature request. + +## Contributing + +If you find an issue with this package and have a fix, please feel free to open a pull request following the [procedures](https://github.com/DataDog/datadog-lambda-go/blob/main/CONTRIBUTING.md). + +## Community + +For product feedback and questions, join the `#serverless` channel in the [Datadog community on Slack](https://chat.datadoghq.com/). + +## License + +Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0. + +This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc. diff --git a/contrib/aws/datadog-lambda-go/awslambdanorpc.go b/contrib/aws/datadog-lambda-go/awslambdanorpc.go new file mode 100644 index 0000000000..287a285da8 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/awslambdanorpc.go @@ -0,0 +1,14 @@ +//go:build lambda.norpc +// +build lambda.norpc + +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package ddlambda + +const awsLambdaRpcSupport = false diff --git a/contrib/aws/datadog-lambda-go/awslambdawithrpc.go b/contrib/aws/datadog-lambda-go/awslambdawithrpc.go new file mode 100644 index 0000000000..994629a11a --- /dev/null +++ b/contrib/aws/datadog-lambda-go/awslambdawithrpc.go @@ -0,0 +1,14 @@ +//go:build !lambda.norpc +// +build !lambda.norpc + +/* +* Unless explicitly stated otherwise all files in this repository are licensed +* under the Apache License Version 2.0. +* +* This product includes software developed at Datadog (https://www.datadoghq.com/). +* Copyright 2021 Datadog, Inc. + */ + +package ddlambda + +const awsLambdaRpcSupport = true diff --git a/contrib/aws/datadog-lambda-go/ddlambda.go b/contrib/aws/datadog-lambda-go/ddlambda.go new file mode 100644 index 0000000000..46dc2725f7 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/ddlambda.go @@ -0,0 +1,404 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package ddlambda + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + "os" + "strconv" + "strings" + "time" + + "github.com/aws/aws-lambda-go/lambda" + "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/metrics" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/trace" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/wrapper" +) + +type ( + // Config gives options for how ddlambda should behave + Config struct { + // APIKey is your Datadog API key. This is used for sending metrics. + APIKey string + // KMSAPIKey is your Datadog API key, encrypted using the AWS KMS service. This is used for sending metrics. + KMSAPIKey string + // ShouldRetryOnFailure is used to turn on retry logic when sending metrics via the API. This can negatively effect the performance of your lambda, + // and should only be turned on if you can't afford to lose metrics data under poor network conditions. + ShouldRetryOnFailure bool + // ShouldUseLogForwarder enabled the log forwarding method for sending metrics to Datadog. This approach requires the user to set up a custom lambda + // function that forwards metrics from cloudwatch to the Datadog api. This approach doesn't have any impact on the performance of your lambda function. + ShouldUseLogForwarder bool + // BatchInterval is the period of time which metrics are grouped together for processing to be sent to the API or written to logs. + // Any pending metrics are flushed at the end of the lambda. + BatchInterval time.Duration + // Site is the host to send metrics to. If empty, this value is read from the 'DD_SITE' environment variable, or if that is empty + // will default to 'datadoghq.com'. + Site string + // DebugLogging will turn on extended debug logging. + DebugLogging bool + // EnhancedMetrics enables the reporting of enhanced metrics under `aws.lambda.enhanced*` and adds enhanced metric tags + EnhancedMetrics bool + // DDTraceEnabled enables the Datadog tracer. + DDTraceEnabled bool + // MergeXrayTraces will cause Datadog traces to be merged with traces from AWS X-Ray. + MergeXrayTraces bool + // HTTPClientTimeout specifies a time limit for requests to the API. It defaults to 5s. + HTTPClientTimeout time.Duration + // CircuitBreakerInterval is the cyclic period of the closed state + // for the CircuitBreaker to clear the internal Counts. + // default: 30s + CircuitBreakerInterval time.Duration + // CircuitBreakerTimeout is the period of the open state, + // after which the state of the CircuitBreaker becomes half-open. + // default: 60s + CircuitBreakerTimeout time.Duration + // CircuitBreakerTotalFailures after this amount of times + // of a request failing in the closed state, the state will become open. + // the counter will get totally reset after CircuitBreakerInterval + // default: 4 + CircuitBreakerTotalFailures uint32 + // FIPSMode enables FIPS mode. Defaults to true in GovCloud regions and false elsewhere. + FIPSMode *bool + // TraceContextExtractor is the function that extracts a root/parent trace context from the Lambda event body. + // See trace.DefaultTraceExtractor for an example. + TraceContextExtractor trace.ContextExtractor + // TracerOptions are additional options passed to the tracer. + TracerOptions []tracer.StartOption + } +) + +const ( + // DatadogAPIKeyEnvVar is the environment variable that will be used to set the API key. + DatadogAPIKeyEnvVar = "DD_API_KEY" + // DatadogKMSAPIKeyEnvVar is the environment variable that will be sent to KMS for decryption, then used as an API key. + DatadogKMSAPIKeyEnvVar = "DD_KMS_API_KEY" + // DatadogSiteEnvVar is the environment variable that will be used as the API host. + DatadogSiteEnvVar = "DD_SITE" + // LogLevelEnvVar is the environment variable that will be used to set the log level. + LogLevelEnvVar = "DD_LOG_LEVEL" + // ShouldUseLogForwarderEnvVar is the environment variable that enables log forwarding of metrics. + ShouldUseLogForwarderEnvVar = "DD_FLUSH_TO_LOG" + // DatadogTraceEnabledEnvVar is the environment variable that enables Datadog tracing. + DatadogTraceEnabledEnvVar = "DD_TRACE_ENABLED" + // MergeXrayTracesEnvVar is the environment variable that enables the merging of X-Ray and Datadog traces. + MergeXrayTracesEnvVar = "DD_MERGE_XRAY_TRACES" + // UniversalInstrumentation is the environment variable that enables universal instrumentation with the DD Extension + UniversalInstrumentation = "DD_UNIVERSAL_INSTRUMENTATION" + // Initialize otel tracer provider if enabled + OtelTracerEnabled = "DD_TRACE_OTEL_ENABLED" + // FIPSModeEnvVar is the environment variable that determines whether to enable FIPS mode. + // Defaults to true in GovCloud regions and false otherwise. + FIPSModeEnvVar = "DD_LAMBDA_FIPS_MODE" + + // DefaultSite to send API messages to. + DefaultSite = "datadoghq.com" + // DefaultEnhancedMetrics enables enhanced metrics by default. + DefaultEnhancedMetrics = true + + // serverlessAppSecEnabledEnvVar is the environment variable used to activate Serverless ASM through the use of an + // AWS Lambda runtime API proxy. + serverlessAppSecEnabledEnvVar = "DD_SERVERLESS_APPSEC_ENABLED" + // awsLambdaRuntimeApiEnvVar is the environment variable used to redirect AWS Lambda runtime API calls to the proxy. + awsLambdaRuntimeApiEnvVar = "AWS_LAMBDA_RUNTIME_API" + // datadogAgentUrl is the URL of the agent and proxy started by the Datadog lambda extension. + datadogAgentUrl = "127.0.0.1:9000" + // ddExtensionFilePath is the path on disk of the datadog lambda extension. + ddExtensionFilePath = "/opt/extensions/datadog-agent" + + // awsLambdaServerPortEnvVar is the environment variable set by the go1.x Lambda Runtime to indicate which port the + // RCP server should listen on. This is used as a sign that a warning should be printed if customers want to enable + // ASM support, but did not enable the lambda.norpc build taf. + awsLambdaServerPortEnvVar = "_LAMBDA_SERVER_PORT" +) + +// WrapLambdaHandlerInterface is used to instrument your lambda functions. +// It returns a modified handler that can be passed directly to the lambda.StartHandler function from aws-lambda-go. +func WrapLambdaHandlerInterface(handler lambda.Handler, cfg *Config) lambda.Handler { + setupAppSec() + listeners := initializeListeners(cfg) + return wrapper.WrapHandlerInterfaceWithListeners(handler, listeners...) +} + +// WrapFunction is used to instrument your lambda functions. +// It returns a modified handler that can be passed directly to the lambda.Start function from aws-lambda-go. +func WrapFunction(handler interface{}, cfg *Config) interface{} { + setupAppSec() + listeners := initializeListeners(cfg) + return wrapper.WrapHandlerWithListeners(handler, listeners...) +} + +// WrapHandler is used to instrument your lambda functions. +// It returns a modified handler that can be passed directly to the lambda.Start function from aws-lambda-go. +// Deprecated: use WrapFunction instead +func WrapHandler(handler interface{}, cfg *Config) interface{} { + return WrapFunction(handler, cfg) +} + +// GetTraceHeaders returns a map containing Datadog trace headers that reflect the +// current X-Ray subsegment. +// Deprecated: use native Datadog tracing instead. +func GetTraceHeaders(ctx context.Context) map[string]string { + result := trace.ConvertCurrentXrayTraceContext(ctx) + return result +} + +// AddTraceHeaders adds Datadog trace headers to a HTTP Request reflecting the current X-Ray +// subsegment. +// Deprecated: use native Datadog tracing instead. +func AddTraceHeaders(ctx context.Context, req *http.Request) { + headers := trace.ConvertCurrentXrayTraceContext(ctx) + for key, value := range headers { + req.Header.Add(key, value) + } +} + +// GetContext retrieves the last created lambda context. +// Only use this if you aren't manually passing context through your call hierarchy. +func GetContext() context.Context { + return wrapper.CurrentContext +} + +// Distribution sends a distribution metric to Datadog +// Deprecated: Use Metric method instead +func Distribution(metric string, value float64, tags ...string) { + Metric(metric, value, tags...) +} + +// Metric sends a distribution metric to DataDog +func Metric(metric string, value float64, tags ...string) { + MetricWithTimestamp(metric, value, time.Now(), tags...) +} + +// MetricWithTimestamp sends a distribution metric to DataDog with a custom timestamp +func MetricWithTimestamp(metric string, value float64, timestamp time.Time, tags ...string) { + ctx := GetContext() + + if ctx == nil { + logger.Debug("no context available, did you wrap your handler?") + return + } + + listener := metrics.GetListener(ctx) + + if listener == nil { + logger.Error(fmt.Errorf("couldn't get metrics listener from current context")) + return + } + listener.AddDistributionMetric(metric, value, timestamp, false, tags...) +} + +// InvokeDryRun is a utility to easily run your lambda for testing +func InvokeDryRun(callback func(ctx context.Context), cfg *Config) (interface{}, error) { + wrapped := WrapHandler(callback, cfg) + // Convert the wrapped handler to it's underlying raw handler type + handler, ok := wrapped.(func(ctx context.Context, msg json.RawMessage) (interface{}, error)) + if !ok { + logger.Debug("Could not unwrap lambda during dry run") + } + return handler(context.Background(), json.RawMessage("{}")) +} + +func (cfg *Config) toTraceConfig() trace.Config { + traceConfig := trace.Config{ + DDTraceEnabled: true, + MergeXrayTraces: false, + UniversalInstrumentation: true, + OtelTracerEnabled: false, + } + + if cfg != nil { + traceConfig.DDTraceEnabled = cfg.DDTraceEnabled + traceConfig.MergeXrayTraces = cfg.MergeXrayTraces + traceConfig.TraceContextExtractor = cfg.TraceContextExtractor + traceConfig.TracerOptions = cfg.TracerOptions + } + + if traceConfig.TraceContextExtractor == nil { + traceConfig.TraceContextExtractor = trace.DefaultTraceExtractor + } + + if tracingEnabled, err := strconv.ParseBool(os.Getenv(DatadogTraceEnabledEnvVar)); err == nil { + traceConfig.DDTraceEnabled = tracingEnabled + // Only read the OTEL env var if DD tracing is enabled + if tracingEnabled { + if otelTracerEnabled, err := strconv.ParseBool(os.Getenv(OtelTracerEnabled)); err == nil { + traceConfig.OtelTracerEnabled = otelTracerEnabled + } + } + } + + if !traceConfig.MergeXrayTraces { + traceConfig.MergeXrayTraces, _ = strconv.ParseBool(os.Getenv(MergeXrayTracesEnvVar)) + } + + if universalInstrumentation, err := strconv.ParseBool(os.Getenv(UniversalInstrumentation)); err == nil { + traceConfig.UniversalInstrumentation = universalInstrumentation + } + + return traceConfig +} + +func initializeListeners(cfg *Config) []wrapper.HandlerListener { + logLevel := os.Getenv(LogLevelEnvVar) + if strings.EqualFold(logLevel, "debug") || (cfg != nil && cfg.DebugLogging) { + logger.SetLogLevel(logger.LevelDebug) + } + traceConfig := cfg.toTraceConfig() + extensionManager := extension.BuildExtensionManager(traceConfig.UniversalInstrumentation) + isExtensionRunning := extensionManager.IsExtensionRunning() + metricsConfig := cfg.toMetricsConfig(isExtensionRunning) + + // Wrap the handler with listeners that add instrumentation for traces and metrics. + tl := trace.MakeListener(traceConfig, extensionManager) + ml := metrics.MakeListener(metricsConfig, extensionManager) + return []wrapper.HandlerListener{ + &tl, &ml, + } +} + +func (cfg *Config) toMetricsConfig(isExtensionRunning bool) metrics.Config { + + mc := metrics.Config{ + ShouldRetryOnFailure: false, + FIPSMode: cfg.calculateFipsMode(), + } + + if cfg != nil { + mc.BatchInterval = cfg.BatchInterval + mc.ShouldRetryOnFailure = cfg.ShouldRetryOnFailure + mc.APIKey = cfg.APIKey + mc.KMSAPIKey = cfg.KMSAPIKey + mc.Site = cfg.Site + mc.ShouldUseLogForwarder = cfg.ShouldUseLogForwarder + mc.HTTPClientTimeout = cfg.HTTPClientTimeout + } + + if mc.Site == "" { + mc.Site = os.Getenv(DatadogSiteEnvVar) + } + if mc.Site == "" { + mc.Site = DefaultSite + } + if strings.HasPrefix(mc.Site, "https://") || strings.HasPrefix(mc.Site, "http://") { + mc.Site = fmt.Sprintf("%s/api/v1", mc.Site) + } else { + mc.Site = fmt.Sprintf("https://api.%s/api/v1", mc.Site) + } + + if !mc.ShouldUseLogForwarder { + shouldUseLogForwarder := os.Getenv(ShouldUseLogForwarderEnvVar) + mc.ShouldUseLogForwarder = strings.EqualFold(shouldUseLogForwarder, "true") + } + + if mc.APIKey == "" { + mc.APIKey = os.Getenv(DatadogAPIKeyEnvVar) + + } + if mc.KMSAPIKey == "" { + mc.KMSAPIKey = os.Getenv(DatadogKMSAPIKeyEnvVar) + } + if !isExtensionRunning && mc.APIKey == "" && mc.KMSAPIKey == "" && !mc.ShouldUseLogForwarder { + logger.Error(fmt.Errorf( + "couldn't read %s or %s from environment", DatadogAPIKeyEnvVar, DatadogKMSAPIKeyEnvVar, + )) + } + + enhancedMetrics := os.Getenv("DD_ENHANCED_METRICS") + if enhancedMetrics == "" { + mc.EnhancedMetrics = DefaultEnhancedMetrics + } + if !mc.EnhancedMetrics { + mc.EnhancedMetrics = strings.EqualFold(enhancedMetrics, "true") + } + + if localTest := os.Getenv("DD_LOCAL_TEST"); localTest == "1" || strings.ToLower(localTest) == "true" { + mc.LocalTest = true + } + + return mc +} + +func (cfg *Config) calculateFipsMode() bool { + if cfg != nil && cfg.FIPSMode != nil { + return *cfg.FIPSMode + } + + region := os.Getenv("AWS_REGION") + isGovCloud := strings.HasPrefix(region, "us-gov-") + + fipsMode := isGovCloud + + fipsModeEnv := os.Getenv(FIPSModeEnvVar) + if fipsModeEnv != "" { + if parsedFipsMode, err := strconv.ParseBool(fipsModeEnv); err == nil { + fipsMode = parsedFipsMode + } else { + logger.Debug(fmt.Sprintf("could not parse %s: %s", fipsModeEnv, err)) + } + } + + if fipsMode || isGovCloud { + if fipsMode { + logger.Debug("Go Lambda Layer FIPS mode enabled") + } else { + logger.Debug("Go Lambda Layer FIPS mode disabled") + } + } + + return fipsMode +} + +// setupAppSec checks if DD_SERVERLESS_APPSEC_ENABLED is set (to true) and when that +// is the case, redirects `AWS_LAMBDA_RUNTIME_API` to the agent extension, and turns +// on universal instrumentation unless it was already configured by the customer, so +// that the HTTP context (invocation details span tags) is available on AppSec traces. +func setupAppSec() { + enabled := false + if env := os.Getenv(serverlessAppSecEnabledEnvVar); env != "" { + if on, err := strconv.ParseBool(env); err == nil { + enabled = on + } + } + + if !enabled { + return + } + + if _, err := os.Stat(ddExtensionFilePath); os.IsNotExist(err) { + logger.Debug(fmt.Sprintf("%s is enabled, but the Datadog extension was not found at %s", serverlessAppSecEnabledEnvVar, ddExtensionFilePath)) + return + } + + if awsLambdaRpcSupport { + if port := os.Getenv(awsLambdaServerPortEnvVar); port != "" { + logger.Warn(fmt.Sprintf("%s activation with the go1.x AWS Lambda runtime requires setting the `lambda.norpc` go build tag", serverlessAppSecEnabledEnvVar)) + } + } + + if err := os.Setenv(awsLambdaRuntimeApiEnvVar, datadogAgentUrl); err != nil { + logger.Debug(fmt.Sprintf("failed to set %s=%s: %v", awsLambdaRuntimeApiEnvVar, datadogAgentUrl, err)) + } else { + logger.Debug(fmt.Sprintf("successfully set %s=%s", awsLambdaRuntimeApiEnvVar, datadogAgentUrl)) + } + + if val := os.Getenv(UniversalInstrumentation); val == "" { + if err := os.Setenv(UniversalInstrumentation, "1"); err != nil { + logger.Debug(fmt.Sprintf("failed to set %s=%d: %v", UniversalInstrumentation, 1, err)) + } else { + logger.Debug(fmt.Sprintf("successfully set %s=%d", UniversalInstrumentation, 1)) + } + } +} diff --git a/contrib/aws/datadog-lambda-go/ddlambda_example_test.go b/contrib/aws/datadog-lambda-go/ddlambda_example_test.go new file mode 100644 index 0000000000..1e2a9dc593 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/ddlambda_example_test.go @@ -0,0 +1,54 @@ +package ddlambda_test + +import ( + "context" + "encoding/json" + "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "strings" + "testing" + + "github.com/aws/aws-lambda-go/events" + + ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" +) + +var exampleSQSExtractor = func(ctx context.Context, ev json.RawMessage) map[string]string { + eh := events.SQSEvent{} + + headers := map[string]string{} + + if err := json.Unmarshal(ev, &eh); err != nil { + return headers + } + + // Using SQS as a trigger with a batchSize=1 so its important we check for this as a single SQS message + // will drive the execution of the handler. + if len(eh.Records) != 1 { + return headers + } + + record := eh.Records[0] + + lowercaseHeaders := map[string]string{} + for k, v := range record.MessageAttributes { + if v.StringValue != nil { + lowercaseHeaders[strings.ToLower(k)] = *v.StringValue + } + } + + return lowercaseHeaders +} + +func TestCustomExtractorExample(t *testing.T) { + handler := func(ctx context.Context, event events.SQSEvent) error { + // Use the parent span retrieved from the SQS Message Attributes. + span, _ := tracer.SpanFromContext(ctx) + span.SetTag("key", "value") + return nil + } + + cfg := &ddlambda.Config{ + TraceContextExtractor: exampleSQSExtractor, + } + ddlambda.WrapFunction(handler, cfg) +} diff --git a/contrib/aws/datadog-lambda-go/ddlambda_test.go b/contrib/aws/datadog-lambda-go/ddlambda_test.go new file mode 100644 index 0000000000..a650bc513e --- /dev/null +++ b/contrib/aws/datadog-lambda-go/ddlambda_test.go @@ -0,0 +1,205 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ +package ddlambda + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "os" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestInvokeDryRun(t *testing.T) { + t.Setenv(UniversalInstrumentation, "false") + t.Setenv(DatadogTraceEnabledEnvVar, "false") + + called := false + _, err := InvokeDryRun(func(ctx context.Context) { + called = true + globalCtx := GetContext() + assert.Equal(t, globalCtx, ctx) + }, nil) + assert.NoError(t, err) + assert.True(t, called) +} + +func TestMetricsSilentFailWithoutWrapper(t *testing.T) { + Metric("my-metric", 100, "my:tag") +} + +func TestMetricsSubmitWithWrapper(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + _, err := InvokeDryRun(func(ctx context.Context) { + Metric("my-metric", 100, "my:tag") + }, &Config{ + APIKey: "abc-123", + Site: server.URL, + }) + assert.NoError(t, err) + assert.True(t, called) +} + +func TestToMetricConfigLocalTest(t *testing.T) { + testcases := []struct { + envs map[string]string + cval bool + }{ + { + envs: map[string]string{"DD_LOCAL_TEST": "True"}, + cval: true, + }, + { + envs: map[string]string{"DD_LOCAL_TEST": "true"}, + cval: true, + }, + { + envs: map[string]string{"DD_LOCAL_TEST": "1"}, + cval: true, + }, + { + envs: map[string]string{"DD_LOCAL_TEST": "False"}, + cval: false, + }, + { + envs: map[string]string{"DD_LOCAL_TEST": "false"}, + cval: false, + }, + { + envs: map[string]string{"DD_LOCAL_TEST": "0"}, + cval: false, + }, + { + envs: map[string]string{"DD_LOCAL_TEST": ""}, + cval: false, + }, + { + envs: map[string]string{}, + cval: false, + }, + } + + cfg := Config{} + for _, tc := range testcases { + t.Run(fmt.Sprintf("%#v", tc.envs), func(t *testing.T) { + for k, v := range tc.envs { + os.Setenv(k, v) + } + mc := cfg.toMetricsConfig(true) + assert.Equal(t, tc.cval, mc.LocalTest) + }) + } +} + +func TestCalculateFipsMode(t *testing.T) { + // Save original environment to restore later + originalRegion := os.Getenv("AWS_REGION") + originalFipsMode := os.Getenv(FIPSModeEnvVar) + defer func() { + os.Setenv("AWS_REGION", originalRegion) + os.Setenv(FIPSModeEnvVar, originalFipsMode) + }() + + testCases := []struct { + name string + configFIPSMode *bool + region string + fipsModeEnv string + expected bool + }{ + { + name: "Config explicit true", + configFIPSMode: boolPtr(true), + region: "us-east-1", + fipsModeEnv: "", + expected: true, + }, + { + name: "Config explicit false", + configFIPSMode: boolPtr(false), + region: "us-gov-west-1", + fipsModeEnv: "", + expected: false, + }, + { + name: "GovCloud default true", + configFIPSMode: nil, + region: "us-gov-east-1", + fipsModeEnv: "", + expected: true, + }, + { + name: "Non-GovCloud default false", + configFIPSMode: nil, + region: "us-east-1", + fipsModeEnv: "", + expected: false, + }, + { + name: "Env var override to true", + configFIPSMode: nil, + region: "us-east-1", + fipsModeEnv: "true", + expected: true, + }, + { + name: "Env var override to false", + configFIPSMode: nil, + region: "us-gov-west-1", + fipsModeEnv: "false", + expected: false, + }, + { + name: "Invalid env var in GovCloud", + configFIPSMode: nil, + region: "us-gov-west-1", + fipsModeEnv: "invalid", + expected: true, + }, + { + name: "Invalid env var in non-GovCloud", + configFIPSMode: nil, + region: "us-east-1", + fipsModeEnv: "invalid", + expected: false, + }, + { + name: "Config takes precedence over env and region", + configFIPSMode: boolPtr(true), + region: "us-east-1", + fipsModeEnv: "false", + expected: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + os.Setenv("AWS_REGION", tc.region) + os.Setenv(FIPSModeEnvVar, tc.fipsModeEnv) + + cfg := &Config{FIPSMode: tc.configFIPSMode} + result := cfg.calculateFipsMode() + + assert.Equal(t, tc.expected, result, "calculateFipsMode returned incorrect value") + }) + } +} + +// Helper function to create bool pointers +func boolPtr(b bool) *bool { + return &b +} diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension.go b/contrib/aws/datadog-lambda-go/internal/extension/extension.go new file mode 100644 index 0000000000..7da39a5d61 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension.go @@ -0,0 +1,236 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package extension + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "fmt" + "net/http" + "os" + "reflect" + "runtime" + "strconv" + "strings" + "time" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + + ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" +) + +type ddTraceContext string + +const ( + DdTraceId ddTraceContext = "x-datadog-trace-id" + DdParentId ddTraceContext = "x-datadog-parent-id" + DdSpanId ddTraceContext = "x-datadog-span-id" + DdSamplingPriority ddTraceContext = "x-datadog-sampling-priority" + DdInvocationError ddTraceContext = "x-datadog-invocation-error" + DdInvocationErrorMsg ddTraceContext = "x-datadog-invocation-error-msg" + DdInvocationErrorType ddTraceContext = "x-datadog-invocation-error-type" + DdInvocationErrorStack ddTraceContext = "x-datadog-invocation-error-stack" + + DdSeverlessSpan ddTraceContext = "dd-tracer-serverless-span" + DdLambdaResponse ddTraceContext = "dd-response" +) + +const ( + // We don't want call to the Serverless Agent to block indefinitely for any reasons, + // so here's a configuration of the timeout when calling the Serverless Agent. We also + // want to let it having some time for its cold start so we should not set this too low. + timeout = 3000 * time.Millisecond + + helloUrl = "http://localhost:8124/lambda/hello" + flushUrl = "http://localhost:8124/lambda/flush" + startInvocationUrl = "http://localhost:8124/lambda/start-invocation" + endInvocationUrl = "http://localhost:8124/lambda/end-invocation" + + extensionPath = "/opt/extensions/datadog-agent" +) + +type ExtensionManager struct { + helloRoute string + flushRoute string + extensionPath string + startInvocationUrl string + endInvocationUrl string + httpClient HTTPClient + isExtensionRunning bool + isUniversalInstrumentation bool +} + +type HTTPClient interface { + Do(req *http.Request) (*http.Response, error) +} + +func BuildExtensionManager(isUniversalInstrumentation bool) *ExtensionManager { + em := &ExtensionManager{ + helloRoute: helloUrl, + flushRoute: flushUrl, + startInvocationUrl: startInvocationUrl, + endInvocationUrl: endInvocationUrl, + extensionPath: extensionPath, + httpClient: &http.Client{Timeout: timeout}, + isUniversalInstrumentation: isUniversalInstrumentation, + } + em.checkAgentRunning() + return em +} + +func (em *ExtensionManager) checkAgentRunning() { + if _, err := os.Stat(em.extensionPath); err != nil { + logger.Debug("Will use the API") + em.isExtensionRunning = false + } else { + logger.Debug("Will use the Serverless Agent") + em.isExtensionRunning = true + + // Tell the extension not to create an execution span if universal instrumentation is disabled + if !em.isUniversalInstrumentation { + req, _ := http.NewRequest(http.MethodGet, em.helloRoute, nil) + if response, err := em.httpClient.Do(req); err == nil && response.StatusCode == 200 { + logger.Debug("Hit the extension /hello route") + } else { + logger.Debug("Will use the API since the Serverless Agent was detected but the hello route was unreachable") + em.isExtensionRunning = false + } + } + } +} + +func (em *ExtensionManager) SendStartInvocationRequest(ctx context.Context, eventPayload json.RawMessage) context.Context { + body := bytes.NewBuffer(eventPayload) + req, _ := http.NewRequest(http.MethodPost, em.startInvocationUrl, body) + + if response, err := em.httpClient.Do(req); err == nil && response.StatusCode == 200 { + // Propagate dd-trace context from the extension response if found in the response headers + traceId := response.Header.Get(string(DdTraceId)) + if traceId != "" { + ctx = context.WithValue(ctx, DdTraceId, traceId) + } + parentId := traceId + if pid := response.Header.Get(string(DdParentId)); pid != "" { + parentId = pid + } + if parentId != "" { + ctx = context.WithValue(ctx, DdParentId, parentId) + } + samplingPriority := response.Header.Get(string(DdSamplingPriority)) + if samplingPriority != "" { + ctx = context.WithValue(ctx, DdSamplingPriority, samplingPriority) + } + } + return ctx +} + +func (em *ExtensionManager) SendEndInvocationRequest(ctx context.Context, functionExecutionSpan *ddtracer.Span, cfg ddtracer.FinishConfig) { + // Handle Lambda response + lambdaResponse := ctx.Value(DdLambdaResponse) + content, responseErr := json.Marshal(lambdaResponse) + if responseErr != nil { + content = []byte("{}") + } + body := bytes.NewBuffer(content) + req, _ := http.NewRequest(http.MethodPost, em.endInvocationUrl, body) + + // Mark the invocation as an error if any + if cfg.Error != nil { + req.Header.Set(string(DdInvocationError), "true") + req.Header.Set(string(DdInvocationErrorMsg), cfg.Error.Error()) + req.Header.Set(string(DdInvocationErrorType), reflect.TypeOf(cfg.Error).String()) + req.Header.Set(string(DdInvocationErrorStack), takeStacktrace(cfg)) + } + + // Extract the DD trace context and pass them to the extension via request headers + traceId, ok := ctx.Value(DdTraceId).(string) + if ok { + req.Header.Set(string(DdTraceId), traceId) + if parentId, ok := ctx.Value(DdParentId).(string); ok { + req.Header.Set(string(DdParentId), parentId) + } + if spanId, ok := ctx.Value(DdSpanId).(string); ok { + req.Header.Set(string(DdSpanId), spanId) + } + if samplingPriority, ok := ctx.Value(DdSamplingPriority).(string); ok { + req.Header.Set(string(DdSamplingPriority), samplingPriority) + } + } else { + spanContext := functionExecutionSpan.Context() + req.Header.Set(string(DdTraceId), fmt.Sprint(spanContext.TraceID())) + req.Header.Set(string(DdSpanId), fmt.Sprint(spanContext.SpanID())) + + // Try to get sampling priority + if priority, ok := spanContext.SamplingPriority(); ok { + req.Header.Set(string(DdSamplingPriority), fmt.Sprint(priority)) + } + } + + resp, err := em.httpClient.Do(req) + if err != nil || resp.StatusCode != 200 { + logger.Error(fmt.Errorf("could not send end invocation payload to the extension: %v", err)) + } +} + +// defaultStackLength specifies the default maximum size of a stack trace. +const defaultStackLength = 32 + +// takeStacktrace takes a stack trace of maximum n entries, skipping the first skip entries. +// If n is 0, up to 20 entries are retrieved. +func takeStacktrace(opts ddtracer.FinishConfig) string { + if opts.StackFrames == 0 { + opts.StackFrames = defaultStackLength + } + var builder strings.Builder + pcs := make([]uintptr, opts.StackFrames) + + // +3 to exclude runtime.Callers, takeStacktrace and SendEndInvocationRequest + numFrames := runtime.Callers(3+int(opts.SkipStackFrames), pcs) + if numFrames == 0 { + return "" + } + frames := runtime.CallersFrames(pcs[:numFrames]) + for i := 0; ; i++ { + frame, more := frames.Next() + if i != 0 { + builder.WriteByte('\n') + } + builder.WriteString(frame.Function) + builder.WriteByte('\n') + builder.WriteByte('\t') + builder.WriteString(frame.File) + builder.WriteByte(':') + builder.WriteString(strconv.Itoa(frame.Line)) + if !more { + break + } + } + + return base64.StdEncoding.EncodeToString([]byte(builder.String())) +} + +func (em *ExtensionManager) IsExtensionRunning() bool { + return em.isExtensionRunning +} + +func (em *ExtensionManager) Flush() error { + req, _ := http.NewRequest(http.MethodGet, em.flushRoute, nil) + if response, err := em.httpClient.Do(req); err != nil { + err := fmt.Errorf("was not able to reach the Agent to flush: %s", err) + logger.Error(err) + return err + } else if response.StatusCode != 200 { + err := fmt.Errorf("the Agent didn't returned HTTP 200: %s", response.Status) + logger.Error(err) + return err + } + return nil +} diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go new file mode 100644 index 0000000000..2d108c3bfd --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go @@ -0,0 +1,298 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package extension + +import ( + "bytes" + "context" + "encoding/base64" + "fmt" + "net/http" + "os" + "testing" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/stretchr/testify/assert" + "github.com/DataDog/dd-trace-go/v2/ddtrace" + ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" +) + +type ClientErrorMock struct { +} + +type ClientSuccessMock struct { +} + +type ClientSuccess202Mock struct { +} + +type ClientSuccessStartInvoke struct { + headers http.Header +} + +type ClientSuccessEndInvoke struct { +} + +const ( + mockTraceId = "1" + mockParentId = "2" + mockSamplingPriority = "3" +) + +func (c *ClientErrorMock) Do(req *http.Request) (*http.Response, error) { + return nil, fmt.Errorf("KO") +} + +func (c *ClientSuccessMock) Do(req *http.Request) (*http.Response, error) { + return &http.Response{StatusCode: 200}, nil +} + +func (c *ClientSuccess202Mock) Do(req *http.Request) (*http.Response, error) { + return &http.Response{StatusCode: 202, Status: "KO"}, nil +} + +func (c *ClientSuccessStartInvoke) Do(req *http.Request) (*http.Response, error) { + return &http.Response{StatusCode: 200, Status: "KO", Header: c.headers}, nil +} + +func (c *ClientSuccessEndInvoke) Do(req *http.Request) (*http.Response, error) { + return &http.Response{StatusCode: 200, Status: "KO"}, nil +} + +func captureLog(f func()) string { + var buf bytes.Buffer + logger.SetOutput(&buf) + f() + logger.SetOutput(os.Stdout) + return buf.String() +} + +func TestBuildExtensionManager(t *testing.T) { + em := BuildExtensionManager(false) + assert.Equal(t, "http://localhost:8124/lambda/hello", em.helloRoute) + assert.Equal(t, "http://localhost:8124/lambda/flush", em.flushRoute) + assert.Equal(t, "http://localhost:8124/lambda/start-invocation", em.startInvocationUrl) + assert.Equal(t, "http://localhost:8124/lambda/end-invocation", em.endInvocationUrl) + assert.Equal(t, "/opt/extensions/datadog-agent", em.extensionPath) + assert.Equal(t, false, em.isUniversalInstrumentation) + assert.NotNil(t, em.httpClient) +} + +func TestIsAgentRunningFalse(t *testing.T) { + em := &ExtensionManager{ + httpClient: &ClientErrorMock{}, + } + assert.False(t, em.IsExtensionRunning()) +} + +func TestIsAgentRunningFalseSinceTheAgentIsNotHere(t *testing.T) { + em := &ExtensionManager{ + extensionPath: "/impossible/path/test", + } + em.checkAgentRunning() + assert.False(t, em.IsExtensionRunning()) +} + +func TestIsAgentRunningTrue(t *testing.T) { + existingPath, err := os.Getwd() + assert.Nil(t, err) + + em := &ExtensionManager{ + httpClient: &ClientSuccessMock{}, + extensionPath: existingPath, + } + em.checkAgentRunning() + assert.True(t, em.IsExtensionRunning()) +} + +func TestFlushErrorNot200(t *testing.T) { + em := &ExtensionManager{ + httpClient: &ClientSuccess202Mock{}, + } + err := em.Flush() + assert.Equal(t, "the Agent didn't returned HTTP 200: KO", err.Error()) +} + +func TestFlushError(t *testing.T) { + em := &ExtensionManager{ + httpClient: &ClientErrorMock{}, + } + err := em.Flush() + assert.Equal(t, "was not able to reach the Agent to flush: KO", err.Error()) +} + +func TestFlushSuccess(t *testing.T) { + em := &ExtensionManager{ + httpClient: &ClientSuccessMock{}, + } + err := em.Flush() + assert.Nil(t, err) +} + +func TestExtensionStartInvoke(t *testing.T) { + em := &ExtensionManager{ + startInvocationUrl: startInvocationUrl, + httpClient: &ClientSuccessStartInvoke{}, + } + ctx := em.SendStartInvocationRequest(context.TODO(), []byte{}) + traceId := ctx.Value(DdTraceId) + parentId := ctx.Value(DdParentId) + samplingPriority := ctx.Value(DdSamplingPriority) + err := em.Flush() + + assert.Nil(t, err) + assert.Nil(t, traceId) + assert.Nil(t, parentId) + assert.Nil(t, samplingPriority) +} + +func TestExtensionStartInvokeWithTraceContext(t *testing.T) { + headers := http.Header{} + headers.Set(string(DdTraceId), mockTraceId) + headers.Set(string(DdParentId), mockParentId) + headers.Set(string(DdSamplingPriority), mockSamplingPriority) + + em := &ExtensionManager{ + startInvocationUrl: startInvocationUrl, + httpClient: &ClientSuccessStartInvoke{ + headers: headers, + }, + } + ctx := em.SendStartInvocationRequest(context.TODO(), []byte{}) + traceId := ctx.Value(DdTraceId) + parentId := ctx.Value(DdParentId) + samplingPriority := ctx.Value(DdSamplingPriority) + err := em.Flush() + + assert.Nil(t, err) + assert.Equal(t, mockTraceId, traceId) + assert.Equal(t, mockParentId, parentId) + assert.Equal(t, mockSamplingPriority, samplingPriority) +} + +func TestExtensionStartInvokeWithTraceContextNoParentID(t *testing.T) { + headers := http.Header{} + headers.Set(string(DdTraceId), mockTraceId) + headers.Set(string(DdSamplingPriority), mockSamplingPriority) + + em := &ExtensionManager{ + startInvocationUrl: startInvocationUrl, + httpClient: &ClientSuccessStartInvoke{ + headers: headers, + }, + } + ctx := em.SendStartInvocationRequest(context.TODO(), []byte{}) + traceId := ctx.Value(DdTraceId) + parentId := ctx.Value(DdParentId) + samplingPriority := ctx.Value(DdSamplingPriority) + err := em.Flush() + + assert.Nil(t, err) + assert.Equal(t, mockTraceId, traceId) + assert.Equal(t, mockTraceId, parentId) + assert.Equal(t, mockSamplingPriority, samplingPriority) +} + +func TestExtensionEndInvocation(t *testing.T) { + em := &ExtensionManager{ + endInvocationUrl: endInvocationUrl, + httpClient: &ClientSuccessEndInvoke{}, + } + span := ddtracer.StartSpan("aws.lambda") + logOutput := captureLog(func() { em.SendEndInvocationRequest(context.TODO(), span, ddtracer.FinishConfig{}) }) + span.Finish() + + assert.Equal(t, "", logOutput) +} + +func TestExtensionEndInvocationError(t *testing.T) { + em := &ExtensionManager{ + endInvocationUrl: endInvocationUrl, + httpClient: &ClientErrorMock{}, + } + span := ddtracer.StartSpan("aws.lambda") + logOutput := captureLog(func() { em.SendEndInvocationRequest(context.TODO(), span, ddtracer.FinishConfig{}) }) + span.Finish() + + assert.Contains(t, logOutput, "could not send end invocation payload to the extension") +} + +type mockSpanContext struct { + ddtrace.SpanContext +} + +func (m mockSpanContext) TraceID() string { return "123" } +func (m mockSpanContext) TraceIDBytes() [16]byte { return [16]byte{} } +func (m mockSpanContext) TraceIDLower() uint64 { return 123 } +func (m mockSpanContext) SpanID() uint64 { return 456 } +func (m mockSpanContext) SamplingPriority() (int, bool) { return -1, true } +func (m mockSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {} + +type mockSpan struct{ ddtrace.Span } + +func (m mockSpan) Context() ddtrace.SpanContext { return mockSpanContext{} } + +func TestExtensionEndInvocationSamplingPriority(t *testing.T) { + headers := http.Header{} + em := &ExtensionManager{httpClient: capturingClient{hdr: headers}} + span := &mockSpan{} + + // When priority in context, use that value + ctx := context.WithValue(context.Background(), DdTraceId, "123") + ctx = context.WithValue(ctx, DdSamplingPriority, "2") + em.SendEndInvocationRequest(ctx, span, ddtracer.FinishConfig{}) + assert.Equal(t, "2", headers.Get("X-Datadog-Sampling-Priority")) + + // When no context, get priority from span + em.SendEndInvocationRequest(context.Background(), span, ddtracer.FinishConfig{}) + assert.Equal(t, "-1", headers.Get("X-Datadog-Sampling-Priority")) +} + +type capturingClient struct { + hdr http.Header +} + +func (c capturingClient) Do(req *http.Request) (*http.Response, error) { + for k, v := range req.Header { + c.hdr[k] = v + } + return &http.Response{StatusCode: 200}, nil +} + +func TestExtensionEndInvocationErrorHeaders(t *testing.T) { + hdr := http.Header{} + em := &ExtensionManager{httpClient: capturingClient{hdr: hdr}} + span := ddtracer.StartSpan("aws.lambda") + cfg := ddtracer.FinishConfig{Error: fmt.Errorf("ooooops")} + + em.SendEndInvocationRequest(context.TODO(), span, cfg) + + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error"), "true") + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error-Msg"), "ooooops") + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error-Type"), "*errors.errorString") + + data, err := base64.StdEncoding.DecodeString(hdr.Get("X-Datadog-Invocation-Error-Stack")) + assert.Nil(t, err) + assert.Contains(t, string(data), "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go") + assert.Contains(t, string(data), "TestExtensionEndInvocationErrorHeaders") +} + +func TestExtensionEndInvocationErrorHeadersNilError(t *testing.T) { + hdr := http.Header{} + em := &ExtensionManager{httpClient: capturingClient{hdr: hdr}} + span := ddtracer.StartSpan("aws.lambda") + cfg := ddtracer.FinishConfig{Error: nil} + + em.SendEndInvocationRequest(context.TODO(), span, cfg) + + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error"), "") + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error-Msg"), "") + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error-Type"), "") + assert.Equal(t, hdr.Get("X-Datadog-Invocation-Error-Stack"), "") +} diff --git a/contrib/aws/datadog-lambda-go/internal/logger/log.go b/contrib/aws/datadog-lambda-go/internal/logger/log.go new file mode 100644 index 0000000000..c2eec046b0 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/logger/log.go @@ -0,0 +1,86 @@ +package logger + +import ( + "encoding/json" + "fmt" + "io" + "log" + "os" +) + +// LogLevel represents the level of logging that should be performed +type LogLevel int + +const ( + // LevelDebug logs all information + LevelDebug LogLevel = iota + // LevelWarn only logs warnings and errors + LevelWarn LogLevel = iota +) + +var ( + logLevel = LevelWarn + output io.Writer = os.Stdout +) + +// SetLogLevel set the level of logging for the ddlambda +func SetLogLevel(ll LogLevel) { + logLevel = ll +} + +// SetOutput changes the writer for the logger +func SetOutput(w io.Writer) { + log.SetOutput(w) + output = w +} + +// Error logs a structured error message to stdout +func Error(err error) { + finalMessage := logStructure{ + Status: "error", + Message: fmt.Sprintf("datadog: %s", err.Error()), + } + result, _ := json.Marshal(finalMessage) + + log.Println(string(result)) +} + +// Debug logs a structured log message to stdout +func Debug(message string) { + if logLevel > LevelDebug { + return + } + finalMessage := logStructure{ + Status: "debug", + Message: fmt.Sprintf("datadog: %s", message), + } + + result, _ := json.Marshal(finalMessage) + + log.Println(string(result)) +} + +// Warn logs a structured log message to stdout +func Warn(message string) { + if logLevel > LevelWarn { + return + } + finalMessage := logStructure{ + Status: "warning", + Message: fmt.Sprintf("datadog: %s", message), + } + + result, _ := json.Marshal(finalMessage) + + log.Println(string(result)) +} + +// Raw prints a raw message to the logs. +func Raw(message string) { + fmt.Fprintln(output, message) +} + +type logStructure struct { + Status string `json:"status"` + Message string `json:"message"` +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/api.go b/contrib/aws/datadog-lambda-go/internal/metrics/api.go new file mode 100644 index 0000000000..a6d4572bbf --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/api.go @@ -0,0 +1,152 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "time" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" +) + +type ( + // Client sends metrics to Datadog + Client interface { + SendMetrics(metrics []APIMetric) error + } + + // APIClient send metrics to Datadog, via the Datadog API + APIClient struct { + apiKey string + apiKeyDecryptChan <-chan string + baseAPIURL string + httpClient *http.Client + context context.Context + } + + // APIClientOptions contains instantiation options from creating an APIClient. + APIClientOptions struct { + baseAPIURL string + apiKey string + kmsAPIKey string + decrypter Decrypter + httpClientTimeout time.Duration + } + + postMetricsModel struct { + Series []APIMetric `json:"series"` + } +) + +// MakeAPIClient creates a new API client with the given api and app keys +func MakeAPIClient(ctx context.Context, options APIClientOptions) *APIClient { + httpClient := &http.Client{ + Timeout: options.httpClientTimeout, + } + client := &APIClient{ + apiKey: options.apiKey, + baseAPIURL: options.baseAPIURL, + httpClient: httpClient, + context: ctx, + } + if len(options.apiKey) == 0 && len(options.kmsAPIKey) != 0 { + client.apiKeyDecryptChan = client.decryptAPIKey(options.decrypter, options.kmsAPIKey) + } + + return client +} + +// SendMetrics posts a batch metrics payload to the Datadog API +func (cl *APIClient) SendMetrics(metrics []APIMetric) error { + + // If the api key was provided as a kms key, wait for it to finish decrypting + if cl.apiKeyDecryptChan != nil { + cl.apiKey = <-cl.apiKeyDecryptChan + cl.apiKeyDecryptChan = nil + } + + content, err := marshalAPIMetricsModel(metrics) + if err != nil { + return fmt.Errorf("Couldn't marshal metrics model: %v", err) + } + body := bytes.NewBuffer(content) + + // For the moment we only support distribution metrics. + // Other metric types use the "series" endpoint, which takes an identical payload. + req, err := http.NewRequest("POST", cl.makeRoute("distribution_points"), body) + if err != nil { + return fmt.Errorf("Couldn't create send metrics request:%v", err) + } + req = req.WithContext(cl.context) + + defer req.Body.Close() + + logger.Debug(fmt.Sprintf("Sending payload with body %s", content)) + + cl.addAPICredentials(req) + + resp, err := cl.httpClient.Do(req) + + if err != nil { + return fmt.Errorf("Failed to send metrics to API") + } + defer resp.Body.Close() + + if resp.StatusCode < 200 || resp.StatusCode > 299 { + if resp.StatusCode == 403 { + logger.Debug(fmt.Sprintf("authorization failed with api key of length %d characters", len(cl.apiKey))) + } + bodyBytes, err := io.ReadAll(resp.Body) + body := "" + if err == nil { + body = string(bodyBytes) + } + return fmt.Errorf("Failed to send metrics to API. Status Code %d, Body %s", resp.StatusCode, body) + } + + return err +} + +func (cl *APIClient) decryptAPIKey(decrypter Decrypter, kmsAPIKey string) <-chan string { + + ch := make(chan string) + + go func() { + result, err := decrypter.Decrypt(kmsAPIKey) + if err != nil { + logger.Error(fmt.Errorf("Couldn't decrypt api kms key %s", err)) + } + ch <- result + close(ch) + }() + return ch +} + +func (cl *APIClient) addAPICredentials(req *http.Request) { + query := req.URL.Query() + query.Add(apiKeyParam, cl.apiKey) + req.URL.RawQuery = query.Encode() +} + +func (cl *APIClient) makeRoute(route string) string { + url := fmt.Sprintf("%s/%s", cl.baseAPIURL, route) + logger.Debug(fmt.Sprintf("posting to url %s", url)) + return url +} + +func marshalAPIMetricsModel(metrics []APIMetric) ([]byte, error) { + pm := postMetricsModel{} + pm.Series = metrics + return json.Marshal(pm) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go new file mode 100644 index 0000000000..f939fca72e --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go @@ -0,0 +1,172 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "context" + "io" + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/assert" +) + +const ( + mockAPIKey = "12345" + mockEncryptedAPIKey = "mockEncrypted" + mockDecryptedAPIKey = "mockDecrypted" +) + +type ( + mockDecrypter struct { + returnValue string + returnError error + } +) + +func (md *mockDecrypter) Decrypt(cipherText string) (string, error) { + return md.returnValue, md.returnError +} + +func TestAddAPICredentials(t *testing.T) { + cl := MakeAPIClient(context.Background(), APIClientOptions{baseAPIURL: "", apiKey: mockAPIKey}) + req, _ := http.NewRequest("GET", "http://some-api.com/endpoint", nil) + cl.addAPICredentials(req) + assert.Equal(t, "http://some-api.com/endpoint?api_key=12345", req.URL.String()) +} + +func TestSendMetricsSuccess(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + body, _ := io.ReadAll(r.Body) + s := string(body) + + assert.Equal(t, "/distribution_points?api_key=12345", r.URL.String()) + assert.Equal(t, "{\"series\":[{\"metric\":\"metric-1\",\"tags\":[\"a\",\"b\",\"c\"],\"type\":\"distribution\",\"points\":[[1,[2]],[3,[4]],[5,[6]]]}]}", s) + + })) + defer server.Close() + + am := []APIMetric{ + { + Name: "metric-1", + Host: nil, + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{float64(1), []interface{}{float64(2)}}, + []interface{}{float64(3), []interface{}{float64(4)}}, + []interface{}{float64(5), []interface{}{float64(6)}}, + }, + }, + } + + cl := MakeAPIClient(context.Background(), APIClientOptions{baseAPIURL: server.URL, apiKey: mockAPIKey}) + err := cl.SendMetrics(am) + + assert.NoError(t, err) + assert.True(t, called) +} + +func TestSendMetricsBadRequest(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusForbidden) + body, _ := io.ReadAll(r.Body) + s := string(body) + + assert.Equal(t, "/distribution_points?api_key=12345", r.URL.String()) + assert.Equal(t, "{\"series\":[{\"metric\":\"metric-1\",\"tags\":[\"a\",\"b\",\"c\"],\"type\":\"distribution\",\"points\":[[1,[2]],[3,[4]],[5,[6]]]}]}", s) + + })) + defer server.Close() + + am := []APIMetric{ + { + Name: "metric-1", + Host: nil, + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{float64(1), []interface{}{float64(2)}}, + []interface{}{float64(3), []interface{}{float64(4)}}, + []interface{}{float64(5), []interface{}{float64(6)}}, + }, + }, + } + + cl := MakeAPIClient(context.Background(), APIClientOptions{baseAPIURL: server.URL, apiKey: mockAPIKey}) + err := cl.SendMetrics(am) + + assert.Error(t, err) + assert.True(t, called) +} + +func TestSendMetricsCantReachServer(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + })) + defer server.Close() + + am := []APIMetric{ + { + Name: "metric-1", + Host: nil, + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{float64(1), []interface{}{float64(2)}}, + []interface{}{float64(3), []interface{}{float64(4)}}, + []interface{}{float64(5), []interface{}{float64(6)}}, + }, + }, + } + + cl := MakeAPIClient(context.Background(), APIClientOptions{baseAPIURL: "httpa:///badly-formatted-url", apiKey: mockAPIKey}) + err := cl.SendMetrics(am) + + assert.Error(t, err) + assert.False(t, called) +} + +func TestDecryptsUsingKMSKey(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + assert.Equal(t, "/distribution_points?api_key=mockDecrypted", r.URL.String()) + })) + defer server.Close() + + am := []APIMetric{ + { + Name: "metric-1", + Host: nil, + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{float64(1), []interface{}{float64(2)}}, + []interface{}{float64(3), []interface{}{float64(4)}}, + []interface{}{float64(5), []interface{}{float64(6)}}, + }, + }, + } + md := mockDecrypter{} + md.returnValue = mockDecryptedAPIKey + + cl := MakeAPIClient(context.Background(), APIClientOptions{baseAPIURL: server.URL, apiKey: "", kmsAPIKey: mockEncryptedAPIKey, decrypter: &md}) + err := cl.SendMetrics(am) + + assert.NoError(t, err) + assert.True(t, called) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go b/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go new file mode 100644 index 0000000000..5d52e37781 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go @@ -0,0 +1,78 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "fmt" + "sort" + "strings" + "time" +) + +type ( + // Batcher aggregates metrics with common properties,(metric name, tags, type etc) + Batcher struct { + metrics map[string]Metric + batchInterval time.Duration + } + // BatchKey identifies a batch of metrics + BatchKey struct { + metricType MetricType + name string + tags []string + host *string + } +) + +// MakeBatcher creates a new batcher object +func MakeBatcher(batchInterval time.Duration) *Batcher { + return &Batcher{ + batchInterval: batchInterval, + metrics: map[string]Metric{}, + } +} + +// AddMetric adds a point to a given metric +func (b *Batcher) AddMetric(metric Metric) { + sk := b.getStringKey(metric.ToBatchKey()) + if existing, ok := b.metrics[sk]; ok { + existing.Join(metric) + } else { + b.metrics[sk] = metric + } +} + +// ToAPIMetrics converts the current batch of metrics into API metrics +func (b *Batcher) ToAPIMetrics() []APIMetric { + + ar := []APIMetric{} + interval := b.batchInterval / time.Second + + for _, metric := range b.metrics { + values := metric.ToAPIMetric(interval) + ar = append(ar, values...) + } + return ar +} + +func (b *Batcher) getStringKey(bk BatchKey) string { + tagKey := getTagKey(bk.tags) + + if bk.host != nil { + return fmt.Sprintf("(%s)-(%s)-(%s)-(%s)", bk.metricType, bk.name, tagKey, *bk.host) + } + return fmt.Sprintf("(%s)-(%s)-(%s)", bk.metricType, bk.name, tagKey) +} + +func getTagKey(tags []string) string { + sortedTags := make([]string, len(tags)) + copy(sortedTags, tags) + sort.Strings(sortedTags) + return strings.Join(sortedTags, ":") +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go new file mode 100644 index 0000000000..75d262341a --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go @@ -0,0 +1,150 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestGetMetricDifferentTagOrder(t *testing.T) { + + tm := time.Now() + batcher := MakeBatcher(10) + dm1 := Distribution{ + Name: "metric-1", + Values: []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}}, + Tags: []string{"a", "b", "c"}, + } + dm2 := Distribution{ + Name: "metric-1", + Values: []MetricValue{{Timestamp: tm, Value: 3}, {Timestamp: tm, Value: 4}}, + Tags: []string{"c", "b", "a"}, + } + + batcher.AddMetric(&dm1) + batcher.AddMetric(&dm2) + + assert.Equal(t, []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}, {Timestamp: tm, Value: 3}, {Timestamp: tm, Value: 4}}, dm1.Values) +} + +func TestGetMetricFailDifferentName(t *testing.T) { + + tm := time.Now() + batcher := MakeBatcher(10) + + dm1 := Distribution{ + Name: "metric-1", + Values: []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}}, + Tags: []string{"a", "b", "c"}, + } + dm2 := Distribution{ + Name: "metric-2", + Values: []MetricValue{{Timestamp: tm, Value: 3}, {Timestamp: tm, Value: 4}}, + Tags: []string{"c", "b", "a"}, + } + + batcher.AddMetric(&dm1) + batcher.AddMetric(&dm2) + + assert.Equal(t, []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}}, dm1.Values) + +} + +func TestGetMetricFailDifferentHost(t *testing.T) { + tm := time.Now() + batcher := MakeBatcher(10) + + host1 := "my-host-1" + host2 := "my-host-2" + + dm1 := Distribution{ + Values: []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}}, + + Tags: []string{"a", "b", "c"}, + Host: &host1, + } + dm2 := Distribution{ + Name: "metric-1", + Values: []MetricValue{{Timestamp: tm, Value: 3}, {Timestamp: tm, Value: 4}}, + Tags: []string{"a", "b", "c"}, + Host: &host2, + } + + batcher.AddMetric(&dm1) + batcher.AddMetric(&dm2) + + assert.Equal(t, []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}}, dm1.Values) +} + +func TestGetMetricSameHost(t *testing.T) { + + tm := time.Now() + batcher := MakeBatcher(10) + + host := "my-host" + + dm1 := Distribution{ + Name: "metric-1", + Values: []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}}, + Tags: []string{"a", "b", "c"}, + Host: &host, + } + dm2 := Distribution{ + Name: "metric-1", + Values: []MetricValue{{Timestamp: tm, Value: 3}, {Timestamp: tm, Value: 4}}, + Tags: []string{"a", "b", "c"}, + Host: &host, + } + + batcher.AddMetric(&dm1) + batcher.AddMetric(&dm2) + + assert.Equal(t, []MetricValue{{Timestamp: tm, Value: 1}, {Timestamp: tm, Value: 2}, {Timestamp: tm, Value: 3}, {Timestamp: tm, Value: 4}}, dm1.Values) +} + +func TestToAPIMetricsSameInterval(t *testing.T) { + tm := time.Now() + hostname := "host-1" + + batcher := MakeBatcher(10) + dm := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Host: &hostname, + Values: []MetricValue{}, + } + + dm.AddPoint(tm, 1) + dm.AddPoint(tm, 2) + dm.AddPoint(tm, 3) + + batcher.AddMetric(&dm) + + floatTime := float64(tm.Unix()) + result := batcher.ToAPIMetrics() + expected := []APIMetric{ + { + Name: "metric-1", + Host: &hostname, + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Interval: nil, + Points: []interface{}{ + []interface{}{floatTime, []interface{}{float64(1)}}, + []interface{}{floatTime, []interface{}{float64(2)}}, + []interface{}{floatTime, []interface{}{float64(3)}}, + }, + }, + } + + assert.Equal(t, expected, result) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/constants.go b/contrib/aws/datadog-lambda-go/internal/metrics/constants.go new file mode 100644 index 0000000000..fc553d5ea7 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/constants.go @@ -0,0 +1,30 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import "time" + +const ( + apiKeyParam = "api_key" + defaultRetryInterval = time.Millisecond * 250 + defaultBatchInterval = time.Second * 15 + defaultHttpClientTimeout = time.Second * 5 + defaultCircuitBreakerInterval = time.Second * 30 + defaultCircuitBreakerTimeout = time.Second * 60 + defaultCircuitBreakerTotalFailures = 4 +) + +// MetricType enumerates all the available metric types +type MetricType string + +const ( + + // DistributionType represents a distribution metric + DistributionType MetricType = "distribution" +) diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/context.go b/contrib/aws/datadog-lambda-go/internal/metrics/context.go new file mode 100644 index 0000000000..744cc8ca7c --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/context.go @@ -0,0 +1,29 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import "context" + +type contextKeytype int + +var metricsListenerKey = new(contextKeytype) + +// GetListener retrieves the metrics listener from a context object. +func GetListener(ctx context.Context) *Listener { + result := ctx.Value(metricsListenerKey) + if result == nil { + return nil + } + return result.(*Listener) +} + +// AddListener adds a metrics listener to a context object +func AddListener(ctx context.Context, listener *Listener) context.Context { + return context.WithValue(ctx, metricsListenerKey, listener) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go new file mode 100644 index 0000000000..3a17f2ab29 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go @@ -0,0 +1,30 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "context" + "testing" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/stretchr/testify/assert" +) + +func TestGetProcessorEmptyContext(t *testing.T) { + ctx := context.Background() + result := GetListener(ctx) + assert.Nil(t, result) +} + +func TestGetProcessorSuccess(t *testing.T) { + lst := MakeListener(Config{}, &extension.ExtensionManager{}) + ctx := AddListener(context.Background(), &lst) + result := GetListener(ctx) + assert.NotNil(t, result) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go new file mode 100644 index 0000000000..a7e3681439 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go @@ -0,0 +1,102 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ +package metrics + +import ( + "context" + "encoding/base64" + "fmt" + "github.com/aws/aws-sdk-go-v2/aws" + "os" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/aws/aws-sdk-go-v2/config" + "github.com/aws/aws-sdk-go-v2/service/kms" +) + +type ( + // Decrypter attempts to decrypt a key + Decrypter interface { + Decrypt(cipherText string) (string, error) + } + + kmsDecrypter struct { + kmsClient *kms.Client + } + + clientDecrypter interface { + Decrypt(context.Context, *kms.DecryptInput, ...func(*kms.Options)) (*kms.DecryptOutput, error) + } +) + +// functionNameEnvVar is the environment variable that stores the Lambda function name +const functionNameEnvVar string = "AWS_LAMBDA_FUNCTION_NAME" + +// encryptionContextKey is the key added to the encryption context by the Lambda console UI +const encryptionContextKey string = "LambdaFunctionName" + +// MakeKMSDecrypter creates a new decrypter which uses the AWS KMS service to decrypt variables +func MakeKMSDecrypter(fipsMode bool) Decrypter { + fipsEndpoint := aws.FIPSEndpointStateUnset + if fipsMode { + fipsEndpoint = aws.FIPSEndpointStateEnabled + logger.Debug("Using FIPS endpoint for KMS decryption.") + } + + cfg, err := config.LoadDefaultConfig(context.Background(), config.WithUseFIPSEndpoint(fipsEndpoint)) + if err != nil { + logger.Error(fmt.Errorf("could not create a new aws config: %v", err)) + panic(err) + } + return &kmsDecrypter{ + kmsClient: kms.NewFromConfig(cfg), + } +} + +func (kd *kmsDecrypter) Decrypt(ciphertext string) (string, error) { + return decryptKMS(kd.kmsClient, ciphertext) +} + +// decryptKMS decodes and deciphers the base64-encoded ciphertext given as a parameter using KMS. +// For this to work properly, the Lambda function must have the appropriate IAM permissions. +func decryptKMS(kmsClient clientDecrypter, ciphertext string) (string, error) { + decodedBytes, err := base64.StdEncoding.DecodeString(ciphertext) + if err != nil { + return "", fmt.Errorf("failed to encode cipher text to base64: %v", err) + } + + // When the API key is encrypted using the AWS console, the function name is added as an + // encryption context. When the API key is encrypted using the AWS CLI, no encryption context + // is added. We need to try decrypting the API key both with and without the encryption context. + + // Try without encryption context, in case API key was encrypted using the AWS CLI + functionName := os.Getenv(functionNameEnvVar) + params := &kms.DecryptInput{ + CiphertextBlob: decodedBytes, + } + ctx := context.Background() + response, err := kmsClient.Decrypt(ctx, params) + + if err != nil { + logger.Debug("Failed to decrypt ciphertext without encryption context, retrying with encryption context") + // Try with encryption context, in case API key was encrypted using the AWS Console + params = &kms.DecryptInput{ + CiphertextBlob: decodedBytes, + EncryptionContext: map[string]string{ + encryptionContextKey: functionName, + }, + } + response, err = kmsClient.Decrypt(ctx, params) + if err != nil { + return "", fmt.Errorf("failed to decrypt ciphertext with kms: %v", err) + } + } + + plaintext := string(response.Plaintext) + return plaintext, nil +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter_test.go new file mode 100644 index 0000000000..5621fbbce4 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter_test.go @@ -0,0 +1,76 @@ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016-present Datadog, Inc. + +package metrics + +import ( + "bytes" + "context" + "errors" + "os" + "testing" + + "github.com/aws/aws-sdk-go-v2/service/kms" + "github.com/stretchr/testify/assert" +) + +// mockEncryptedAPIKeyBase64 represents an API key encrypted with KMS and encoded as a base64 string +const mockEncryptedAPIKeyBase64 = "MjIyMjIyMjIyMjIyMjIyMg==" + +// mockDecodedEncryptedAPIKey represents the encrypted API key after it has been decoded from base64 +const mockDecodedEncryptedAPIKey = "2222222222222222" + +// expectedDecryptedAPIKey represents the true value of the API key after decryption by KMS +const expectedDecryptedAPIKey = "1111111111111111" + +// mockFunctionName represents the name of the current function +var mockFunctionName = "my-Function" + +type mockKMSClientWithEncryptionContext struct{} + +func (mockKMSClientWithEncryptionContext) Decrypt(_ context.Context, params *kms.DecryptInput, _ ...func(*kms.Options)) (*kms.DecryptOutput, error) { + encryptionContextPointer, exists := params.EncryptionContext[encryptionContextKey] + if !exists { + return nil, errors.New("InvalidCiphertextException") + } + if encryptionContextPointer != mockFunctionName { + return nil, errors.New("InvalidCiphertextException") + } + if bytes.Equal(params.CiphertextBlob, []byte(mockDecodedEncryptedAPIKey)) { + return &kms.DecryptOutput{ + Plaintext: []byte(expectedDecryptedAPIKey), + }, nil + } + return nil, errors.New("KMS error") +} + +type mockKMSClientNoEncryptionContext struct{} + +func (mockKMSClientNoEncryptionContext) Decrypt(_ context.Context, params *kms.DecryptInput, _ ...func(*kms.Options)) (*kms.DecryptOutput, error) { + if params.EncryptionContext[encryptionContextKey] != "" { + return nil, errors.New("InvalidCiphertextException") + } + if bytes.Equal(params.CiphertextBlob, []byte(mockDecodedEncryptedAPIKey)) { + return &kms.DecryptOutput{ + Plaintext: []byte(expectedDecryptedAPIKey), + }, nil + } + return nil, errors.New("KMS error") +} + +func TestDecryptKMSWithEncryptionContext(t *testing.T) { + os.Setenv(functionNameEnvVar, mockFunctionName) + defer os.Setenv(functionNameEnvVar, "") + + client := mockKMSClientWithEncryptionContext{} + result, _ := decryptKMS(client, mockEncryptedAPIKeyBase64) + assert.Equal(t, expectedDecryptedAPIKey, result) +} + +func TestDecryptKMSNoEncryptionContext(t *testing.T) { + client := mockKMSClientNoEncryptionContext{} + result, _ := decryptKMS(client, mockEncryptedAPIKeyBase64) + assert.Equal(t, expectedDecryptedAPIKey, result) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go new file mode 100644 index 0000000000..5a97a978f9 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -0,0 +1,288 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "context" + "encoding/json" + "fmt" + "runtime" + "strconv" + "strings" + "time" + + "github.com/aws/aws-lambda-go/lambdacontext" + + "github.com/DataDog/datadog-go/v5/statsd" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" +) + +type ( + // Listener implements wrapper.HandlerListener, injecting metrics into the context + Listener struct { + apiClient *APIClient + statsdClient *statsd.Client + config *Config + processor Processor + isAgentRunning bool + extensionManager *extension.ExtensionManager + } + + // Config gives options for how the listener should work + Config struct { + APIKey string + KMSAPIKey string + Site string + ShouldRetryOnFailure bool + ShouldUseLogForwarder bool + BatchInterval time.Duration + EnhancedMetrics bool + HTTPClientTimeout time.Duration + CircuitBreakerInterval time.Duration + CircuitBreakerTimeout time.Duration + CircuitBreakerTotalFailures uint32 + LocalTest bool + FIPSMode bool + } + + logMetric struct { + MetricName string `json:"m"` + Value float64 `json:"v"` + Timestamp int64 `json:"e"` + Tags []string `json:"t"` + } +) + +// MakeListener initializes a new metrics lambda listener +func MakeListener(config Config, extensionManager *extension.ExtensionManager) Listener { + + var apiClient *APIClient + if !config.FIPSMode { + apiClient = MakeAPIClient(context.Background(), APIClientOptions{ + baseAPIURL: config.Site, + apiKey: config.APIKey, + decrypter: MakeKMSDecrypter(config.FIPSMode), + kmsAPIKey: config.KMSAPIKey, + httpClientTimeout: config.HTTPClientTimeout, + }) + } + + if config.HTTPClientTimeout <= 0 { + config.HTTPClientTimeout = defaultHttpClientTimeout + } + if config.CircuitBreakerInterval <= 0 { + config.CircuitBreakerInterval = defaultCircuitBreakerInterval + } + if config.CircuitBreakerTimeout <= 0 { + config.CircuitBreakerTimeout = defaultCircuitBreakerTimeout + } + if config.CircuitBreakerTotalFailures <= 0 { + config.CircuitBreakerTotalFailures = defaultCircuitBreakerTotalFailures + } + if config.BatchInterval <= 0 { + config.BatchInterval = defaultBatchInterval + } + + var statsdClient *statsd.Client + // immediate call to the Agent, if not a 200, fallback to API + // TODO(remy): we may want to use an environment var to force the use of the + // Agent instead of using this "discovery" implementation. + if extensionManager.IsExtensionRunning() { + var err error + if statsdClient, err = statsd.New("127.0.0.1:8125"); err != nil { + statsdClient = nil // force nil if an error occurred during statsd client init + } + } + + return Listener{ + apiClient: apiClient, + config: &config, + isAgentRunning: statsdClient != nil, + statsdClient: statsdClient, + processor: nil, + extensionManager: extensionManager, + } +} + +// canSendMetrics reports whether l can send metrics. +func (l *Listener) canSendMetrics() bool { + return l.isAgentRunning || l.config.ShouldUseLogForwarder || !l.config.FIPSMode || (l.apiClient != nil && (l.apiClient.apiKey != "" || l.config.KMSAPIKey != "")) +} + +// HandlerStarted adds metrics service to the context +func (l *Listener) HandlerStarted(ctx context.Context, msg json.RawMessage) context.Context { + if !l.canSendMetrics() { + logger.Error(fmt.Errorf("datadog api key isn't set, won't be able to send metrics")) + } + + ctx = AddListener(ctx, l) + + if !l.config.FIPSMode { + ts := MakeTimeService() + pr := MakeProcessor(ctx, l.apiClient, ts, l.config.BatchInterval, l.config.ShouldRetryOnFailure, l.config.CircuitBreakerInterval, l.config.CircuitBreakerTimeout, l.config.CircuitBreakerTotalFailures) + l.processor = pr + + // Setting the context on the client will mean that future requests will be cancelled correctly + // if the lambda times out. + l.apiClient.context = ctx + + pr.StartProcessing() + } + + l.submitEnhancedMetrics("invocations", ctx) + + return ctx +} + +// HandlerFinished implemented as part of the wrapper.HandlerListener interface +func (l *Listener) HandlerFinished(ctx context.Context, err error) { + if l.isAgentRunning { + // use the agent + // flush the metrics from the DogStatsD client to the Agent + if l.statsdClient != nil { + if err := l.statsdClient.Flush(); err != nil { + logger.Error(fmt.Errorf("can't flush the DogStatsD client: %s", err)) + } + } + // send a message to the Agent to flush the metrics + if l.config.LocalTest { + if err := l.extensionManager.Flush(); err != nil { + logger.Error(fmt.Errorf("error while flushing the metrics: %s", err)) + } + } + } else { + // use the api + if l.processor != nil { + if err != nil { + l.submitEnhancedMetrics("errors", ctx) + } + l.processor.FinishProcessing() + } + } +} + +// AddDistributionMetric sends a distribution metric +func (l *Listener) AddDistributionMetric(metric string, value float64, timestamp time.Time, forceLogForwarder bool, tags ...string) { + + // We add our own runtime tag to the metric for version tracking + tags = append(tags, getRuntimeTag()) + + if l.isAgentRunning { + err := l.statsdClient.Distribution(metric, value, tags, 1) + if err != nil { + logger.Error(fmt.Errorf("could not send metric %s: %s", metric, err.Error())) + } + return + } + + if l.config.ShouldUseLogForwarder || forceLogForwarder { + logger.Debug("sending metric via log forwarder") + unixTime := timestamp.Unix() + lm := logMetric{ + MetricName: metric, + Value: value, + Timestamp: unixTime, + Tags: tags, + } + result, err := json.Marshal(lm) + if err != nil { + logger.Error(fmt.Errorf("failed to marshall metric for log forwarder with error %v", err)) + return + } + payload := string(result) + logger.Raw(payload) + return + } + + if l.config.FIPSMode { + logger.Debug(fmt.Sprintf("skipping metric %s due to FIPS mode - direct API calls are disabled", metric)) + return + } + + m := Distribution{ + Name: metric, + Tags: tags, + Values: []MetricValue{}, + } + m.AddPoint(timestamp, value) + logger.Debug(fmt.Sprintf("adding metric \"%s\", with value %f", metric, value)) + l.processor.AddMetric(&m) +} + +func getRuntimeTag() string { + v := runtime.Version() + return fmt.Sprintf("dd_lambda_layer:datadog-%s", v) +} + +func (l *Listener) submitEnhancedMetrics(metricName string, ctx context.Context) { + if l.config.EnhancedMetrics { + tags := getEnhancedMetricsTags(ctx) + l.AddDistributionMetric(fmt.Sprintf("aws.lambda.enhanced.%s", metricName), 1, time.Now(), true, tags...) + } +} + +func getEnhancedMetricsTags(ctx context.Context) []string { + isColdStart := ctx.Value("cold_start") + + if lc, ok := lambdacontext.FromContext(ctx); ok { + // ex: arn:aws:lambda:us-east-1:123497558138:function:golang-layer:alias + splitArn := strings.Split(lc.InvokedFunctionArn, ":") + + // malformed arn string + if len(splitArn) < 5 { + logger.Debug("malformed arn string in the LambdaContext") + return []string{} + } + + var alias string + var executedVersion string + + functionName := fmt.Sprintf("functionname:%s", lambdacontext.FunctionName) + region := fmt.Sprintf("region:%s", splitArn[3]) + accountId := fmt.Sprintf("account_id:%s", splitArn[4]) + memorySize := fmt.Sprintf("memorysize:%d", lambdacontext.MemoryLimitInMB) + coldStart := fmt.Sprintf("cold_start:%t", isColdStart.(bool)) + resource := fmt.Sprintf("resource:%s", lambdacontext.FunctionName) + datadogLambda := fmt.Sprintf("datadog_lambda:v%s", version.DDLambdaVersion) + + tags := []string{functionName, region, accountId, memorySize, coldStart, datadogLambda} + + // Check if our slice contains an alias or version + if len(splitArn) > 7 { + alias = splitArn[7] + + // If we have an alias... + switch alias != "" { + // If the alias is $Latest, drop the $ for ddog tag conventio + case strings.HasPrefix(alias, "$"): + alias = strings.TrimPrefix(alias, "$") + // If this is not a version number, we will have an alias and executed version + case isNotNumeric(alias): + executedVersion = fmt.Sprintf("executedversion:%s", lambdacontext.FunctionVersion) + tags = append(tags, executedVersion) + } + + resource = fmt.Sprintf("resource:%s:%s", lambdacontext.FunctionName, alias) + } + + tags = append(tags, resource) + + return tags + } + + logger.Debug("could not retrieve the LambdaContext from Context") + return []string{} +} + +func isNotNumeric(s string) bool { + _, err := strconv.ParseInt(s, 0, 64) + return err != nil +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go new file mode 100644 index 0000000000..6e25870a36 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -0,0 +1,292 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "net" + "net/http" + "net/http/httptest" + "os" + "strings" + "testing" + "time" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" + "github.com/aws/aws-lambda-go/lambdacontext" + + "github.com/stretchr/testify/assert" +) + +func captureOutput(f func()) string { + var buf bytes.Buffer + logger.SetOutput(&buf) + f() + logger.SetOutput(os.Stderr) + return buf.String() +} + +func TestHandlerAddsItselfToContext(t *testing.T) { + listener := MakeListener(Config{}, &extension.ExtensionManager{}) + ctx := listener.HandlerStarted(context.Background(), json.RawMessage{}) + pr := GetListener(ctx) + assert.NotNil(t, pr) +} + +func TestHandlerFinishesProcessing(t *testing.T) { + listener := MakeListener(Config{}, &extension.ExtensionManager{}) + ctx := listener.HandlerStarted(context.Background(), json.RawMessage{}) + + listener.HandlerFinished(ctx, nil) + assert.False(t, listener.processor.IsProcessing()) +} + +func TestAddDistributionMetricWithAPI(t *testing.T) { + + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + assert.Equal(t, "/distribution_points?api_key=12345", r.URL.String()) + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + listener := MakeListener(Config{APIKey: "12345", Site: server.URL}, &extension.ExtensionManager{}) + ctx := listener.HandlerStarted(context.Background(), json.RawMessage{}) + listener.AddDistributionMetric("the-metric", 2, time.Now(), false, "tag:a", "tag:b") + listener.HandlerFinished(ctx, nil) + assert.True(t, called) +} + +func TestAddDistributionMetricWithLogForwarder(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + listener := MakeListener(Config{APIKey: "12345", Site: server.URL, ShouldUseLogForwarder: true}, &extension.ExtensionManager{}) + ctx := listener.HandlerStarted(context.Background(), json.RawMessage{}) + listener.AddDistributionMetric("the-metric", 2, time.Now(), false, "tag:a", "tag:b") + listener.HandlerFinished(ctx, nil) + assert.False(t, called) +} +func TestAddDistributionMetricWithForceLogForwarder(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + listener := MakeListener(Config{APIKey: "12345", Site: server.URL, ShouldUseLogForwarder: false}, &extension.ExtensionManager{}) + ctx := listener.HandlerStarted(context.Background(), json.RawMessage{}) + listener.AddDistributionMetric("the-metric", 2, time.Now(), true, "tag:a", "tag:b") + listener.HandlerFinished(ctx, nil) + assert.False(t, called) +} + +func TestAddDistributionMetricWithFIPSMode(t *testing.T) { + // Setup a test server to detect if any API calls are made + apiCallAttempted := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + apiCallAttempted = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + // Create a listener with FIPS mode enabled + listener := MakeListener(Config{ + APIKey: "12345", + Site: server.URL, + FIPSMode: true, + }, &extension.ExtensionManager{}) + + // Verify the API client wasn't created + assert.Nil(t, listener.apiClient, "API client should be nil when FIPS mode is enabled") + + // Initialize the listener + ctx := listener.HandlerStarted(context.Background(), json.RawMessage{}) + + // Verify processor wasn't initialized + assert.Nil(t, listener.processor, "Processor should be nil when FIPS mode is enabled") + + // Log calls to validate we're getting the expected log message + var logOutput string + logger.SetLogLevel(logger.LevelDebug) + logOutput = captureOutput(func() { + listener.AddDistributionMetric("fips-test-metric", 42, time.Now(), false, "tag:fips") + }) + + // Check that we logged the skipping message + assert.Contains(t, logOutput, "skipping metric fips-test-metric due to FIPS mode", "Expected log about skipping metric") + assert.Contains(t, logOutput, "direct API calls are disabled", "Expected log about disabled API calls") + + // Finish the handler + listener.HandlerFinished(ctx, nil) + + // Check that no API call was attempted + assert.False(t, apiCallAttempted, "No API call should be attempted when FIPS mode is enabled") +} + +func TestGetEnhancedMetricsTags(t *testing.T) { + //nolint + ctx := context.WithValue(context.Background(), "cold_start", false) + + lambdacontext.MemoryLimitInMB = 256 + lambdacontext.FunctionName = "go-lambda-test" + lc := &lambdacontext.LambdaContext{ + InvokedFunctionArn: "arn:aws:lambda:us-east-1:123497558138:function:go-lambda-test:$Latest", + } + tags := getEnhancedMetricsTags(lambdacontext.NewContext(ctx, lc)) + + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:v" + version.DDLambdaVersion}) +} + +func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { + //nolint + ctx := context.WithValue(context.Background(), "cold_start", false) + + lambdacontext.MemoryLimitInMB = 256 + lambdacontext.FunctionName = "go-lambda-test" + lambdacontext.FunctionVersion = "1" + lc := &lambdacontext.LambdaContext{ + InvokedFunctionArn: "arn:aws:lambda:us-east-1:123497558138:function:go-lambda-test:my-alias", + } + + tags := getEnhancedMetricsTags((lambdacontext.NewContext(ctx, lc))) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:v" + version.DDLambdaVersion}) +} + +func TestGetEnhancedMetricsTagsNoLambdaContext(t *testing.T) { + //nolint + ctx := context.WithValue(context.Background(), "cold_start", true) + tags := getEnhancedMetricsTags(ctx) + + assert.Empty(t, tags) +} + +func TestSubmitEnhancedMetrics(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + ml := MakeListener( + Config{ + APIKey: "abc-123", + Site: server.URL, + EnhancedMetrics: true, + }, + &extension.ExtensionManager{}, + ) + //nolint + ctx := context.WithValue(context.Background(), "cold_start", false) + + output := captureOutput(func() { + ctx = ml.HandlerStarted(ctx, json.RawMessage{}) + ml.HandlerFinished(ctx, nil) + }) + + assert.False(t, called) + expected := "{\"m\":\"aws.lambda.enhanced.invocations\",\"v\":1," + assert.True(t, strings.Contains(output, expected)) +} + +func TestDoNotSubmitEnhancedMetrics(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + ml := MakeListener( + Config{ + APIKey: "abc-123", + Site: server.URL, + EnhancedMetrics: false, + }, + &extension.ExtensionManager{}, + ) + //nolint + ctx := context.WithValue(context.Background(), "cold_start", true) + + output := captureOutput(func() { + ctx = ml.HandlerStarted(ctx, json.RawMessage{}) + ml.HandlerFinished(ctx, nil) + }) + + assert.False(t, called) + expected := "{\"m\":\"aws.lambda.enhanced.invocations\",\"v\":1," + assert.False(t, strings.Contains(output, expected)) +} + +func TestSubmitEnhancedMetricsOnlyErrors(t *testing.T) { + called := false + server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + w.WriteHeader(http.StatusCreated) + })) + defer server.Close() + + ml := MakeListener( + Config{ + APIKey: "abc-123", + Site: server.URL, + EnhancedMetrics: false, + }, + &extension.ExtensionManager{}, + ) + //nolint + ctx := context.WithValue(context.Background(), "cold_start", true) + + output := captureOutput(func() { + ctx = ml.HandlerStarted(ctx, json.RawMessage{}) + ml.config.EnhancedMetrics = true + err := errors.New("something went wrong") + ml.HandlerFinished(ctx, err) + }) + + assert.False(t, called) + expected := "{\"m\":\"aws.lambda.enhanced.errors\",\"v\":1," + assert.True(t, strings.Contains(output, expected)) +} + +func TestListenerHandlerFinishedFlushes(t *testing.T) { + var called bool + + ts := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + called = true + })) + ts.Listener.Close() + ts.Listener, _ = net.Listen("tcp", "127.0.0.1:8124") + + ts.Start() + defer ts.Close() + + listener := MakeListener(Config{}, extension.BuildExtensionManager(false)) + listener.isAgentRunning = true + for _, localTest := range []bool{true, false} { + t.Run(fmt.Sprintf("%#v", localTest), func(t *testing.T) { + called = false + listener.config.LocalTest = localTest + listener.HandlerFinished(context.TODO(), nil) + assert.Equal(t, called, localTest) + }) + } +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/model.go b/contrib/aws/datadog-lambda-go/internal/metrics/model.go new file mode 100644 index 0000000000..d4e3aea057 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/model.go @@ -0,0 +1,96 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "time" +) + +type ( + // Metric represents a metric that can have any kind of + Metric interface { + AddPoint(timestamp time.Time, value float64) + ToAPIMetric(interval time.Duration) []APIMetric + ToBatchKey() BatchKey + Join(metric Metric) + } + + // APIMetric is a metric that can be marshalled to send to the metrics API + APIMetric struct { + Name string `json:"metric"` + Host *string `json:"host,omitempty"` + Tags []string `json:"tags,omitempty"` + MetricType MetricType `json:"type"` + Interval *float64 `json:"interval,omitempty"` + Points []interface{} `json:"points"` + } + + // MetricValue represents a datapoint for a metric + MetricValue struct { + Value float64 + Timestamp time.Time + } + + // Distribution is a type of metric that is aggregated over multiple hosts + Distribution struct { + Name string + Tags []string + Host *string + Values []MetricValue + } +) + +// AddPoint adds a point to the distribution metric +func (d *Distribution) AddPoint(timestamp time.Time, value float64) { + d.Values = append(d.Values, MetricValue{Timestamp: timestamp, Value: value}) +} + +// ToBatchKey returns a key that can be used to batch the metric +func (d *Distribution) ToBatchKey() BatchKey { + return BatchKey{ + name: d.Name, + host: d.Host, + tags: d.Tags, + metricType: DistributionType, + } +} + +// Join creates a union between two metric sets +func (d *Distribution) Join(metric Metric) { + otherDist, ok := metric.(*Distribution) + if !ok { + return + } + for _, val := range otherDist.Values { + d.AddPoint(val.Timestamp, val.Value) + } + +} + +// ToAPIMetric converts a distribution into an API ready format. +func (d *Distribution) ToAPIMetric(interval time.Duration) []APIMetric { + points := make([]interface{}, len(d.Values)) + + for i, val := range d.Values { + currentTime := float64(val.Timestamp.Unix()) + + points[i] = []interface{}{currentTime, []interface{}{val.Value}} + } + + return []APIMetric{ + APIMetric{ + Name: d.Name, + Host: d.Host, + Tags: d.Tags, + MetricType: DistributionType, + Points: points, + Interval: nil, + }, + } +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/processor.go b/contrib/aws/datadog-lambda-go/internal/metrics/processor.go new file mode 100644 index 0000000000..d890bbb271 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/processor.go @@ -0,0 +1,189 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "context" + "fmt" + "sync" + "time" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/cenkalti/backoff/v4" + "github.com/sony/gobreaker" +) + +type ( + // Processor is used to batch metrics on a background thread, and send them on to a client periodically. + Processor interface { + // AddMetric sends a metric to the agent + AddMetric(metric Metric) + // StartProcessing begins processing metrics asynchronously + StartProcessing() + // FinishProcessing shuts down the agent, and tries to flush any remaining metrics + FinishProcessing() + // Whether the processor is still processing + IsProcessing() bool + } + + processor struct { + context context.Context + metricsChan chan Metric + timeService TimeService + waitGroup sync.WaitGroup + batchInterval time.Duration + client Client + batcher *Batcher + shouldRetryOnFail bool + isProcessing bool + breaker *gobreaker.CircuitBreaker + } +) + +// MakeProcessor creates a new metrics context +func MakeProcessor(ctx context.Context, client Client, timeService TimeService, batchInterval time.Duration, shouldRetryOnFail bool, circuitBreakerInterval time.Duration, circuitBreakerTimeout time.Duration, circuitBreakerTotalFailures uint32) Processor { + batcher := MakeBatcher(batchInterval) + + breaker := MakeCircuitBreaker(circuitBreakerInterval, circuitBreakerTimeout, circuitBreakerTotalFailures) + + return &processor{ + context: ctx, + metricsChan: make(chan Metric, 2000), + batchInterval: batchInterval, + waitGroup: sync.WaitGroup{}, + client: client, + batcher: batcher, + shouldRetryOnFail: shouldRetryOnFail, + timeService: timeService, + isProcessing: false, + breaker: breaker, + } +} + +func MakeCircuitBreaker(circuitBreakerInterval time.Duration, circuitBreakerTimeout time.Duration, circuitBreakerTotalFailures uint32) *gobreaker.CircuitBreaker { + readyToTrip := func(counts gobreaker.Counts) bool { + return counts.TotalFailures > circuitBreakerTotalFailures + } + + st := gobreaker.Settings{ + Name: "post distribution_points", + Interval: circuitBreakerInterval, + Timeout: circuitBreakerTimeout, + ReadyToTrip: readyToTrip, + } + return gobreaker.NewCircuitBreaker(st) +} + +func (p *processor) AddMetric(metric Metric) { + // We use a large buffer in the metrics channel, to make this operation non-blocking. + // However, if the channel does fill up, this will become a blocking operation. + p.metricsChan <- metric +} + +func (p *processor) StartProcessing() { + if !p.isProcessing { + p.isProcessing = true + p.waitGroup.Add(1) + go p.processMetrics() + } + +} + +func (p *processor) FinishProcessing() { + if !p.isProcessing { + p.StartProcessing() + } + // Closes the metrics channel, and waits for the last send to complete + close(p.metricsChan) + p.waitGroup.Wait() +} + +func (p *processor) IsProcessing() bool { + return p.isProcessing +} + +func (p *processor) processMetrics() { + + ticker := p.timeService.NewTicker(p.batchInterval) + + doneChan := p.context.Done() + shouldExit := false + for !shouldExit { + shouldSendBatch := false + // Batches metrics until timeout is reached + select { + case <-doneChan: + // This process is being cancelled by the context,(probably due to a lambda deadline), exit without flushing. + shouldExit = true + case m, ok := <-p.metricsChan: + if !ok { + // The channel has now been closed + shouldSendBatch = true + shouldExit = true + } else { + p.batcher.AddMetric(m) + } + case <-ticker.C: + // We are ready to send a batch to our backend + shouldSendBatch = true + } + // Since the go select statement picks randomly if multiple values are available, it's possible the done channel was + // closed, but another channel was selected instead. We double check the done channel, to make sure this isn't he case. + select { + case <-doneChan: + shouldExit = true + shouldSendBatch = false + default: + // Non-blocking + } + + if shouldSendBatch { + _, err := p.breaker.Execute(func() (interface{}, error) { + if shouldExit && p.shouldRetryOnFail { + // If we are shutting down, and we just failed to send our last batch, do a retry + bo := backoff.WithMaxRetries(backoff.NewConstantBackOff(defaultRetryInterval), 2) + err := backoff.Retry(p.sendMetricsBatch, bo) + if err != nil { + return nil, fmt.Errorf("after retry: %v", err) + } + } else { + err := p.sendMetricsBatch() + if err != nil { + return nil, fmt.Errorf("with no retry: %v", err) + } + } + return nil, nil + }) + if err != nil { + logger.Error(fmt.Errorf("failed to flush metrics to datadog API: %v", err)) + } + } + } + ticker.Stop() + p.isProcessing = false + p.waitGroup.Done() +} + +func (p *processor) sendMetricsBatch() error { + mts := p.batcher.ToAPIMetrics() + if len(mts) > 0 { + oldBatcher := p.batcher + p.batcher = MakeBatcher(p.batchInterval) + + err := p.client.SendMetrics(mts) + if err != nil { + if p.shouldRetryOnFail { + // If we want to retry on error, keep the metrics in the batcher until they are sent correctly. + p.batcher = oldBatcher + } + return err + } + } + return nil +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go new file mode 100644 index 0000000000..3ef25d175e --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go @@ -0,0 +1,259 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import ( + "context" + "errors" + "math" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +type ( + mockClient struct { + batches chan []APIMetric + sendMetricsCalledCount int + err error + } + + mockTimeService struct { + now time.Time + tickerChan chan time.Time + } +) + +func makeMockClient() mockClient { + return mockClient{ + batches: make(chan []APIMetric, 10), + err: nil, + } +} + +func makeMockTimeService() mockTimeService { + return mockTimeService{ + now: time.Now(), + tickerChan: make(chan time.Time), + } +} + +func (mc *mockClient) SendMetrics(mts []APIMetric) error { + mc.sendMetricsCalledCount++ + mc.batches <- mts + return mc.err +} + +func (ts *mockTimeService) NewTicker(duration time.Duration) *time.Ticker { + return &time.Ticker{ + C: ts.tickerChan, + } +} + +func (ts *mockTimeService) Now() time.Time { + return ts.now +} + +func TestProcessorBatches(t *testing.T) { + mc := makeMockClient() + mts := makeMockTimeService() + + mts.now, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05Z") + nowUnix := float64(mts.now.Unix()) + + processor := MakeProcessor(context.Background(), &mc, &mts, 1000, false, time.Hour*1000, time.Hour*1000, math.MaxUint32) + + d1 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: mts.now, Value: 1}, {Timestamp: mts.now, Value: 2}, {Timestamp: mts.now, Value: 3}}, + } + d2 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: mts.now, Value: 4}, {Timestamp: mts.now, Value: 5}, {Timestamp: mts.now, Value: 6}}, + } + + processor.AddMetric(&d1) + processor.AddMetric(&d2) + + processor.StartProcessing() + processor.FinishProcessing() + + firstBatch := <-mc.batches + + assert.Equal(t, []APIMetric{{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{nowUnix, []interface{}{float64(1)}}, + []interface{}{nowUnix, []interface{}{float64(2)}}, + []interface{}{nowUnix, []interface{}{float64(3)}}, + []interface{}{nowUnix, []interface{}{float64(4)}}, + []interface{}{nowUnix, []interface{}{float64(5)}}, + []interface{}{nowUnix, []interface{}{float64(6)}}, + }, + }}, firstBatch) +} + +func TestProcessorBatchesPerTick(t *testing.T) { + mc := makeMockClient() + mts := makeMockTimeService() + + firstTime, _ := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z") + firstTimeUnix := float64(firstTime.Unix()) + secondTime, _ := time.Parse(time.RFC3339, "2007-01-02T15:04:05Z") + secondTimeUnix := float64(secondTime.Unix()) + mts.now = firstTime + + processor := MakeProcessor(context.Background(), &mc, &mts, 1000, false, time.Hour*1000, time.Hour*1000, math.MaxUint32) + + d1 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: firstTime, Value: 1}, {Timestamp: firstTime, Value: 2}}, + } + d2 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: firstTime, Value: 3}}, + } + d3 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: secondTime, Value: 4}, {Timestamp: secondTime, Value: 5}}, + } + d4 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: secondTime, Value: 6}}, + } + + processor.StartProcessing() + + processor.AddMetric(&d1) + processor.AddMetric(&d2) + + // This wait is necessary to make sure both metrics have been added to the batch + <-time.Tick(time.Millisecond * 10) + // Sending time to the ticker channel will flush the batch. + mts.tickerChan <- firstTime + firstBatch := <-mc.batches + mts.now = secondTime + + processor.AddMetric(&d3) + processor.AddMetric(&d4) + + processor.FinishProcessing() + secondBatch := <-mc.batches + batches := [][]APIMetric{firstBatch, secondBatch} + + assert.Equal(t, [][]APIMetric{ + []APIMetric{ + { + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{firstTimeUnix, []interface{}{float64(1)}}, + []interface{}{firstTimeUnix, []interface{}{float64(2)}}, + []interface{}{firstTimeUnix, []interface{}{float64(3)}}, + }, + }}, + []APIMetric{ + { + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + MetricType: DistributionType, + Points: []interface{}{ + []interface{}{secondTimeUnix, []interface{}{float64(4)}}, + []interface{}{secondTimeUnix, []interface{}{float64(5)}}, + []interface{}{secondTimeUnix, []interface{}{float64(6)}}, + }, + }}, + }, batches) +} + +func TestProcessorPerformsRetry(t *testing.T) { + mc := makeMockClient() + mts := makeMockTimeService() + + mts.now, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05Z") + + shouldRetry := true + processor := MakeProcessor(context.Background(), &mc, &mts, 1000, shouldRetry, time.Hour*1000, time.Hour*1000, math.MaxUint32) + + d1 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: mts.now, Value: 1}, {Timestamp: mts.now, Value: 2}, {Timestamp: mts.now, Value: 3}}, + } + + mc.err = errors.New("Some error") + + processor.AddMetric(&d1) + + processor.FinishProcessing() + + assert.Equal(t, 3, mc.sendMetricsCalledCount) +} + +func TestProcessorCancelsWithContext(t *testing.T) { + mc := makeMockClient() + mts := makeMockTimeService() + + mts.now, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05Z") + + shouldRetry := true + ctx, cancelFunc := context.WithCancel(context.Background()) + processor := MakeProcessor(ctx, &mc, &mts, 1000, shouldRetry, time.Hour*1000, time.Hour*1000, math.MaxUint32) + + d1 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: mts.now, Value: 1}, {Timestamp: mts.now, Value: 2}, {Timestamp: mts.now, Value: 3}}, + } + + processor.AddMetric(&d1) + // After calling cancelFunc, no metrics should be processed/sent + cancelFunc() + //<-time.Tick(time.Millisecond * 100) + + processor.FinishProcessing() + + assert.Equal(t, 0, mc.sendMetricsCalledCount) +} + +func TestProcessorBatchesWithOpeningCircuitBreaker(t *testing.T) { + mc := makeMockClient() + mts := makeMockTimeService() + + mts.now, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05Z") + + // Will open the circuit breaker at number of total failures > 1 + circuitBreakerTotalFailures := uint32(1) + processor := MakeProcessor(context.Background(), &mc, &mts, 1000, false, time.Hour*1000, time.Hour*1000, circuitBreakerTotalFailures) + + d1 := Distribution{ + Name: "metric-1", + Tags: []string{"a", "b", "c"}, + Values: []MetricValue{{Timestamp: mts.now, Value: 1}, {Timestamp: mts.now, Value: 2}, {Timestamp: mts.now, Value: 3}}, + } + + mc.err = errors.New("Some error") + + processor.AddMetric(&d1) + + processor.FinishProcessing() + + // It should have retried 3 times, but circuit breaker opened at the second time + assert.Equal(t, 1, mc.sendMetricsCalledCount) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/time.go b/contrib/aws/datadog-lambda-go/internal/metrics/time.go new file mode 100644 index 0000000000..ed71525eaa --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/metrics/time.go @@ -0,0 +1,35 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package metrics + +import "time" + +type ( + //TimeService wraps common time related operations + TimeService interface { + NewTicker(duration time.Duration) *time.Ticker + Now() time.Time + } + + timeService struct { + } +) + +// MakeTimeService creates a new time service +func MakeTimeService() TimeService { + return &timeService{} +} + +func (ts *timeService) NewTicker(duration time.Duration) *time.Ticker { + return time.NewTicker(duration) +} + +func (ts *timeService) Now() time.Time { + return time.Now() +} diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/apig-event-no-headers.json b/contrib/aws/datadog-lambda-go/internal/testdata/apig-event-no-headers.json new file mode 100644 index 0000000000..82c5caa632 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/apig-event-no-headers.json @@ -0,0 +1,57 @@ +{ + "body": "{{.body}}", + "resource": "{{.resource}}", + "requestContext": { + "resourceId": "123456", + "apiId": "1234567890", + "resourcePath": "{{.resource}}", + "httpMethod": "{{.method}}", + "requestId": "c6af9ac6-7b61-11e6-9a41-93e8deadbeef", + "accountId": "123456789012", + "identity": { + "apiKey": null, + "userArn": null, + "cognitoAuthenticationType": null, + "caller": null, + "userAgent": "Custom User Agent String", + "user": null, + "cognitoIdentityPoolId": null, + "cognitoIdentityId": null, + "cognitoAuthenticationProvider": null, + "sourceIp": "127.0.0.1", + "accountId": null + }, + "stage": "prod" + }, + "queryStringParameters": { + "foo": "bar" + }, + "headers": { + "Via": "1.1 08f323deadbeefa7af34d5feb414ce27.cloudfront.net (CloudFront)", + "Accept-Language": "en-US,en;q=0.8", + "CloudFront-Is-Desktop-Viewer": "true", + "CloudFront-Is-SmartTV-Viewer": "false", + "CloudFront-Is-Mobile-Viewer": "false", + "X-Forwarded-For": "127.0.0.1, 127.0.0.2", + "CloudFront-Viewer-Country": "US", + "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", + "Upgrade-Insecure-Requests": "1", + "X-Forwarded-Port": "443", + "Host": "1234567890.execute-api.us-east-1.amazonaws.com", + "X-Forwarded-Proto": "https", + "X-Amz-Cf-Id": "cDehVQoZnx43VYQb9j2-nvCh-9z396Uhbp027Y2JvkCPNLmGJHqlaA==", + "CloudFront-Is-Tablet-Viewer": "false", + "Cache-Control": "max-age=0", + "User-Agent": "Custom User Agent String", + "CloudFront-Forwarded-Proto": "https", + "Accept-Encoding": "gzip, deflate, sdch" + }, + "pathParameters": { + "proxy": "{{.path}}" + }, + "httpMethod": "{{.method}}", + "stageVariables": { + "baz": "qux" + }, + "path": "{{.path}}" + } \ No newline at end of file diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/apig-event-with-headers.json b/contrib/aws/datadog-lambda-go/internal/testdata/apig-event-with-headers.json new file mode 100644 index 0000000000..754a81a966 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/apig-event-with-headers.json @@ -0,0 +1,60 @@ +{ + "body": "{{.body}}", + "resource": "{{.resource}}", + "requestContext": { + "resourceId": "123456", + "apiId": "1234567890", + "resourcePath": "{{.resource}}", + "httpMethod": "{{.method}}", + "requestId": "c6af9ac6-7b61-11e6-9a41-93e8deadbeef", + "accountId": "123456789012", + "identity": { + "apiKey": null, + "userArn": null, + "cognitoAuthenticationType": null, + "caller": null, + "userAgent": "Custom User Agent String", + "user": null, + "cognitoIdentityPoolId": null, + "cognitoIdentityId": null, + "cognitoAuthenticationProvider": null, + "sourceIp": "127.0.0.1", + "accountId": null + }, + "stage": "prod" + }, + "queryStringParameters": { + "foo": "bar" + }, + "headers": { + "Via": "1.1 08f323deadbeefa7af34d5feb414ce27.cloudfront.net (CloudFront)", + "Accept-Language": "en-US,en;q=0.8", + "CloudFront-Is-Desktop-Viewer": "true", + "CloudFront-Is-SmartTV-Viewer": "false", + "CloudFront-Is-Mobile-Viewer": "false", + "X-Forwarded-For": "127.0.0.1, 127.0.0.2", + "CloudFront-Viewer-Country": "US", + "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", + "Upgrade-Insecure-Requests": "1", + "X-Forwarded-Port": "443", + "Host": "1234567890.execute-api.us-east-1.amazonaws.com", + "X-Forwarded-Proto": "https", + "X-Amz-Cf-Id": "cDehVQoZnx43VYQb9j2-nvCh-9z396Uhbp027Y2JvkCPNLmGJHqlaA==", + "CloudFront-Is-Tablet-Viewer": "false", + "Cache-Control": "max-age=0", + "User-Agent": "Custom User Agent String", + "CloudFront-Forwarded-Proto": "https", + "Accept-Encoding": "gzip, deflate, sdch", + "x-datadog-trace-id": "1231452342", + "x-datadog-parent-id": "45678910", + "x-datadog-sampling-priority": "2" + }, + "pathParameters": { + "proxy": "{{.path}}" + }, + "httpMethod": "{{.method}}", + "stageVariables": { + "baz": "qux" + }, + "path": "{{.path}}" + } \ No newline at end of file diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/invalid.json b/contrib/aws/datadog-lambda-go/internal/testdata/invalid.json new file mode 100644 index 0000000000..049b861b58 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/invalid.json @@ -0,0 +1,3 @@ +{ + "tag-left-open": [ + " \ No newline at end of file diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-no-headers.json b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-no-headers.json new file mode 100644 index 0000000000..8a97772560 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-no-headers.json @@ -0,0 +1,6 @@ +{ + "my-custom-event": { + "hello": 100 + }, + "fake-id": "12345678910" +} \ No newline at end of file diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-headers.json b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-headers.json new file mode 100644 index 0000000000..c167cc37d5 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-headers.json @@ -0,0 +1,11 @@ +{ + "my-custom-event": { + "hello": 100 + }, + "fake-id": "12345678910", + "headers": { + "x-datadog-trace-id": "1231452342", + "x-datadog-parent-id": "45678910", + "x-datadog-sampling-priority": "2" + } +} \ No newline at end of file diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-missing-sampling-priority.json b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-missing-sampling-priority.json new file mode 100644 index 0000000000..005e0ed4d0 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-missing-sampling-priority.json @@ -0,0 +1,10 @@ +{ + "my-custom-event": { + "hello": 100 + }, + "fake-id": "12345678910", + "headers": { + "X-Datadog-Trace-Id": "1231452342", + "X-Datadog-Parent-Id": "45678910" + } +} diff --git a/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-mixed-case-headers.json b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-mixed-case-headers.json new file mode 100644 index 0000000000..42da8a7d92 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/testdata/non-proxy-with-mixed-case-headers.json @@ -0,0 +1,11 @@ +{ + "my-custom-event": { + "hello": 100 + }, + "fake-id": "12345678910", + "headers": { + "X-Datadog-Trace-Id": "1231452342", + "X-Datadog-Parent-Id": "45678910", + "X-Datadog-Sampling-Priority": "2" + } +} diff --git a/contrib/aws/datadog-lambda-go/internal/trace/constants.go b/contrib/aws/datadog-lambda-go/internal/trace/constants.go new file mode 100644 index 0000000000..21a66e6061 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/trace/constants.go @@ -0,0 +1,28 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package trace + +const ( + traceIDHeader = "x-datadog-trace-id" + parentIDHeader = "x-datadog-parent-id" + samplingPriorityHeader = "x-datadog-sampling-priority" +) + +const ( + userReject = "-1" + // autoReject = "0" + // autoKeep = "1" + userKeep = "2" +) + +const ( + xraySubsegmentName = "datadog-metadata" + xraySubsegmentKey = "trace" + xraySubsegmentNamespace = "datadog" +) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context.go b/contrib/aws/datadog-lambda-go/internal/trace/context.go new file mode 100644 index 0000000000..68ed214d11 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/trace/context.go @@ -0,0 +1,294 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package trace + +import ( + "context" + "encoding/binary" + "encoding/hex" + "encoding/json" + "fmt" + "strconv" + "strings" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/aws/aws-xray-sdk-go/v2/header" + "github.com/aws/aws-xray-sdk-go/v2/xray" + "github.com/DataDog/dd-trace-go/v2/ddtrace" + "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" +) + +type ( + eventWithHeaders struct { + Headers map[string]string `json:"headers"` + } + + // TraceContext is map of headers containing a Datadog trace context. + TraceContext map[string]string + + // ContextExtractor is a func type for extracting a root TraceContext. + ContextExtractor func(ctx context.Context, ev json.RawMessage) map[string]string +) + +type contextKeytype int + +// traceContextKey is the key used to store a TraceContext in a TraceContext object +var traceContextKey = new(contextKeytype) + +// DefaultTraceExtractor is the default trace extractor. Extracts root trace from API Gateway headers. +var DefaultTraceExtractor = getHeadersFromEventHeaders + +// contextWithRootTraceContext uses the incoming event and context object payloads to determine +// the root TraceContext and then adds that TraceContext to the context object. +func contextWithRootTraceContext(ctx context.Context, ev json.RawMessage, mergeXrayTraces bool, extractor ContextExtractor) (context.Context, error) { + datadogTraceContext, gotDatadogTraceContext := getTraceContext(ctx, extractor(ctx, ev)) + + xrayTraceContext, errGettingXrayContext := convertXrayTraceContextFromLambdaContext(ctx) + if errGettingXrayContext != nil { + logger.Error(fmt.Errorf("Couldn't convert X-Ray trace context: %v", errGettingXrayContext)) + } + + if gotDatadogTraceContext && errGettingXrayContext == nil { + err := createDummySubsegmentForXrayConverter(ctx, datadogTraceContext) + if err != nil { + logger.Error(fmt.Errorf("Couldn't create segment: %v", err)) + } + } + + if !mergeXrayTraces { + logger.Debug("Merge X-Ray Traces is off, using trace context from Datadog only") + return context.WithValue(ctx, traceContextKey, datadogTraceContext), nil + } + + if !gotDatadogTraceContext { + logger.Debug("Merge X-Ray Traces is on, but did not get incoming Datadog trace context; using X-Ray trace context instead") + return context.WithValue(ctx, traceContextKey, xrayTraceContext), nil + } + + logger.Debug("Using merged Datadog/X-Ray trace context") + mergedTraceContext := TraceContext{} + mergedTraceContext[traceIDHeader] = datadogTraceContext[traceIDHeader] + mergedTraceContext[samplingPriorityHeader] = datadogTraceContext[samplingPriorityHeader] + mergedTraceContext[parentIDHeader] = xrayTraceContext[parentIDHeader] + return context.WithValue(ctx, traceContextKey, mergedTraceContext), nil +} + +// ConvertCurrentXrayTraceContext returns the current X-Ray trace context converted to Datadog headers, taking into account +// the current subsegment. It is designed for sending Datadog trace headers from functions instrumented with the X-Ray SDK. +func ConvertCurrentXrayTraceContext(ctx context.Context) TraceContext { + if xrayTraceContext, err := convertXrayTraceContextFromLambdaContext(ctx); err == nil { + // If there is an active X-Ray segment, use it as the parent + parentID := xrayTraceContext[parentIDHeader] + segment := xray.GetSegment(ctx) + if segment != nil { + newParentID, err := convertXRayEntityIDToDatadogParentID(segment.ID) + if err == nil { + parentID = newParentID + } + } + + newTraceContext := map[string]string{} + newTraceContext[traceIDHeader] = xrayTraceContext[traceIDHeader] + newTraceContext[samplingPriorityHeader] = xrayTraceContext[samplingPriorityHeader] + newTraceContext[parentIDHeader] = parentID + + return newTraceContext + } + return map[string]string{} +} + +// createDummySubsegmentForXrayConverter creates a dummy X-Ray subsegment containing Datadog trace context metadata. +// This metadata is used by the Datadog X-Ray converter to parent the X-Ray trace under the Datadog trace. +// This subsegment will be dropped by the X-Ray converter and will not appear in Datadog. +func createDummySubsegmentForXrayConverter(ctx context.Context, traceCtx TraceContext) error { + _, segment := xray.BeginSubsegment(ctx, xraySubsegmentName) + + traceID := traceCtx[traceIDHeader] + parentID := traceCtx[parentIDHeader] + sampled := traceCtx[samplingPriorityHeader] + metadata := map[string]string{ + "trace-id": traceID, + "parent-id": parentID, + "sampling-priority": sampled, + } + + err := segment.AddMetadataToNamespace(xraySubsegmentNamespace, xraySubsegmentKey, metadata) + if err != nil { + return fmt.Errorf("couldn't save trace context to XRay: %v", err) + } + segment.Close(nil) + return nil +} + +func getTraceContext(ctx context.Context, headers map[string]string) (TraceContext, bool) { + tc := TraceContext{} + + traceID := headers[traceIDHeader] + if traceID == "" { + if val, ok := ctx.Value(extension.DdTraceId).(string); ok { + traceID = val + } + } + if traceID == "" { + return tc, false + } + + parentID := headers[parentIDHeader] + if parentID == "" { + if val, ok := ctx.Value(extension.DdParentId).(string); ok { + parentID = val + } + } + if parentID == "" { + return tc, false + } + + samplingPriority := headers[samplingPriorityHeader] + if samplingPriority == "" { + if val, ok := ctx.Value(extension.DdSamplingPriority).(string); ok { + samplingPriority = val + } + } + if samplingPriority == "" { + samplingPriority = "1" //sampler-keep + } + + tc[samplingPriorityHeader] = samplingPriority + tc[traceIDHeader] = traceID + tc[parentIDHeader] = parentID + + return tc, true +} + +// getHeadersFromEventHeaders extracts the Datadog trace context from an incoming Lambda event payload +// and creates a dummy X-Ray subsegment containing this information. +// This is used as the DefaultTraceExtractor. +func getHeadersFromEventHeaders(ctx context.Context, ev json.RawMessage) map[string]string { + eh := eventWithHeaders{} + + headers := map[string]string{} + + err := json.Unmarshal(ev, &eh) + if err != nil { + return headers + } + + lowercaseHeaders := map[string]string{} + for k, v := range eh.Headers { + lowercaseHeaders[strings.ToLower(k)] = v + } + + return lowercaseHeaders +} + +func convertXrayTraceContextFromLambdaContext(ctx context.Context) (TraceContext, error) { + traceCtx := map[string]string{} + + header := getXrayTraceHeaderFromContext(ctx) + if header == nil { + return traceCtx, fmt.Errorf("Couldn't read X-Ray trace context from Lambda context object") + } + + traceID, err := convertXRayTraceIDToDatadogTraceID(header.TraceID) + if err != nil { + return traceCtx, fmt.Errorf("Couldn't read trace id from X-Ray: %v", err) + } + parentID, err := convertXRayEntityIDToDatadogParentID(header.ParentID) + if err != nil { + return traceCtx, fmt.Errorf("Couldn't read parent id from X-Ray: %v", err) + } + samplingPriority := convertXRaySamplingDecision(header.SamplingDecision) + + traceCtx[traceIDHeader] = traceID + traceCtx[parentIDHeader] = parentID + traceCtx[samplingPriorityHeader] = samplingPriority + return traceCtx, nil +} + +// getXrayTraceHeaderFromContext is used to extract xray segment metadata from the lambda context object. +// By default, the context object won't have any Segment, (xray.GetSegment(ctx) will return nil). However it +// will have the "LambdaTraceHeader" object, which contains the traceID/parentID/sampling info. +func getXrayTraceHeaderFromContext(ctx context.Context) *header.Header { + var traceHeader string + + if traceHeaderValue := ctx.Value(xray.LambdaTraceHeaderKey); traceHeaderValue != nil { + traceHeader = traceHeaderValue.(string) + return header.FromString(traceHeader) + } + return nil +} + +// Converts the last 63 bits of an X-Ray trace ID (hex) to a Datadog trace id (uint64). +func convertXRayTraceIDToDatadogTraceID(traceID string) (string, error) { + parts := strings.Split(traceID, "-") + + if len(parts) != 3 { + return "0", fmt.Errorf("invalid x-ray trace id; expected 3 components in id") + } + if len(parts[2]) != 24 { + return "0", fmt.Errorf("x-ray trace id should be 96 bits") + } + + traceIDLength := len(parts[2]) - 16 + traceID = parts[2][traceIDLength : traceIDLength+16] // Per XRay Team: use the last 64 bits of the trace id + apmTraceID, err := convertHexIDToUint64(traceID) + if err != nil { + return "0", fmt.Errorf("while converting xray trace id: %v", err) + } + apmTraceID = 0x7FFFFFFFFFFFFFFF & apmTraceID // The APM Trace ID is restricted to 63 bits, so make sure the 64th bit is always 0 + return strconv.FormatUint(apmTraceID, 10), nil +} + +func convertHexIDToUint64(hexNumber string) (uint64, error) { + ba, err := hex.DecodeString(hexNumber) + if err != nil { + return 0, fmt.Errorf("couldn't convert hex to uint64: %v", err) + } + return binary.BigEndian.Uint64(ba), nil // TODO: Verify that this is correct +} + +// Converts an X-Ray entity ID (hex) to a Datadog parent id (uint64). +func convertXRayEntityIDToDatadogParentID(entityID string) (string, error) { + if len(entityID) < 16 { + return "0", fmt.Errorf("couldn't convert to trace id, too short") + } + val, err := convertHexIDToUint64(entityID[len(entityID)-16:]) + if err != nil { + return "0", fmt.Errorf("couldn't convert entity id to trace id: %v", err) + } + return strconv.FormatUint(val, 10), nil +} + +// Converts an X-Ray sampling decision into its Datadog counterpart. +func convertXRaySamplingDecision(decision header.SamplingDecision) string { + if decision == header.Sampled { + return userKeep + } + return userReject +} + +// ConvertTraceContextToSpanContext converts a TraceContext object to a SpanContext that can be used by dd-trace. +func ConvertTraceContextToSpanContext(traceCtx TraceContext) (ddtrace.SpanContext, error) { + spanCtx, err := propagator.Extract(tracer.TextMapCarrier(traceCtx)) + + if err != nil { + logger.Debug("Could not convert TraceContext to a SpanContext (most likely TraceContext was empty)") + return nil, err + } + + return spanCtx, nil +} + +// propagator is able to extract a SpanContext object from a TraceContext object +var propagator = tracer.NewPropagator(&tracer.PropagatorConfig{ + TraceHeader: traceIDHeader, + ParentHeader: parentIDHeader, + PriorityHeader: samplingPriorityHeader, +}) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go new file mode 100644 index 0000000000..201d364a1a --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go @@ -0,0 +1,302 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package trace + +import ( + "context" + "encoding/json" + "os" + "testing" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/aws/aws-xray-sdk-go/v2/header" + "github.com/aws/aws-xray-sdk-go/v2/xray" + "github.com/stretchr/testify/assert" +) + +const ( + mockXRayEntityID = "0b11cc4230d3e09e" + mockXRayTraceID = "1-5ce31dc2-2c779014b90ce44db5e03875" + convertedXRayEntityID = "797643193680388254" + convertedXRayTraceID = "4110911582297405557" +) + +func mockLambdaXRayTraceContext(ctx context.Context, traceID, parentID string, sampled bool) context.Context { + decision := header.NotSampled + if sampled { + decision = header.Sampled + } + + traceHeader := header.Header{ + TraceID: traceID, + ParentID: parentID, + SamplingDecision: decision, + AdditionalData: make(TraceContext), + } + headerString := traceHeader.String() + //nolint + return context.WithValue(ctx, xray.LambdaTraceHeaderKey, headerString) +} + +func mockTraceContext(traceID, parentID, samplingPriority string) context.Context { + ctx := context.Background() + if traceID != "" { + ctx = context.WithValue(ctx, extension.DdTraceId, traceID) + } + if parentID != "" { + ctx = context.WithValue(ctx, extension.DdParentId, parentID) + } + if samplingPriority != "" { + ctx = context.WithValue(ctx, extension.DdSamplingPriority, samplingPriority) + } + return ctx +} + +func loadRawJSON(t *testing.T, filename string) *json.RawMessage { + bytes, err := os.ReadFile(filename) + if err != nil { + assert.Fail(t, "Couldn't find JSON file") + return nil + } + msg := json.RawMessage{} + err = msg.UnmarshalJSON(bytes) + assert.NoError(t, err) + return &msg +} +func TestGetDatadogTraceContextForTraceMetadataNonProxyEvent(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") + + headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) + assert.True(t, ok) + + expected := TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: "45678910", + samplingPriorityHeader: "2", + } + assert.Equal(t, expected, headers) +} + +func TestGetDatadogTraceContextForTraceMetadataWithMixedCaseHeaders(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/non-proxy-with-mixed-case-headers.json") + + headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) + assert.True(t, ok) + + expected := TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: "45678910", + samplingPriorityHeader: "2", + } + assert.Equal(t, expected, headers) +} + +func TestGetDatadogTraceContextForTraceMetadataWithMissingSamplingPriority(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/non-proxy-with-missing-sampling-priority.json") + + headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) + assert.True(t, ok) + + expected := TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: "45678910", + samplingPriorityHeader: "1", + } + assert.Equal(t, expected, headers) +} + +func TestGetDatadogTraceContextForInvalidData(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/invalid.json") + + _, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) + assert.False(t, ok) +} + +func TestGetDatadogTraceContextForMissingData(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/non-proxy-no-headers.json") + + _, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) + assert.False(t, ok) +} + +func TestGetDatadogTraceContextFromContextObject(t *testing.T) { + testcases := []struct { + traceID string + parentID string + samplingPriority string + expectTC TraceContext + expectOk bool + }{ + { + "trace", + "parent", + "sampling", + TraceContext{ + "x-datadog-trace-id": "trace", + "x-datadog-parent-id": "parent", + "x-datadog-sampling-priority": "sampling", + }, + true, + }, + { + "", + "parent", + "sampling", + TraceContext{}, + false, + }, + { + "trace", + "", + "sampling", + TraceContext{}, + false, + }, + { + "trace", + "parent", + "", + TraceContext{ + "x-datadog-trace-id": "trace", + "x-datadog-parent-id": "parent", + "x-datadog-sampling-priority": "1", + }, + true, + }, + } + + ev := loadRawJSON(t, "../testdata/non-proxy-no-headers.json") + for _, test := range testcases { + t.Run(test.traceID+test.parentID+test.samplingPriority, func(t *testing.T) { + ctx := mockTraceContext(test.traceID, test.parentID, test.samplingPriority) + tc, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) + assert.Equal(t, test.expectTC, tc) + assert.Equal(t, test.expectOk, ok) + }) + } +} + +func TestConvertXRayTraceID(t *testing.T) { + output, err := convertXRayTraceIDToDatadogTraceID(mockXRayTraceID) + assert.NoError(t, err) + assert.Equal(t, convertedXRayTraceID, output) +} + +func TestConvertXRayTraceIDTooShort(t *testing.T) { + output, err := convertXRayTraceIDToDatadogTraceID("1-5ce31dc2-5e03875") + assert.Error(t, err) + assert.Equal(t, "0", output) +} + +func TestConvertXRayTraceIDInvalidFormat(t *testing.T) { + output, err := convertXRayTraceIDToDatadogTraceID("1-2c779014b90ce44db5e03875") + assert.Error(t, err) + assert.Equal(t, "0", output) +} +func TestConvertXRayTraceIDIncorrectCharacters(t *testing.T) { + output, err := convertXRayTraceIDToDatadogTraceID("1-5ce31dc2-c779014b90ce44db5e03875;") + assert.Error(t, err) + assert.Equal(t, "0", output) +} + +func TestConvertXRayEntityID(t *testing.T) { + output, err := convertXRayEntityIDToDatadogParentID(mockXRayEntityID) + assert.NoError(t, err) + assert.Equal(t, convertedXRayEntityID, output) +} + +func TestConvertXRayEntityIDInvalidFormat(t *testing.T) { + output, err := convertXRayEntityIDToDatadogParentID(";b11cc4230d3e09e") + assert.Error(t, err) + assert.Equal(t, "0", output) +} + +func TestConvertXRayEntityIDTooShort(t *testing.T) { + output, err := convertXRayEntityIDToDatadogParentID("c4230d3e09e") + assert.Error(t, err) + assert.Equal(t, "0", output) +} + +func TestXrayTraceContextNoSegment(t *testing.T) { + ctx := context.Background() + + _, err := convertXrayTraceContextFromLambdaContext(ctx) + assert.Error(t, err) +} +func TestXrayTraceContextWithSegment(t *testing.T) { + + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + + headers, err := convertXrayTraceContextFromLambdaContext(ctx) + assert.NoError(t, err) + assert.Equal(t, "2", headers[samplingPriorityHeader]) + assert.NotNil(t, headers[traceIDHeader]) + assert.NotNil(t, headers[parentIDHeader]) +} + +func TestContextWithRootTraceContextNoDatadogContext(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/apig-event-no-headers.json") + + newCTX, _ := contextWithRootTraceContext(ctx, *ev, false, DefaultTraceExtractor) + traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) + + expected := TraceContext{} + assert.Equal(t, expected, traceContext) +} + +func TestContextWithRootTraceContextWithDatadogContext(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") + + newCTX, _ := contextWithRootTraceContext(ctx, *ev, false, DefaultTraceExtractor) + traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) + + expected := TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: "45678910", + samplingPriorityHeader: "2", + } + assert.Equal(t, expected, traceContext) +} + +func TestContextWithRootTraceContextMergeXrayTracesNoDatadogContext(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/apig-event-no-headers.json") + + newCTX, _ := contextWithRootTraceContext(ctx, *ev, true, DefaultTraceExtractor) + traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) + + expected := TraceContext{ + traceIDHeader: convertedXRayTraceID, + parentIDHeader: convertedXRayEntityID, + samplingPriorityHeader: "2", + } + assert.Equal(t, expected, traceContext) +} + +func TestContextWithRootTraceContextMergeXrayTracesWithDatadogContext(t *testing.T) { + ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) + ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") + + newCTX, _ := contextWithRootTraceContext(ctx, *ev, true, DefaultTraceExtractor) + traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) + + expected := TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: convertedXRayEntityID, + samplingPriorityHeader: "2", + } + assert.Equal(t, expected, traceContext) +} diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener.go b/contrib/aws/datadog-lambda-go/internal/trace/listener.go new file mode 100644 index 0000000000..4237af75d7 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener.go @@ -0,0 +1,203 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package trace + +import ( + "context" + "encoding/json" + "fmt" + "os" + "strings" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" + "github.com/aws/aws-lambda-go/lambdacontext" + "go.opentelemetry.io/otel" + "github.com/DataDog/dd-trace-go/v2/ddtrace" + ddotel "github.com/DataDog/dd-trace-go/v2/ddtrace/opentelemetry" + ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" +) + +type ( + // Listener creates a function execution span and injects it into the context + Listener struct { + ddTraceEnabled bool + mergeXrayTraces bool + universalInstrumentation bool + otelTracerEnabled bool + extensionManager *extension.ExtensionManager + traceContextExtractor ContextExtractor + tracerOptions []ddtracer.StartOption + } + + // Config gives options for how the Listener should work + Config struct { + DDTraceEnabled bool + MergeXrayTraces bool + UniversalInstrumentation bool + OtelTracerEnabled bool + TraceContextExtractor ContextExtractor + TracerOptions []ddtracer.StartOption + } +) + +// The function execution span is the top-level span representing the current Lambda function execution +var functionExecutionSpan *ddtracer.Span + +var tracerInitialized = false + +// MakeListener initializes a new trace lambda Listener +func MakeListener(config Config, extensionManager *extension.ExtensionManager) Listener { + + return Listener{ + ddTraceEnabled: config.DDTraceEnabled, + mergeXrayTraces: config.MergeXrayTraces, + universalInstrumentation: config.UniversalInstrumentation, + otelTracerEnabled: config.OtelTracerEnabled, + extensionManager: extensionManager, + traceContextExtractor: config.TraceContextExtractor, + tracerOptions: config.TracerOptions, + } +} + +// HandlerStarted sets up tracing and starts the function execution span if Datadog tracing is enabled +func (l *Listener) HandlerStarted(ctx context.Context, msg json.RawMessage) context.Context { + if !l.ddTraceEnabled { + return ctx + } + + if l.universalInstrumentation && l.extensionManager.IsExtensionRunning() { + ctx = l.extensionManager.SendStartInvocationRequest(ctx, msg) + } + + ctx, _ = contextWithRootTraceContext(ctx, msg, l.mergeXrayTraces, l.traceContextExtractor) + + if !tracerInitialized { + serviceName := os.Getenv("DD_SERVICE") + if serviceName == "" { + serviceName = "aws.lambda" + } + extensionNotRunning := !l.extensionManager.IsExtensionRunning() + opts := append([]ddtracer.StartOption{ + ddtracer.WithService(serviceName), + ddtracer.WithLambdaMode(extensionNotRunning), + ddtracer.WithGlobalTag("_dd.origin", "lambda"), + ddtracer.WithSendRetries(2), + }, l.tracerOptions...) + if l.otelTracerEnabled { + provider := ddotel.NewTracerProvider( + opts..., + ) + otel.SetTracerProvider(provider) + } else { + ddtracer.Start( + opts..., + ) + } + tracerInitialized = true + } + + isDdServerlessSpan := l.universalInstrumentation && l.extensionManager.IsExtensionRunning() + functionExecutionSpan, ctx = startFunctionExecutionSpan(ctx, l.mergeXrayTraces, isDdServerlessSpan) + + // Add the span to the context so the user can create child spans + ctx = ddtracer.ContextWithSpan(ctx, functionExecutionSpan) + + return ctx +} + +// HandlerFinished ends the function execution span and stops the tracer +func (l *Listener) HandlerFinished(ctx context.Context, err error) { + if functionExecutionSpan != nil { + functionExecutionSpan.Finish(ddtracer.WithError(err)) + + finishConfig := ddtracer.FinishConfig{Error: err} + + if l.universalInstrumentation && l.extensionManager.IsExtensionRunning() { + l.extensionManager.SendEndInvocationRequest(ctx, functionExecutionSpan, finishConfig) + } + } + + ddtracer.Flush() +} + +// startFunctionExecutionSpan starts a span that represents the current Lambda function execution +// and returns the span so that it can be finished when the function execution is complete +func startFunctionExecutionSpan(ctx context.Context, mergeXrayTraces bool, isDdServerlessSpan bool) (*ddtracer.Span, context.Context) { + // Extract information from context + lambdaCtx, _ := lambdacontext.FromContext(ctx) + rootTraceContext, ok := ctx.Value(traceContextKey).(TraceContext) + if !ok { + logger.Error(fmt.Errorf("Error extracting trace context from context object")) + } + + functionArn := lambdaCtx.InvokedFunctionArn + functionArn = strings.ToLower(functionArn) + functionArn, functionVersion := separateVersionFromFunctionArn(functionArn) + + // Set the root trace context as the parent of the function execution span + var parentSpanContext ddtrace.SpanContext + convertedSpanContext, err := ConvertTraceContextToSpanContext(rootTraceContext) + if err == nil { + parentSpanContext = convertedSpanContext + } + + resourceName := lambdacontext.FunctionName + if isDdServerlessSpan { + // The extension will drop this span, prioritizing the execution span the extension creates + resourceName = string(extension.DdSeverlessSpan) + } + + spanOptions := []ddtracer.StartSpanOption{ + ddtracer.SpanType("serverless"), + ddtracer.ResourceName(resourceName), + ddtracer.Tag("cold_start", ctx.Value("cold_start")), + ddtracer.Tag("function_arn", functionArn), + ddtracer.Tag("function_version", functionVersion), + ddtracer.Tag("request_id", lambdaCtx.AwsRequestID), + ddtracer.Tag("resource_names", lambdacontext.FunctionName), + ddtracer.Tag("functionname", strings.ToLower(lambdacontext.FunctionName)), + ddtracer.Tag("datadog_lambda", version.DDLambdaVersion), + ddtracer.Tag("dd_trace", version.DDTraceVersion), + } + + if parentSpanContext != nil { + if sc, ok := parentSpanContext.(*ddtracer.SpanContext); ok { + spanOptions = append(spanOptions, ddtracer.ChildOf(sc)) + } + } + + span := ddtracer.StartSpan( + "aws.lambda", // This operation name will be replaced with the value of the service tag by the Forwarder + spanOptions..., + ) + + if parentSpanContext != nil && mergeXrayTraces { + // This tag will cause the Forwarder to drop the span (to avoid redundancy with X-Ray) + span.SetTag("_dd.parent_source", "xray") + } + + ctx = context.WithValue(ctx, extension.DdSpanId, fmt.Sprint(span.Context().SpanID())) + + return span, ctx +} + +func separateVersionFromFunctionArn(functionArn string) (arnWithoutVersion string, functionVersion string) { + arnSegments := strings.Split(functionArn, ":") + if cap(arnSegments) < 7 { + return "", "" + } + functionVersion = "$LATEST" + arnWithoutVersion = strings.Join(arnSegments[0:7], ":") + if len(arnSegments) > 7 { + functionVersion = arnSegments[7] + } + return arnWithoutVersion, functionVersion +} diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go new file mode 100644 index 0000000000..47b9a4535d --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go @@ -0,0 +1,176 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package trace + +import ( + "context" + "fmt" + "testing" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/aws/aws-lambda-go/lambdacontext" + "github.com/stretchr/testify/assert" + "github.com/DataDog/dd-trace-go/v2/ddtrace/mocktracer" +) + +func TestSeparateVersionFromFunctionArnWithVersion(t *testing.T) { + inputArn := "arn:aws:lambda:us-east-1:123456789012:function:my-function:9" + + arnWithoutVersion, functionVersion := separateVersionFromFunctionArn(inputArn) + + expectedArnWithoutVersion := "arn:aws:lambda:us-east-1:123456789012:function:my-function" + expectedFunctionVersion := "9" + assert.Equal(t, expectedArnWithoutVersion, arnWithoutVersion) + assert.Equal(t, expectedFunctionVersion, functionVersion) +} + +func TestSeparateVersionFromFunctionArnWithoutVersion(t *testing.T) { + inputArn := "arn:aws:lambda:us-east-1:123456789012:function:my-function" + + arnWithoutVersion, functionVersion := separateVersionFromFunctionArn(inputArn) + + expectedArnWithoutVersion := "arn:aws:lambda:us-east-1:123456789012:function:my-function" + expectedFunctionVersion := "$LATEST" + assert.Equal(t, expectedArnWithoutVersion, arnWithoutVersion) + assert.Equal(t, expectedFunctionVersion, functionVersion) +} + +func TestSeparateVersionFromFunctionArnEmptyString(t *testing.T) { + inputArn := "" + + arnWithoutVersion, functionVersion := separateVersionFromFunctionArn(inputArn) + assert.Empty(t, arnWithoutVersion) + assert.Empty(t, functionVersion) +} + +var traceContextFromXray = TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: "45678910", +} + +var traceContextFromEvent = TraceContext{ + traceIDHeader: "1231452342", + parentIDHeader: "45678910", +} + +var mockLambdaContext = lambdacontext.LambdaContext{ + AwsRequestID: "abcdefgh-1234-5678-1234-abcdefghijkl", + InvokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:MyFunction:11", +} + +func TestStartFunctionExecutionSpanFromXrayWithMergeEnabled(t *testing.T) { + ctx := context.Background() + + lambdacontext.FunctionName = "MockFunctionName" + ctx = lambdacontext.NewContext(ctx, &mockLambdaContext) + ctx = context.WithValue(ctx, traceContextKey, traceContextFromXray) + //nolint + ctx = context.WithValue(ctx, "cold_start", true) + + mt := mocktracer.Start() + defer mt.Stop() + + span, ctx := startFunctionExecutionSpan(ctx, true, false) + span.Finish() + finishedSpan := mt.FinishedSpans()[0] + + assert.Equal(t, "aws.lambda", finishedSpan.OperationName()) + + assert.Equal(t, true, finishedSpan.Tag("cold_start")) + // We expect the function ARN to be lowercased, and the version removed + assert.Equal(t, "arn:aws:lambda:us-east-1:123456789012:function:myfunction", finishedSpan.Tag("function_arn")) + assert.Equal(t, "11", finishedSpan.Tag("function_version")) + assert.Equal(t, "abcdefgh-1234-5678-1234-abcdefghijkl", finishedSpan.Tag("request_id")) + assert.Equal(t, "MockFunctionName", finishedSpan.Tag("resource.name")) + assert.Equal(t, "MockFunctionName", finishedSpan.Tag("resource_names")) + assert.Equal(t, "mockfunctionname", finishedSpan.Tag("functionname")) + assert.Equal(t, "serverless", finishedSpan.Tag("span.type")) + assert.Equal(t, "xray", finishedSpan.Tag("_dd.parent_source")) + assert.Equal(t, fmt.Sprint(span.Context().SpanID()), ctx.Value(extension.DdSpanId).(string)) +} + +func TestStartFunctionExecutionSpanFromXrayWithMergeDisabled(t *testing.T) { + ctx := context.Background() + + lambdacontext.FunctionName = "MockFunctionName" + ctx = lambdacontext.NewContext(ctx, &mockLambdaContext) + ctx = context.WithValue(ctx, traceContextKey, traceContextFromXray) + //nolint + ctx = context.WithValue(ctx, "cold_start", true) + + mt := mocktracer.Start() + defer mt.Stop() + + span, ctx := startFunctionExecutionSpan(ctx, false, false) + span.Finish() + finishedSpan := mt.FinishedSpans()[0] + + assert.Equal(t, nil, finishedSpan.Tag("_dd.parent_source")) + assert.Equal(t, fmt.Sprint(span.Context().SpanID()), ctx.Value(extension.DdSpanId).(string)) +} + +func TestStartFunctionExecutionSpanFromEventWithMergeEnabled(t *testing.T) { + ctx := context.Background() + + lambdacontext.FunctionName = "MockFunctionName" + ctx = lambdacontext.NewContext(ctx, &mockLambdaContext) + ctx = context.WithValue(ctx, traceContextKey, traceContextFromEvent) + //nolint + ctx = context.WithValue(ctx, "cold_start", true) + + mt := mocktracer.Start() + defer mt.Stop() + + span, ctx := startFunctionExecutionSpan(ctx, true, false) + span.Finish() + finishedSpan := mt.FinishedSpans()[0] + + assert.Equal(t, "xray", finishedSpan.Tag("_dd.parent_source")) + assert.Equal(t, fmt.Sprint(span.Context().SpanID()), ctx.Value(extension.DdSpanId).(string)) +} + +func TestStartFunctionExecutionSpanFromEventWithMergeDisabled(t *testing.T) { + ctx := context.Background() + + lambdacontext.FunctionName = "MockFunctionName" + ctx = lambdacontext.NewContext(ctx, &mockLambdaContext) + ctx = context.WithValue(ctx, traceContextKey, traceContextFromEvent) + //nolint + ctx = context.WithValue(ctx, "cold_start", true) + + mt := mocktracer.Start() + defer mt.Stop() + + span, ctx := startFunctionExecutionSpan(ctx, false, false) + span.Finish() + finishedSpan := mt.FinishedSpans()[0] + + assert.Equal(t, nil, finishedSpan.Tag("_dd.parent_source")) + assert.Equal(t, fmt.Sprint(span.Context().SpanID()), ctx.Value(extension.DdSpanId).(string)) +} + +func TestStartFunctionExecutionSpanWithExtension(t *testing.T) { + ctx := context.Background() + + lambdacontext.FunctionName = "MockFunctionName" + ctx = lambdacontext.NewContext(ctx, &mockLambdaContext) + ctx = context.WithValue(ctx, traceContextKey, traceContextFromEvent) + //nolint + ctx = context.WithValue(ctx, "cold_start", true) + + mt := mocktracer.Start() + defer mt.Stop() + + span, ctx := startFunctionExecutionSpan(ctx, false, true) + span.Finish() + finishedSpan := mt.FinishedSpans()[0] + + assert.Equal(t, string(extension.DdSeverlessSpan), finishedSpan.Tag("resource.name")) + assert.Equal(t, fmt.Sprint(span.Context().SpanID()), ctx.Value(extension.DdSpanId).(string)) +} diff --git a/contrib/aws/datadog-lambda-go/internal/version/version.go b/contrib/aws/datadog-lambda-go/internal/version/version.go new file mode 100644 index 0000000000..f088b21e1c --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/version/version.go @@ -0,0 +1,11 @@ +// Do not modify this file manually. It is modified by the release script. +package version + +// DDLambdaVersion is the current version number of this library (datadog-lambda-go). +// It is automatically updated by the release script. +const DDLambdaVersion = "1.23.0" + +// DDTraceVersion is the version of dd-trace-go required by this libary. +// This should match the version number specified in go.mod. +// It is automatically updated by the release script +const DDTraceVersion = "1.72.1" diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go new file mode 100644 index 0000000000..e64fe65f28 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go @@ -0,0 +1,202 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package wrapper + +import ( + "context" + "encoding/json" + "errors" + "fmt" + + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/aws/aws-lambda-go/lambda" + + "reflect" +) + +var ( + // CurrentContext is the last create lambda context object. + CurrentContext context.Context +) + +type ( + // HandlerListener is a point where listener logic can be injected into a handler + HandlerListener interface { + HandlerStarted(ctx context.Context, msg json.RawMessage) context.Context + HandlerFinished(ctx context.Context, err error) + } + + DatadogHandler struct { + coldStart bool + handler lambda.Handler + listeners []HandlerListener + } +) + +// WrapHandlerWithListeners wraps a lambda handler, and calls listeners before and after every invocation. +func WrapHandlerWithListeners(handler interface{}, listeners ...HandlerListener) interface{} { + err := validateHandler(handler) + if err != nil { + // This wasn't a valid handler function, pass back to AWS SDK to let it handle the error. + logger.Error(fmt.Errorf("handler function was in format ddlambda doesn't recognize: %v", err)) + return handler + } + coldStart := true + + // Return custom handler, to be called once per invocation + return func(ctx context.Context, msg json.RawMessage) (interface{}, error) { + //nolint + ctx = context.WithValue(ctx, "cold_start", coldStart) + for _, listener := range listeners { + ctx = listener.HandlerStarted(ctx, msg) + } + CurrentContext = ctx + result, err := callHandler(ctx, msg, handler) + for _, listener := range listeners { + ctx = context.WithValue(ctx, extension.DdLambdaResponse, result) + listener.HandlerFinished(ctx, err) + } + coldStart = false + CurrentContext = nil + return result, err + } +} + +func (h *DatadogHandler) Invoke(ctx context.Context, payload []byte) ([]byte, error) { + //nolint + ctx = context.WithValue(ctx, "cold_start", h.coldStart) + msg := json.RawMessage{} + err := msg.UnmarshalJSON(payload) + if err != nil { + logger.Error(fmt.Errorf("couldn't load handler payload: %v", err)) + } + + for _, listener := range h.listeners { + ctx = listener.HandlerStarted(ctx, msg) + } + + CurrentContext = ctx + result, err := h.handler.Invoke(ctx, payload) + for _, listener := range h.listeners { + listener.HandlerFinished(ctx, err) + } + h.coldStart = false + CurrentContext = nil + return result, err +} + +func WrapHandlerInterfaceWithListeners(handler lambda.Handler, listeners ...HandlerListener) lambda.Handler { + return &DatadogHandler{ + coldStart: true, + handler: handler, + listeners: listeners, + } +} + +func validateHandler(handler interface{}) error { + // Detect the handler follows the right format, based on the GO AWS SDK. + // https://docs.aws.amazon.com/lambda/latest/dg/go-programming-model-handler-types.html + handlerType := reflect.TypeOf(handler) + if handlerType.Kind() != reflect.Func { + return errors.New("handler is not a function") + } + + if handlerType.NumIn() == 2 { + contextType := reflect.TypeOf((*context.Context)(nil)).Elem() + firstArgType := handlerType.In(0) + if !firstArgType.Implements(contextType) { + return errors.New("handler should take context as first argument") + } + } + if handlerType.NumIn() > 2 { + return errors.New("handler takes too many arguments") + } + + errorType := reflect.TypeOf((*error)(nil)).Elem() + + if handlerType.NumOut() > 2 { + return errors.New("handler returns more than two values") + } + if handlerType.NumOut() > 0 { + rt := handlerType.Out(handlerType.NumOut() - 1) // Last returned value + if !rt.Implements(errorType) { + return errors.New("handler doesn't return error as it's last value") + } + } + return nil +} + +func callHandler(ctx context.Context, msg json.RawMessage, handler interface{}) (interface{}, error) { + ev, err := unmarshalEventForHandler(msg, handler) + if err != nil { + return nil, err + } + handlerType := reflect.TypeOf(handler) + + args := []reflect.Value{} + + if handlerType.NumIn() == 1 { + // When there is only one argument, argument is either the event payload, or the context. + contextType := reflect.TypeOf((*context.Context)(nil)).Elem() + firstArgType := handlerType.In(0) + if firstArgType.Implements(contextType) { + args = []reflect.Value{reflect.ValueOf(ctx)} + } else { + args = []reflect.Value{ev.Elem()} + + } + } else if handlerType.NumIn() == 2 { + // Or when there are two arguments, context is always first, followed by event payload. + args = []reflect.Value{reflect.ValueOf(ctx), ev.Elem()} + } + + handlerValue := reflect.ValueOf(handler) + output := handlerValue.Call(args) + + var response interface{} + var errResponse error + + if len(output) > 0 { + // If there are any output values, the last should always be an error + val := output[len(output)-1].Interface() + if errVal, ok := val.(error); ok { + errResponse = errVal + } + } + + if len(output) > 1 { + // If there is more than one output value, the first should be the response payload. + response = output[0].Interface() + } + + return response, errResponse +} + +func unmarshalEventForHandler(ev json.RawMessage, handler interface{}) (reflect.Value, error) { + handlerType := reflect.TypeOf(handler) + if handlerType.NumIn() == 0 { + return reflect.ValueOf(nil), nil + } + + messageType := handlerType.In(handlerType.NumIn() - 1) + contextType := reflect.TypeOf((*context.Context)(nil)).Elem() + firstArgType := handlerType.In(0) + + if handlerType.NumIn() == 1 && firstArgType.Implements(contextType) { + return reflect.ValueOf(nil), nil + } + + newMessage := reflect.New(messageType) + err := json.Unmarshal(ev, newMessage.Interface()) + if err != nil { + return reflect.ValueOf(nil), err + } + return newMessage, err +} diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go new file mode 100644 index 0000000000..8c5fe3f097 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go @@ -0,0 +1,300 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed + * under the Apache License Version 2.0. + * + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2021 Datadog, Inc. + */ + +package wrapper + +import ( + "context" + "encoding/json" + "errors" + "os" + "reflect" + "testing" + + "github.com/aws/aws-lambda-go/events" + "github.com/aws/aws-lambda-go/lambda" + "github.com/stretchr/testify/assert" +) + +type ( + mockHandlerListener struct { + inputCTX context.Context + inputMSG json.RawMessage + outputCTX context.Context + } + + mockNonProxyEvent struct { + MyCustomEvent map[string]int `json:"my-custom-event"` + FakeID string `json:"fake-id"` + } +) + +func (mhl *mockHandlerListener) HandlerStarted(ctx context.Context, msg json.RawMessage) context.Context { + mhl.inputCTX = ctx + mhl.inputMSG = msg + return ctx +} + +func (mhl *mockHandlerListener) HandlerFinished(ctx context.Context, err error) { + mhl.outputCTX = ctx +} + +func runHandlerWithJSON(t *testing.T, filename string, handler interface{}) (*mockHandlerListener, interface{}, error) { + ctx := context.Background() + payload := loadRawJSON(t, filename) + + mhl := mockHandlerListener{} + + wrappedHandler := WrapHandlerWithListeners(handler, &mhl).(func(context.Context, json.RawMessage) (interface{}, error)) + + response, err := wrappedHandler(ctx, *payload) + return &mhl, response, err +} + +func runHandlerInterfaceWithJSON(t *testing.T, filename string, handler lambda.Handler) (*mockHandlerListener, []byte, error) { + ctx := context.Background() + payload, err := os.ReadFile(filename) + if err != nil { + assert.Fail(t, "Couldn't find JSON file") + return nil, nil, nil + } + mhl := mockHandlerListener{} + + wrappedHandler := WrapHandlerInterfaceWithListeners(handler, &mhl) + + response, err := wrappedHandler.Invoke(ctx, payload) + return &mhl, response, err +} + +func loadRawJSON(t *testing.T, filename string) *json.RawMessage { + bytes, err := os.ReadFile(filename) + if err != nil { + assert.Fail(t, "Couldn't find JSON file") + return nil + } + msg := json.RawMessage{} + err = msg.UnmarshalJSON(bytes) + assert.NoError(t, err) + return &msg +} + +func TestValidateHandlerNotFunction(t *testing.T) { + nonFunction := 1 + + err := validateHandler(nonFunction) + assert.EqualError(t, err, "handler is not a function") +} +func TestValidateHandlerToManyArguments(t *testing.T) { + tooManyArgs := func(a, b, c int) { + } + + err := validateHandler(tooManyArgs) + assert.EqualError(t, err, "handler takes too many arguments") +} + +func TestValidateHandlerContextIsNotFirstArgument(t *testing.T) { + firstArgNotContext := func(arg1, arg2 int) { + } + + err := validateHandler(firstArgNotContext) + assert.EqualError(t, err, "handler should take context as first argument") +} + +func TestValidateHandlerTwoArguments(t *testing.T) { + twoArguments := func(arg1 context.Context, arg2 int) { + } + + err := validateHandler(twoArguments) + assert.NoError(t, err) +} + +func TestValidateHandlerOneArgument(t *testing.T) { + oneArgument := func(arg1 int) { + } + + err := validateHandler(oneArgument) + assert.NoError(t, err) +} + +func TestValidateHandlerTooManyReturnValues(t *testing.T) { + tooManyReturns := func() (int, int, error) { + return 0, 0, nil + } + + err := validateHandler(tooManyReturns) + assert.EqualError(t, err, "handler returns more than two values") +} +func TestValidateHandlerLastReturnValueNotError(t *testing.T) { + lastNotError := func() (int, int) { + return 0, 0 + } + + err := validateHandler(lastNotError) + assert.EqualError(t, err, "handler doesn't return error as it's last value") +} +func TestValidateHandlerCorrectFormat(t *testing.T) { + correct := func(context context.Context) (int, error) { + return 0, nil + } + + err := validateHandler(correct) + assert.NoError(t, err) +} + +func TestWrapHandlerAPIGEvent(t *testing.T) { + called := false + + handler := func(ctx context.Context, request events.APIGatewayProxyRequest) (int, error) { + called = true + assert.Equal(t, "c6af9ac6-7b61-11e6-9a41-93e8deadbeef", request.RequestContext.RequestID) + return 5, nil + } + + _, response, err := runHandlerWithJSON(t, "../testdata/apig-event-no-headers.json", handler) + + assert.True(t, called) + assert.NoError(t, err) + assert.Equal(t, 5, response) +} + +func TestWrapHandlerNonProxyEvent(t *testing.T) { + called := false + + handler := func(ctx context.Context, request mockNonProxyEvent) (int, error) { + called = true + assert.Equal(t, "12345678910", request.FakeID) + return 5, nil + } + + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + + assert.True(t, called) + assert.NoError(t, err) + assert.Equal(t, 5, response) +} + +func TestWrapHandlerEventArgumentOnly(t *testing.T) { + called := false + + handler := func(request mockNonProxyEvent) (int, error) { + called = true + assert.Equal(t, "12345678910", request.FakeID) + return 5, nil + } + + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + + assert.True(t, called) + assert.NoError(t, err) + assert.Equal(t, 5, response) +} + +func TestWrapHandlerContextArgumentOnly(t *testing.T) { + called := true + var handler = func(ctx context.Context) (interface{}, error) { + return nil, nil + } + + mhl := mockHandlerListener{} + wrappedHandler := WrapHandlerWithListeners(handler, &mhl).(func(context.Context, json.RawMessage) (interface{}, error)) + + _, err := wrappedHandler(context.Background(), nil) + assert.NoError(t, err) + assert.True(t, called) +} + +func TestWrapHandlerNoArguments(t *testing.T) { + called := false + + handler := func() (int, error) { + called = true + return 5, nil + } + + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + + assert.True(t, called) + assert.NoError(t, err) + assert.Equal(t, 5, response) +} + +func TestWrapHandlerInvalidData(t *testing.T) { + called := false + + handler := func(request mockNonProxyEvent) (int, error) { + called = true + return 5, nil + } + + _, response, err := runHandlerWithJSON(t, "../testdata/invalid.json", handler) + + assert.False(t, called) + assert.Error(t, err) + assert.Equal(t, nil, response) +} + +func TestWrapHandlerReturnsError(t *testing.T) { + called := false + defaultErr := errors.New("Some error") + + handler := func(request mockNonProxyEvent) (int, error) { + called = true + return 5, defaultErr + } + + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + + assert.True(t, called) + assert.Equal(t, defaultErr, err) + assert.Equal(t, 5, response) +} + +func TestWrapHandlerReturnsErrorOnly(t *testing.T) { + called := false + defaultErr := errors.New("Some error") + + handler := func(request mockNonProxyEvent) error { + called = true + return defaultErr + } + + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + + assert.True(t, called) + assert.Equal(t, defaultErr, err) + assert.Equal(t, nil, response) +} + +func TestWrapHandlerReturnsOriginalHandlerIfInvalid(t *testing.T) { + + var handler interface{} = func(arg1, arg2, arg3 int) (int, error) { + return 0, nil + } + mhl := mockHandlerListener{} + + wrappedHandler := WrapHandlerWithListeners(handler, &mhl) + + assert.Equal(t, reflect.ValueOf(handler).Pointer(), reflect.ValueOf(wrappedHandler).Pointer()) + +} + +func TestWrapHandlerInterfaceWithListeners(t *testing.T) { + called := false + + handler := lambda.NewHandler(func(ctx context.Context, request events.APIGatewayProxyRequest) (int, error) { + called = true + assert.Equal(t, "c6af9ac6-7b61-11e6-9a41-93e8deadbeef", request.RequestContext.RequestID) + return 5, nil + }) + + _, response, err := runHandlerInterfaceWithJSON(t, "../testdata/apig-event-no-headers.json", handler) + + assert.True(t, called) + assert.NoError(t, err) + assert.Equal(t, uint8('5'), response[0]) +} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/README.md b/contrib/aws/datadog-lambda-go/lambdatest/README.md new file mode 100644 index 0000000000..af1b0c6cb3 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/README.md @@ -0,0 +1,16 @@ +# Integration tests + + +## Requirements + +- Node +- Go +- DD_API_KEY + +## Running + +```bash +DD_API_KEY= aws-vault exec sandbox-account-admin -- ./run_integration_tests.sh +``` + +Use `UPDATE_SNAPSHOTS=true` to update snapshots diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod new file mode 100644 index 0000000000..a9877557e7 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod @@ -0,0 +1,73 @@ +module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/lambdatest/error + +go 1.24 + +require ( + github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go v0.0.0-00010101000000-000000000000 + github.com/aws/aws-lambda-go v1.46.0 +) + +require ( + github.com/DataDog/appsec-internal-go v1.9.0 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0 // indirect + github.com/DataDog/datadog-go/v5 v5.5.0 // indirect + github.com/DataDog/go-libddwaf/v3 v3.5.1 // indirect + github.com/DataDog/go-sqllexer v0.0.14 // indirect + github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect + github.com/DataDog/sketches-go v1.4.5 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/andybalholm/brotli v1.1.0 // indirect + github.com/aws/aws-sdk-go v1.50.9 // indirect + github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect + github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect + github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect + github.com/aws/aws-xray-sdk-go v1.8.3 // indirect + github.com/aws/smithy-go v1.19.0 // indirect + github.com/cenkalti/backoff/v4 v4.2.1 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/ebitengine/purego v0.6.0-alpha.5 // indirect + github.com/go-logr/logr v1.4.1 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/klauspost/compress v1.17.6 // indirect + github.com/outcaste-io/ristretto v0.2.3 // indirect + github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/secure-systems-lab/go-securesystemslib v0.8.0 // indirect + github.com/sony/gobreaker v0.5.0 // indirect + github.com/tinylib/msgp v1.2.1 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.52.0 // indirect + go.opentelemetry.io/otel v1.27.0 // indirect + go.opentelemetry.io/otel/metric v1.27.0 // indirect + go.opentelemetry.io/otel/trace v1.27.0 // indirect + go.uber.org/atomic v1.11.0 // indirect + golang.org/x/mod v0.20.0 // indirect + golang.org/x/net v0.33.0 // indirect + golang.org/x/sys v0.28.0 // indirect + golang.org/x/text v0.21.0 // indirect + golang.org/x/time v0.6.0 // indirect + golang.org/x/tools v0.24.0 // indirect + golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5 // indirect + google.golang.org/grpc v1.64.1 // indirect + google.golang.org/protobuf v1.34.2 // indirect + gopkg.in/DataDog/dd-trace-go.v1 v1.72.1 // indirect +) + +replace github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go => ../../ +replace github.com/DataDog/dd-trace-go/v2 => ../../../../../ diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum b/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum new file mode 100644 index 0000000000..2aeebb7710 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum @@ -0,0 +1,263 @@ +github.com/DATA-DOG/go-sqlmock v1.4.1 h1:ThlnYciV1iM/V0OSF/dtkqWb6xo5qITT1TJBG1MRDJM= +github.com/DATA-DOG/go-sqlmock v1.4.1/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= +github.com/DataDog/appsec-internal-go v1.6.0 h1:QHvPOv/O0s2fSI/BraZJNpRDAtdlrRm5APJFZNBxjAw= +github.com/DataDog/appsec-internal-go v1.6.0/go.mod h1:pEp8gjfNLtEOmz+iZqC8bXhu0h4k7NUsW/qiQb34k1U= +github.com/DataDog/appsec-internal-go v1.9.0/go.mod h1:wW0cRfWBo4C044jHGwYiyh5moQV2x0AhnwqMuiX7O/g= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 h1:y08IzbpFM/HBaKfgayFZe1FpcbZn6bVPXoZ++93vxv8= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2/go.mod h1:A4nLJvxlg6BO/8/zg81til9yT0uRPuXDFMAzDMpmgn4= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0/go.mod h1:MfDvphBMmEMwE3a30h27AtPO7OzmvdoVTiGY1alEmo4= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 h1:7jn5EOu84uph4sd+pB3vF8LnsdTjhh+1/NnCvfNpG4A= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2/go.mod h1:Vc+snp0Bey4MrrJyiV2tVxxJb6BmLomPvN1RgAvjGaQ= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0/go.mod h1:jN5BsZI+VilHJV1Wac/efGxS4TPtXa1Lh9SiUyv93F4= +github.com/DataDog/datadog-go/v5 v5.5.0 h1:G5KHeB8pWBNXT4Jtw0zAkhdxEAWSpWH00geHI6LDrKU= +github.com/DataDog/datadog-go/v5 v5.5.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= +github.com/DataDog/go-libddwaf/v3 v3.2.1 h1:lZPc6UxCOwioHc++nsldKR50FpIrRh1uGnGLuryqnE8= +github.com/DataDog/go-libddwaf/v3 v3.2.1/go.mod h1:AP+7Atb8ftSsrha35wht7+K3R+xuzfVSQhabSO4w6CY= +github.com/DataDog/go-libddwaf/v3 v3.5.1/go.mod h1:n98d9nZ1gzenRSk53wz8l6d34ikxS+hs62A31Fqmyi4= +github.com/DataDog/go-sqllexer v0.0.10 h1:u07DuRfdlPPmOX/dclb1gcn/zaqWxUiURRRVenKILxc= +github.com/DataDog/go-sqllexer v0.0.10/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= +github.com/DataDog/go-sqllexer v0.0.14/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= +github.com/DataDog/go-tuf v1.0.2-0.5.2 h1:EeZr937eKAWPxJ26IykAdWA4A0jQXJgkhUjqEI/w7+I= +github.com/DataDog/go-tuf v1.0.2-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= +github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= +github.com/DataDog/sketches-go v1.4.5 h1:ki7VfeNz7IcNafq7yI/j5U/YCkO3LJiMDtXz9OMQbyE= +github.com/DataDog/sketches-go v1.4.5/go.mod h1:7Y8GN8Jf66DLyDhc94zuWA3uHEt/7ttt8jHOBWWrSOg= +github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= +github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= +github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= +github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= +github.com/aws/aws-sdk-go v1.50.9 h1:yX66aKnEtRc/uNV/1EH8CudRT5aLwVwcSwTBphuVPt8= +github.com/aws/aws-sdk-go v1.50.9/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= +github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= +github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= +github.com/aws/aws-sdk-go-v2/config v1.26.6/go.mod h1:uKU6cnDmYCvJ+pxO9S4cWDb2yWWIH5hra+32hVh1MI4= +github.com/aws/aws-sdk-go-v2/credentials v1.16.16 h1:8q6Rliyv0aUFAVtzaldUEcS+T5gbadPbWdV1WcAddK8= +github.com/aws/aws-sdk-go-v2/credentials v1.16.16/go.mod h1:UHVZrdUsv63hPXFo1H7c5fEneoVo9UXiz36QG1GEPi0= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 h1:c5I5iH+DZcH3xOIMlz3/tCKJDaHFwYEmxvlh2fAcFo8= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11/go.mod h1:cRrYDYAMUohBJUtUnOhydaMHtiK/1NZ0Otc9lIb6O0Y= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 h1:n3GDfwqF2tzEkXlv5cuy4iy7LpKDtqDMcNLfZDu9rls= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 h1:DBYTXwIGQSGs9w4jKm60F5dmCQ3EEruxdc0MFh+3EY4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10/go.mod h1:wohMUQiFdzo0NtxbBg0mSRGZ4vL3n0dKjLTINdcIino= +github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 h1:W9PbZAZAEcelhhjb7KuwUtf+Lbc+i7ByYJRuWLlnxyQ= +github.com/aws/aws-sdk-go-v2/service/kms v1.27.9/go.mod h1:2tFmR7fQnOdQlM2ZCEPpFnBIQD1U8wmXmduBgZbOag0= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 h1:eajuO3nykDPdYicLlP3AGgOyVN3MOlFmZv7WGTuJPow= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.7/go.mod h1:+mJNDdF+qiUlNKNC3fxn74WWNN+sOiGOEImje+3ScPM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w1NmfkfiSK8mS4zOx3BA= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= +github.com/aws/aws-xray-sdk-go v1.8.3 h1:S8GdgVncBRhzbNnNUgTPwhEqhwt2alES/9rLASyhxjU= +github.com/aws/aws-xray-sdk-go v1.8.3/go.mod h1:tv8uLMOSCABolrIF8YCcp3ghyswArsan8dfLCA1ZATk= +github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= +github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= +github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= +github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc= +github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg= +github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds= +github.com/ebitengine/purego v0.6.0-alpha.5 h1:EYID3JOAdmQ4SNZYJHu9V6IqOeRQDBYxqKAg9PyoHFY= +github.com/ebitengine/purego v0.6.0-alpha.5/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ= +github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk= +github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b h1:h9U78+dx9a4BKdQkBBos92HalKpaGKHrp+3Uo6yTodo= +github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= +github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= +github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7 h1:UpiO20jno/eV1eVZcxqWnUohyKRe1g8FPV/xH1s/2qs= +github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7/go.mod h1:QmrqtbKuxxSWTN3ETMPuB+VtEiBJ/A9XhoYGv8E1uD8= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 h1:kes8mmyCpxJsI7FTwtzRqEy9CdjCtrXrXGuOpxEA7Ts= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.2/go.mod h1:Gou2R9+il93BqX25LAKCLuM+y9U2T4hlwvT1yprcna4= +github.com/hashicorp/go-sockaddr v1.0.2 h1:ztczhD1jLxIRjVejw8gFomI1BQZOe2WoVOu0SyteCQc= +github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/klauspost/compress v1.17.5 h1:d4vBd+7CHydUqpFBgUEKkSdtSugf9YFmSkvUYPquI5E= +github.com/klauspost/compress v1.17.5/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= +github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= +github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw= +github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0= +github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= +github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= +github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk= +github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= +github.com/secure-systems-lab/go-securesystemslib v0.8.0 h1:mr5An6X45Kb2nddcFlbmfHkLguCE9laoZCUzEEpIZXA= +github.com/secure-systems-lab/go-securesystemslib v0.8.0/go.mod h1:UH2VZVuJfCYR8WgMlCU1uFsOUU+KeyrTWcSS73NBOzU= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= +github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.1 h1:4VhoImhV/Bm0ToFkXFi8hXNXwpDRZ/ynw3amt82mzq0= +github.com/stretchr/objx v0.5.1/go.mod h1:/iHQpkQwBD6DLUmQ4pE+s1TXdob1mORJ4/UFdrifcy0= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/tinylib/msgp v1.1.9 h1:SHf3yoO2sGA0veCJeCBYLHuttAVFHGm2RHgNodW7wQU= +github.com/tinylib/msgp v1.1.9/go.mod h1:BCXGB54lDD8qUEPmiG0cQQUANC4IUQyB2ItS2UDlO/k= +github.com/tinylib/msgp v1.2.1/go.mod h1:2vIGs3lcUo8izAATNobrCHevYZC/LMsJtw4JPiYPHro= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA= +github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g= +github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0 h1:KfYpVmrjI7JuToy5k8XV3nkapjWx48k4E4JOtVstzQI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0/go.mod h1:SeQhzAEccGVZVEy7aH87Nh0km+utSpo1pTv6eMMop48= +go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= +go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= +go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ= +go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= +go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= +go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak= +go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= +go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= +go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= +golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= +golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= +golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= +golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= +golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= +golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe h1:bQnxqljG/wqi4NTXu2+DJ3n7APcEA882QZ1JvhQAq9o= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:PAREbraiVEVGVdTZsVWjSbbTtSyGbAgIIvni8a8CD5s= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0= +google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0= +google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= +google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/DataDog/dd-trace-go.v1 v1.65.1 h1:Ne7kzWr/br/jwhUJR7CnqPl/mUpNxa6LfgZs0S4htZM= +gopkg.in/DataDog/dd-trace-go.v1 v1.65.1/go.mod h1:beNFIWd/H04d0k96cfltgiDH2+t0T5sDbyYLF3VTXqk= +gopkg.in/DataDog/dd-trace-go.v1 v1.72.1/go.mod h1:XqDhDqsLpThFnJc4z0FvAEItISIAUka+RHwmQ6EfN1U= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +honnef.co/go/gotraceui v0.2.0 h1:dmNsfQ9Vl3GwbiVD7Z8d/osC6WtGGrasyrC2suc4ZIQ= +honnef.co/go/gotraceui v0.2.0/go.mod h1:qHo4/W75cA3bX0QQoSvDjbJa4R8mAyyFjbWAj63XElc= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go new file mode 100644 index 0000000000..b0d1bfd773 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go @@ -0,0 +1,22 @@ +package main + +import ( + "context" + "errors" + + "github.com/aws/aws-lambda-go/lambda" + + ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" + "github.com/aws/aws-lambda-go/events" +) + +func handleRequest(ctx context.Context, ev events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + return events.APIGatewayProxyResponse{ + StatusCode: 500, + Body: "error", + }, errors.New("something went wrong") +} + +func main() { + lambda.Start(ddlambda.WrapHandler(handleRequest, nil)) +} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod new file mode 100644 index 0000000000..3e0c760a6d --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod @@ -0,0 +1,79 @@ +module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/lambdatest/hello + +go 1.24 + +require ( + github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go v0.0.0-00010101000000-000000000000 + github.com/aws/aws-lambda-go v1.46.0 + github.com/DataDog/dd-trace-go/v2 v2.0.0 +) + +require ( + github.com/DataDog/appsec-internal-go v1.9.0 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0 // indirect + github.com/DataDog/datadog-go/v5 v5.5.0 // indirect + github.com/DataDog/go-libddwaf/v3 v3.5.1 // indirect + github.com/DataDog/go-sqllexer v0.0.14 // indirect + github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect + github.com/DataDog/sketches-go v1.4.5 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/andybalholm/brotli v1.1.0 // indirect + github.com/aws/aws-sdk-go v1.50.9 // indirect + github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect + github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect + github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect + github.com/aws/aws-xray-sdk-go v1.8.3 // indirect + github.com/aws/smithy-go v1.19.0 // indirect + github.com/cenkalti/backoff/v4 v4.2.1 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 // indirect + github.com/ebitengine/purego v0.6.0-alpha.5 // indirect + github.com/go-logr/logr v1.4.1 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7 // indirect + github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 // indirect + github.com/hashicorp/go-sockaddr v1.0.2 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/klauspost/compress v1.17.6 // indirect + github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c // indirect + github.com/outcaste-io/ristretto v0.2.3 // indirect + github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/ryanuber/go-glob v1.0.0 // indirect + github.com/secure-systems-lab/go-securesystemslib v0.8.0 // indirect + github.com/sony/gobreaker v0.5.0 // indirect + github.com/tinylib/msgp v1.2.1 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.52.0 // indirect + go.opentelemetry.io/otel v1.27.0 // indirect + go.opentelemetry.io/otel/metric v1.27.0 // indirect + go.opentelemetry.io/otel/trace v1.27.0 // indirect + go.uber.org/atomic v1.11.0 // indirect + golang.org/x/mod v0.20.0 // indirect + golang.org/x/net v0.33.0 // indirect + golang.org/x/sys v0.28.0 // indirect + golang.org/x/text v0.21.0 // indirect + golang.org/x/time v0.6.0 // indirect + golang.org/x/tools v0.24.0 // indirect + golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5 // indirect + google.golang.org/grpc v1.64.1 // indirect + google.golang.org/protobuf v1.34.2 // indirect +) + +replace github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go => ../../ +replace github.com/DataDog/dd-trace-go/v2 => ../../../../../ diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum new file mode 100644 index 0000000000..c7b939ab90 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum @@ -0,0 +1,277 @@ +github.com/DATA-DOG/go-sqlmock v1.4.1 h1:ThlnYciV1iM/V0OSF/dtkqWb6xo5qITT1TJBG1MRDJM= +github.com/DATA-DOG/go-sqlmock v1.4.1/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= +github.com/DataDog/appsec-internal-go v1.6.0 h1:QHvPOv/O0s2fSI/BraZJNpRDAtdlrRm5APJFZNBxjAw= +github.com/DataDog/appsec-internal-go v1.6.0/go.mod h1:pEp8gjfNLtEOmz+iZqC8bXhu0h4k7NUsW/qiQb34k1U= +github.com/DataDog/appsec-internal-go v1.9.0/go.mod h1:wW0cRfWBo4C044jHGwYiyh5moQV2x0AhnwqMuiX7O/g= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 h1:y08IzbpFM/HBaKfgayFZe1FpcbZn6bVPXoZ++93vxv8= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2/go.mod h1:A4nLJvxlg6BO/8/zg81til9yT0uRPuXDFMAzDMpmgn4= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0/go.mod h1:MfDvphBMmEMwE3a30h27AtPO7OzmvdoVTiGY1alEmo4= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 h1:7jn5EOu84uph4sd+pB3vF8LnsdTjhh+1/NnCvfNpG4A= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2/go.mod h1:Vc+snp0Bey4MrrJyiV2tVxxJb6BmLomPvN1RgAvjGaQ= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0/go.mod h1:jN5BsZI+VilHJV1Wac/efGxS4TPtXa1Lh9SiUyv93F4= +github.com/DataDog/datadog-go/v5 v5.5.0 h1:G5KHeB8pWBNXT4Jtw0zAkhdxEAWSpWH00geHI6LDrKU= +github.com/DataDog/datadog-go/v5 v5.5.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= +github.com/DataDog/go-libddwaf/v3 v3.2.1 h1:lZPc6UxCOwioHc++nsldKR50FpIrRh1uGnGLuryqnE8= +github.com/DataDog/go-libddwaf/v3 v3.2.1/go.mod h1:AP+7Atb8ftSsrha35wht7+K3R+xuzfVSQhabSO4w6CY= +github.com/DataDog/go-libddwaf/v3 v3.5.1/go.mod h1:n98d9nZ1gzenRSk53wz8l6d34ikxS+hs62A31Fqmyi4= +github.com/DataDog/go-sqllexer v0.0.10 h1:u07DuRfdlPPmOX/dclb1gcn/zaqWxUiURRRVenKILxc= +github.com/DataDog/go-sqllexer v0.0.10/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= +github.com/DataDog/go-sqllexer v0.0.14/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= +github.com/DataDog/go-tuf v1.0.2-0.5.2 h1:EeZr937eKAWPxJ26IykAdWA4A0jQXJgkhUjqEI/w7+I= +github.com/DataDog/go-tuf v1.0.2-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= +github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= +github.com/DataDog/sketches-go v1.4.5 h1:ki7VfeNz7IcNafq7yI/j5U/YCkO3LJiMDtXz9OMQbyE= +github.com/DataDog/sketches-go v1.4.5/go.mod h1:7Y8GN8Jf66DLyDhc94zuWA3uHEt/7ttt8jHOBWWrSOg= +github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= +github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= +github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= +github.com/aws/aws-sdk-go v1.50.9 h1:yX66aKnEtRc/uNV/1EH8CudRT5aLwVwcSwTBphuVPt8= +github.com/aws/aws-sdk-go v1.50.9/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= +github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= +github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= +github.com/aws/aws-sdk-go-v2/config v1.26.6/go.mod h1:uKU6cnDmYCvJ+pxO9S4cWDb2yWWIH5hra+32hVh1MI4= +github.com/aws/aws-sdk-go-v2/credentials v1.16.16 h1:8q6Rliyv0aUFAVtzaldUEcS+T5gbadPbWdV1WcAddK8= +github.com/aws/aws-sdk-go-v2/credentials v1.16.16/go.mod h1:UHVZrdUsv63hPXFo1H7c5fEneoVo9UXiz36QG1GEPi0= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 h1:c5I5iH+DZcH3xOIMlz3/tCKJDaHFwYEmxvlh2fAcFo8= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11/go.mod h1:cRrYDYAMUohBJUtUnOhydaMHtiK/1NZ0Otc9lIb6O0Y= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 h1:n3GDfwqF2tzEkXlv5cuy4iy7LpKDtqDMcNLfZDu9rls= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 h1:DBYTXwIGQSGs9w4jKm60F5dmCQ3EEruxdc0MFh+3EY4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10/go.mod h1:wohMUQiFdzo0NtxbBg0mSRGZ4vL3n0dKjLTINdcIino= +github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 h1:W9PbZAZAEcelhhjb7KuwUtf+Lbc+i7ByYJRuWLlnxyQ= +github.com/aws/aws-sdk-go-v2/service/kms v1.27.9/go.mod h1:2tFmR7fQnOdQlM2ZCEPpFnBIQD1U8wmXmduBgZbOag0= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 h1:eajuO3nykDPdYicLlP3AGgOyVN3MOlFmZv7WGTuJPow= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.7/go.mod h1:+mJNDdF+qiUlNKNC3fxn74WWNN+sOiGOEImje+3ScPM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w1NmfkfiSK8mS4zOx3BA= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= +github.com/aws/aws-xray-sdk-go v1.8.3 h1:S8GdgVncBRhzbNnNUgTPwhEqhwt2alES/9rLASyhxjU= +github.com/aws/aws-xray-sdk-go v1.8.3/go.mod h1:tv8uLMOSCABolrIF8YCcp3ghyswArsan8dfLCA1ZATk= +github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= +github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= +github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= +github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg= +github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds= +github.com/ebitengine/purego v0.6.0-alpha.5 h1:EYID3JOAdmQ4SNZYJHu9V6IqOeRQDBYxqKAg9PyoHFY= +github.com/ebitengine/purego v0.6.0-alpha.5/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk= +github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b h1:h9U78+dx9a4BKdQkBBos92HalKpaGKHrp+3Uo6yTodo= +github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= +github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7 h1:UpiO20jno/eV1eVZcxqWnUohyKRe1g8FPV/xH1s/2qs= +github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7/go.mod h1:QmrqtbKuxxSWTN3ETMPuB+VtEiBJ/A9XhoYGv8E1uD8= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.1/go.mod h1:gKOamz3EwoIoJq7mlMIRBpVTAUn8qPCrEclOKKWhD3U= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 h1:kes8mmyCpxJsI7FTwtzRqEy9CdjCtrXrXGuOpxEA7Ts= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.2/go.mod h1:Gou2R9+il93BqX25LAKCLuM+y9U2T4hlwvT1yprcna4= +github.com/hashicorp/go-sockaddr v1.0.2 h1:ztczhD1jLxIRjVejw8gFomI1BQZOe2WoVOu0SyteCQc= +github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/klauspost/compress v1.17.5 h1:d4vBd+7CHydUqpFBgUEKkSdtSugf9YFmSkvUYPquI5E= +github.com/klauspost/compress v1.17.5/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= +github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= +github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw= +github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0= +github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= +github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= +github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk= +github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= +github.com/secure-systems-lab/go-securesystemslib v0.8.0 h1:mr5An6X45Kb2nddcFlbmfHkLguCE9laoZCUzEEpIZXA= +github.com/secure-systems-lab/go-securesystemslib v0.8.0/go.mod h1:UH2VZVuJfCYR8WgMlCU1uFsOUU+KeyrTWcSS73NBOzU= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= +github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.1 h1:4VhoImhV/Bm0ToFkXFi8hXNXwpDRZ/ynw3amt82mzq0= +github.com/stretchr/objx v0.5.1/go.mod h1:/iHQpkQwBD6DLUmQ4pE+s1TXdob1mORJ4/UFdrifcy0= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/tinylib/msgp v1.1.9 h1:SHf3yoO2sGA0veCJeCBYLHuttAVFHGm2RHgNodW7wQU= +github.com/tinylib/msgp v1.1.9/go.mod h1:BCXGB54lDD8qUEPmiG0cQQUANC4IUQyB2ItS2UDlO/k= +github.com/tinylib/msgp v1.2.1/go.mod h1:2vIGs3lcUo8izAATNobrCHevYZC/LMsJtw4JPiYPHro= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA= +github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g= +github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0 h1:KfYpVmrjI7JuToy5k8XV3nkapjWx48k4E4JOtVstzQI= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0/go.mod h1:SeQhzAEccGVZVEy7aH87Nh0km+utSpo1pTv6eMMop48= +go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= +go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= +go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ= +go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= +go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= +go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak= +go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= +go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= +go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= +golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= +golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= +golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= +golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= +golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= +golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe h1:bQnxqljG/wqi4NTXu2+DJ3n7APcEA882QZ1JvhQAq9o= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:PAREbraiVEVGVdTZsVWjSbbTtSyGbAgIIvni8a8CD5s= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0= +google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0= +google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= +google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/DataDog/dd-trace-go.v1 v1.65.1 h1:Ne7kzWr/br/jwhUJR7CnqPl/mUpNxa6LfgZs0S4htZM= +gopkg.in/DataDog/dd-trace-go.v1 v1.65.1/go.mod h1:beNFIWd/H04d0k96cfltgiDH2+t0T5sDbyYLF3VTXqk= +gopkg.in/DataDog/dd-trace-go.v1 v1.72.1/go.mod h1:XqDhDqsLpThFnJc4z0FvAEItISIAUka+RHwmQ6EfN1U= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +honnef.co/go/gotraceui v0.2.0 h1:dmNsfQ9Vl3GwbiVD7Z8d/osC6WtGGrasyrC2suc4ZIQ= +honnef.co/go/gotraceui v0.2.0/go.mod h1:qHo4/W75cA3bX0QQoSvDjbJa4R8mAyyFjbWAj63XElc= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go new file mode 100644 index 0000000000..c3630900c1 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go @@ -0,0 +1,48 @@ +package main + +import ( + "context" + "fmt" + "net/http" + "strconv" + "time" + + "github.com/aws/aws-lambda-go/lambda" + + ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" + "github.com/aws/aws-lambda-go/events" + httptrace "github.com/DataDog/dd-trace-go/v2/contrib/net/http" + "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" +) + +func handleRequest(ctx context.Context, ev events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + currentSpan, _ := tracer.SpanFromContext(ctx) + currentSpanContext := currentSpan.Context() + fmt.Println("Current span ID: " + strconv.FormatUint(currentSpanContext.SpanID(), 10)) + fmt.Println("Current trace ID: " + strconv.FormatUint(currentSpanContext.TraceID(), 10)) + + // HTTP request + req, _ := http.NewRequestWithContext(ctx, "GET", "https://www.datadoghq.com", nil) + client := http.Client{} + client = *httptrace.WrapClient(&client) + client.Do(req) + + // Metric + ddlambda.Distribution("hello-go.dog", 1) + + // User-defined span + for i := 0; i < 10; i++ { + s, _ := tracer.StartSpanFromContext(ctx, "child.span") + time.Sleep(100 * time.Millisecond) + s.Finish() + } + + return events.APIGatewayProxyResponse{ + StatusCode: 200, + Body: "hello, dog!", + }, nil +} + +func main() { + lambda.Start(ddlambda.WrapHandler(handleRequest, nil)) +} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json b/contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json new file mode 100644 index 0000000000..496553dee9 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json @@ -0,0 +1,55 @@ +{ + "path": "/test/hello", + "headers": { + "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", + "Accept-Encoding": "gzip, deflate, lzma, sdch, br", + "Accept-Language": "en-US,en;q=0.8", + "CloudFront-Forwarded-Proto": "https", + "CloudFront-Is-Desktop-Viewer": "true", + "CloudFront-Is-Mobile-Viewer": "false", + "CloudFront-Is-SmartTV-Viewer": "false", + "CloudFront-Is-Tablet-Viewer": "false", + "CloudFront-Viewer-Country": "US", + "Host": "wt6mne2s9k.execute-api.us-west-2.amazonaws.com", + "Upgrade-Insecure-Requests": "1", + "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48", + "Via": "1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)", + "X-Amz-Cf-Id": "nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==", + "X-Forwarded-For": "192.168.100.1, 192.168.1.1", + "X-Forwarded-Port": "443", + "X-Forwarded-Proto": "https" + }, + "pathParameters": { + "proxy": "hello" + }, + "requestContext": { + "accountId": "123456789012", + "resourceId": "us4z18", + "stage": "test", + "requestId": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", + "identity": { + "cognitoIdentityPoolId": "", + "accountId": "", + "cognitoIdentityId": "", + "caller": "", + "apiKey": "", + "sourceIp": "192.168.100.1", + "cognitoAuthenticationType": "", + "cognitoAuthenticationProvider": "", + "userArn": "", + "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48", + "user": "" + }, + "resourcePath": "/{proxy+}", + "httpMethod": "GET", + "apiId": "wt6mne2s9k" + }, + "resource": "/{proxy+}", + "httpMethod": "GET", + "queryStringParameters": { + "name": "me" + }, + "stageVariables": { + "stageVarName": "stageVarValue" + } +} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/package.json b/contrib/aws/datadog-lambda-go/lambdatest/package.json new file mode 100644 index 0000000000..8372064182 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/package.json @@ -0,0 +1,4 @@ +{ + "name": "lambda-sample-go", + "version": "1.0.0" +} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/parse-json.js b/contrib/aws/datadog-lambda-go/lambdatest/parse-json.js new file mode 100644 index 0000000000..29fa0d7c95 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/parse-json.js @@ -0,0 +1,17 @@ +'use strict' + +var readline = require('readline'); +var rl = readline.createInterface({ + input: process.stdin, + output: process.stdout, + terminal: false +}); + +rl.on('line', function(line){ + try { + const obj = JSON.parse(line) + console.log(JSON.stringify(obj, Object.keys(obj).sort(), 2)) + } catch (e) { + console.log(line) + } +}) diff --git a/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh b/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh new file mode 100755 index 0000000000..56de1e3bdf --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh @@ -0,0 +1,210 @@ +#!/bin/bash + +# Usage - run commands from the /integration_tests directory: +# To check if new changes to the library cause changes to any snapshots: +# DD_API_KEY=XXXX aws-vault exec sandbox-account-admin -- ./run_integration_tests.sh +# To regenerate snapshots: +# UPDATE_SNAPSHOTS=true DD_API_KEY=XXXX aws-vault exec sandbox-account-admin -- ./run_integration_tests.sh + +set -e + +# Disable deprecation warnings. +export SLS_DEPRECATION_DISABLE=* + +# These values need to be in sync with serverless.yml, where there needs to be a function +# defined for every handler_runtime combination +LAMBDA_HANDLERS=("hello" "error") + +LOGS_WAIT_SECONDS=20 + +integration_tests_dir=$(cd `dirname $0` && pwd) +echo $integration_tests_dir + +script_utc_start_time=$(date -u +"%Y%m%dT%H%M%S") + +mismatch_found=false + +if [ -z "$AWS_SECRET_ACCESS_KEY" ]; then + echo "No AWS credentials were found in the environment." + echo "Note that only Datadog employees can run these integration tests." + exit 1 +fi + +if [ -z "$DD_API_KEY" ]; then + echo "No DD_API_KEY env var set, exiting" + exit 1 +fi + +if [ -n "$UPDATE_SNAPSHOTS" ]; then + echo "Overwriting snapshots in this execution" +fi + +echo "Building Go binaries" +CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o build/hello/bootstrap hello/main.go +CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o build/error/bootstrap error/main.go +zip -j build/hello.zip build/hello/bootstrap +zip -j build/error.zip build/error/bootstrap + +# Generate a random 8-character ID to avoid collisions with other runs +run_id=$(xxd -l 4 -c 4 -p < /dev/random) + +# Always remove the stack before exiting, no matter what +function remove_stack() { + echo "Removing functions" + serverless remove --stage $run_id +} +trap remove_stack EXIT + +sls --version + +echo "Deploying functions" +sls deploy --stage $run_id + +cd $integration_tests_dir + +input_event_files=$(ls ./input_events) +# Sort event files by name so that snapshots stay consistent +input_event_files=($(for file_name in ${input_event_files[@]}; do echo $file_name; done | sort)) + +echo "Invoking functions" +set +e # Don't exit this script if an invocation fails or there's a diff +for input_event_file in "${input_event_files[@]}"; do + for function_name in "${LAMBDA_HANDLERS[@]}"; do + # Get event name without trailing ".json" so we can build the snapshot file name + input_event_name=$(echo "$input_event_file" | sed "s/.json//") + # Return value snapshot file format is snapshots/return_values/{handler}_{runtime}_{input-event} + snapshot_path="$integration_tests_dir/snapshots/return_values/${function_name}_${input_event_name}.json" + + return_value=$(DD_API_KEY=$DD_API_KEY sls invoke --stage $run_id -f $function_name --path "$integration_tests_dir/input_events/$input_event_file") + sls_invoke_exit_code=$? + if [ $sls_invoke_exit_code -ne 0 ]; then + return_value="Invocation failed" + fi + + if [ ! -f $snapshot_path ]; then + # If the snapshot file doesn't exist yet, we create it + echo "Writing return value to $snapshot_path because no snapshot exists yet" + echo "$return_value" >$snapshot_path + elif [ -n "$UPDATE_SNAPSHOTS" ]; then + # If $UPDATE_SNAPSHOTS is set to true, write the new logs over the current snapshot + echo "Overwriting return value snapshot for $snapshot_path" + echo "$return_value" >$snapshot_path + else + # Compare new return value to snapshot + diff_output=$(echo "$return_value" | diff - $snapshot_path) + if [ $? -eq 1 ]; then + echo "Failed: Return value for $function_name does not match snapshot:" + echo "$diff_output" + mismatch_found=true + else + echo "Ok: Return value for $function_name with $input_event_name event matches snapshot" + fi + fi + done +done +set -e + +echo "Sleeping $LOGS_WAIT_SECONDS seconds to wait for logs to appear in CloudWatch..." +sleep $LOGS_WAIT_SECONDS + +set +e # Don't exit this script if there is a diff or the logs endpoint fails +echo "Fetching logs for invocations and comparing to snapshots" +for function_name in "${LAMBDA_HANDLERS[@]}"; do + function_snapshot_path="./snapshots/logs/$function_name.log" + + # Fetch logs with serverless cli, retrying to avoid AWS account-wide rate limit error + retry_counter=0 + while [ $retry_counter -lt 10 ]; do + raw_logs=$(serverless logs -f $function_name --stage $run_id --startTime $script_utc_start_time) + fetch_logs_exit_code=$? + if [ $fetch_logs_exit_code -eq 1 ]; then + echo "Retrying fetch logs for $function_name..." + retry_counter=$(($retry_counter + 1)) + sleep 10 + continue + fi + break + done + + if [ $retry_counter -eq 9 ]; then + echo "FAILURE: Could not retrieve logs for $function_name" + echo "Error from final attempt to retrieve logs:" + echo $raw_logs + + exit 1 + fi + + # Replace invocation-specific data like timestamps and IDs with XXXX to normalize logs across executions + logs=$( + echo "$raw_logs" | + node parse-json.js | + # Remove serverless cli errors + sed '/Serverless: Recoverable error occurred/d' | + # Remove dd-trace-go logs + sed '/Datadog Tracer/d' | + # Normalize Lambda runtime report logs + perl -p -e 's/(RequestId|TraceId|init|SegmentId|Duration|Memory Used|"e"):( )?[a-z0-9\.\-]+/\1:\2XXXX/g' | + # Normalize DD APM headers and AWS account ID + perl -p -e "s/(Current span ID:|Current trace ID:|account_id:) ?[0-9]+/\1XXXX/g" | + # Strip API key from logged requests + perl -p -e "s/(api_key=|'api_key': ')[a-z0-9\.\-]+/\1XXXX/g" | + # Normalize ISO combined date-time + perl -p -e "s/[0-9]{4}\-[0-9]{2}\-[0-9]{2}(T?)[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+ \(\-?[0-9:]+\))?Z/XXXX-XX-XXTXX:XX:XX.XXXZ/" | + # Normalize log timestamps + perl -p -e "s/[0-9]{4}(\-|\/)[0-9]{2}(\-|\/)[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+( \(\-?[0-9:]+\))?)?/XXXX-XX-XX XX:XX:XX.XXX/" | + # Normalize DD trace ID injection + perl -p -e "s/(dd\.trace_id=)[0-9]+ (dd\.span_id=)[0-9]+/\1XXXX \2XXXX/" | + # Normalize execution ID in logs prefix + perl -p -e $'s/[0-9a-z]+\-[0-9a-z]+\-[0-9a-z]+\-[0-9a-z]+\-[0-9a-z]+\t/XXXX-XXXX-XXXX-XXXX-XXXX\t/' | + # Normalize layer version tag + perl -p -e "s/(dd_lambda_layer:datadog-go)[0-9]+\.[0-9]+\.[0-9]+/\1X\.X\.X/g" | + # Normalize package version tag + perl -p -e "s/(datadog_lambda:v)[0-9]+\.[0-9]+\.[0-9]+/\1X\.X\.X/g" | + # Normalize golang version tag + perl -p -e "s/(go)[0-9]+\.[0-9]+\.[0-9]+/\1X\.X\.X/g" | + # Normalize data in logged traces + perl -p -e 's/"(span_id|apiid|runtime-id|record_ids|parent_id|trace_id|start|duration|tcp\.local\.address|tcp\.local\.port|dns\.address|request_id|function_arn|x-datadog-trace-id|x-datadog-parent-id|datadog_lambda|dd_trace)":\ ("?)[a-zA-Z0-9\.:\-]+("?)/"\1":\2XXXX\3/g' | + # Remove metrics and metas in logged traces (their order is inconsistent) + perl -p -e 's/"(meta|metrics)":{(.*?)}/"\1":{"XXXX": "XXXX"}/g' | + # Strip out run ID (from function name, resource, etc.) + perl -p -e "s/$run_id/XXXX/g" | + # Normalize data in logged metrics + perl -p -e 's/"(points\\\":\[\[)([0-9]+)/\1XXXX/g' | + # Remove INIT_START log + perl -p -e "s/INIT_START.*//g" + ) + + if [ ! -f $function_snapshot_path ]; then + # If no snapshot file exists yet, we create one + echo "Writing logs to $function_snapshot_path because no snapshot exists yet" + echo "$logs" >$function_snapshot_path + elif [ -n "$UPDATE_SNAPSHOTS" ]; then + # If $UPDATE_SNAPSHOTS is set to true write the new logs over the current snapshot + echo "Overwriting log snapshot for $function_snapshot_path" + echo "$logs" >$function_snapshot_path + else + # Compare new logs to snapshots + diff_output=$(echo "$logs" | diff - $function_snapshot_path) + if [ $? -eq 1 ]; then + echo "Failed: Mismatch found between new $function_name logs (first) and snapshot (second):" + echo "$diff_output" + mismatch_found=true + else + echo "Ok: New logs for $function_name match snapshot" + fi + fi +done +set -e + +if [ "$mismatch_found" = true ]; then + echo "FAILURE: A mismatch between new data and a snapshot was found and printed above." + echo "If the change is expected, generate new snapshots by running 'UPDATE_SNAPSHOTS=true DD_API_KEY=XXXX ./run_integration_tests.sh'" + exit 1 +fi + +if [ -n "$UPDATE_SNAPSHOTS" ]; then + echo "SUCCESS: Wrote new snapshots for all functions" + exit 0 +fi + +echo "SUCCESS: No difference found between snapshots and new return values or logs" diff --git a/contrib/aws/datadog-lambda-go/lambdatest/serverless.yml b/contrib/aws/datadog-lambda-go/lambdatest/serverless.yml new file mode 100644 index 0000000000..f5a9157d73 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/serverless.yml @@ -0,0 +1,37 @@ +# IAM permissions require service name to begin with 'integration-tests' +service: integration-tests-go + +package: + individually: true # <- package each function individually, to prevent file name conflicts + +provider: + name: aws + region: eu-west-1 + tracing: + lambda: true + apiGateway: true + memorySize: 128 + timeout: 30 + environment: + DD_API_KEY: ${env:DD_API_KEY} + DD_LOG_LEVEL: DEBUG + DD_INTEGRATION_TEST: true + DD_ENHANCED_METRICS: true + DD_TRACE_ENABLED: true + deploymentBucket: + name: integration-tests-serververless-deployment-bucket + iam: + # IAM permissions require that all functions are deployed with this role + role: "arn:aws:iam::425362996713:role/serverless-integration-test-lambda-role" + +functions: + hello: + runtime: provided.al2 + handler: bootstrap + package: + artifact: build/hello.zip + error: + runtime: provided.al2 + handler: bootstrap + package: + artifact: build/error.zip diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log new file mode 100644 index 0000000000..df2ab2b609 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log @@ -0,0 +1,46 @@ + +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Will use the API"} +START +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Merge X-Ray Traces is off, using trace context from Datadog only"} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Could not convert TraceContext to a SpanContext (most likely TraceContext was empty)"} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: sending metric via log forwarder"} +{ + "e": XXXX, + "m": "aws.lambda.enhanced.invocations", + "t": [ + "functionname:integration-tests-go-XXXX-error", + "region:eu-west-1", + "account_id:XXXX", + "memorysize:128", + "cold_start:true", + "datadog_lambda:vX.X.X", + "resource:integration-tests-go-XXXX-error", + "dd_lambda_layer:datadog-goX.X.X" + ], + "v": 1 +} +{ + "traces": [ + [ + {} + ] + ] +} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: sending metric via log forwarder"} +{ + "e": XXXX, + "m": "aws.lambda.enhanced.errors", + "t": [ + "functionname:integration-tests-go-XXXX-error", + "region:eu-west-1", + "account_id:XXXX", + "memorysize:128", + "cold_start:true", + "datadog_lambda:vX.X.X", + "resource:integration-tests-go-XXXX-error", + "dd_lambda_layer:datadog-goX.X.X" + ], + "v": 1 +} +XXXX-XX-XX XX:XX:XX.XXX {"errorMessage":"something went wrong","errorType":"errorString"} +END Duration: XXXX ms (init: XXXX ms) Memory Used: XXXX MB diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log new file mode 100644 index 0000000000..811db7e487 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log @@ -0,0 +1,45 @@ + +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Will use the API"} +START +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Merge X-Ray Traces is off, using trace context from Datadog only"} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Could not convert TraceContext to a SpanContext (most likely TraceContext was empty)"} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: sending metric via log forwarder"} +{ + "e": XXXX, + "m": "aws.lambda.enhanced.invocations", + "t": [ + "functionname:integration-tests-go-XXXX-hello", + "region:eu-west-1", + "account_id:XXXX", + "memorysize:128", + "cold_start:true", + "datadog_lambda:vX.X.X", + "resource:integration-tests-go-XXXX-hello", + "dd_lambda_layer:datadog-goX.X.X" + ], + "v": 1 +} +Current span ID:XXXX +Current trace ID:XXXX +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: adding metric \"hello-go.dog\", with value 1.000000"} +{ + "traces": [ + [ + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {} + ] + ] +} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: posting to url https://api.datadoghq.com/api/v1/distribution_points"} +XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Sending payload with body {\"series\":[{\"metric\":\"hello-go.dog\",\"tags\":[\"dd_lambda_layer:datadog-goX.X.X\"],\"type\":\"distribution\",\points\":[[XXXX,[1]]]}]}"} +END Duration: XXXX ms (init: XXXX ms) Memory Used: XXXX MB diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json new file mode 100644 index 0000000000..7147cafa92 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json @@ -0,0 +1 @@ +Invocation failed diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json new file mode 100644 index 0000000000..61a0287540 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json @@ -0,0 +1,6 @@ +{ + "statusCode": 200, + "headers": null, + "multiValueHeaders": null, + "body": "hello, dog!" +} diff --git a/go.mod b/go.mod index 9a2ff2a7d8..b08b216b03 100644 --- a/go.mod +++ b/go.mod @@ -17,6 +17,12 @@ require ( github.com/DataDog/gostackparse v0.7.0 github.com/DataDog/sketches-go v1.4.7 github.com/Masterminds/semver/v3 v3.3.1 + github.com/aws/aws-lambda-go v1.49.0 + github.com/aws/aws-sdk-go-v2 v1.38.3 + github.com/aws/aws-sdk-go-v2/config v1.31.6 + github.com/aws/aws-sdk-go-v2/service/kms v1.45.1 + github.com/aws/aws-xray-sdk-go/v2 v2.0.0 + github.com/cenkalti/backoff/v4 v4.3.0 github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 github.com/go-viper/mapstructure/v2 v2.4.0 github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db @@ -25,6 +31,7 @@ require ( github.com/puzpuzpuz/xsync/v3 v3.5.1 github.com/quasilyte/go-ruleguard/dsl v0.3.22 github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 + github.com/sony/gobreaker v1.0.0 github.com/spaolacci/murmur3 v1.1.0 github.com/stretchr/testify v1.10.0 github.com/theckman/httpforwarded v0.4.0 @@ -53,6 +60,18 @@ require ( github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/andybalholm/brotli v1.1.0 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.18.10 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.6 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.6 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.6 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.6 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.29.1 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.34.2 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.38.2 // indirect + github.com/aws/smithy-go v1.23.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dustin/go-humanize v1.0.1 // indirect @@ -79,6 +98,8 @@ require ( github.com/stretchr/objx v0.5.2 // indirect github.com/tklauser/go-sysconf v0.3.14 // indirect github.com/tklauser/numcpus v0.9.0 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.52.0 // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect go.opentelemetry.io/collector/component v1.31.0 // indirect diff --git a/go.sum b/go.sum index ba730bfded..e57b86185a 100644 --- a/go.sum +++ b/go.sum @@ -1,3 +1,5 @@ +github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= +github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= @@ -35,6 +37,42 @@ github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lpr github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= +github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= +github.com/aws/aws-lambda-go v1.49.0 h1:z4VhTqkFZPM3xpEtTqWqRqsRH4TZBMJqTkRiBPYLqIQ= +github.com/aws/aws-lambda-go v1.49.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= +github.com/aws/aws-sdk-go-v2 v1.38.3 h1:B6cV4oxnMs45fql4yRH+/Po/YU+597zgWqvDpYMturk= +github.com/aws/aws-sdk-go-v2 v1.38.3/go.mod h1:sDioUELIUO9Znk23YVmIk86/9DOpkbyyVb1i/gUNFXY= +github.com/aws/aws-sdk-go-v2/config v1.31.6 h1:a1t8fXY4GT4xjyJExz4knbuoxSCacB5hT/WgtfPyLjo= +github.com/aws/aws-sdk-go-v2/config v1.31.6/go.mod h1:5ByscNi7R+ztvOGzeUaIu49vkMk2soq5NaH5PYe33MQ= +github.com/aws/aws-sdk-go-v2/credentials v1.18.10 h1:xdJnXCouCx8Y0NncgoptztUocIYLKeQxrCgN6x9sdhg= +github.com/aws/aws-sdk-go-v2/credentials v1.18.10/go.mod h1:7tQk08ntj914F/5i9jC4+2HQTAuJirq7m1vZVIhEkWs= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.6 h1:wbjnrrMnKew78/juW7I2BtKQwa1qlf6EjQgS69uYY14= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.6/go.mod h1:AtiqqNrDioJXuUgz3+3T0mBWN7Hro2n9wll2zRUc0ww= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.6 h1:uF68eJA6+S9iVr9WgX1NaRGyQ/6MdIyc4JNUo6TN1FA= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.6/go.mod h1:qlPeVZCGPiobx8wb1ft0GHT5l+dc6ldnwInDFaMvC7Y= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.6 h1:pa1DEC6JoI0zduhZePp3zmhWvk/xxm4NB8Hy/Tlsgos= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.6/go.mod h1:gxEjPebnhWGJoaDdtDkA0JX46VRg1wcTHYe63OfX5pE= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1 h1:oegbebPEMA/1Jny7kvwejowCaHz1FWZAQ94WXFNCyTM= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1/go.mod h1:kemo5Myr9ac0U9JfSjMo9yHLtw+pECEHsFtJ9tqCEI8= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.6 h1:LHS1YAIJXJ4K9zS+1d/xa9JAA9sL2QyXIQCQFQW/X08= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.6/go.mod h1:c9PCiTEuh0wQID5/KqA32J+HAgZxN9tOGXKCiYJjTZI= +github.com/aws/aws-sdk-go-v2/service/kms v1.45.1 h1:NhkI4kfcZYmcIM34a+q9drh3aMG1BthkyziOr7sRTv4= +github.com/aws/aws-sdk-go-v2/service/kms v1.45.1/go.mod h1:elyXIFqx79eHvd0cRAzYDYHajeoJEygkBjJto4HJddc= +github.com/aws/aws-sdk-go-v2/service/sso v1.29.1 h1:8OLZnVJPvjnrxEwHFg9hVUof/P4sibH+Ea4KKuqAGSg= +github.com/aws/aws-sdk-go-v2/service/sso v1.29.1/go.mod h1:27M3BpVi0C02UiQh1w9nsBEit6pLhlaH3NHna6WUbDE= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.34.2 h1:gKWSTnqudpo8dAxqBqZnDoDWCiEh/40FziUjr/mo6uA= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.34.2/go.mod h1:x7+rkNmRoEN1U13A6JE2fXne9EWyJy54o3n6d4mGaXQ= +github.com/aws/aws-sdk-go-v2/service/sts v1.38.2 h1:YZPjhyaGzhDQEvsffDEcpycq49nl7fiGcfJTIo8BszI= +github.com/aws/aws-sdk-go-v2/service/sts v1.38.2/go.mod h1:2dIN8qhQfv37BdUYGgEC8Q3tteM3zFxTI1MLO2O3J3c= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= +github.com/aws/smithy-go v1.23.0 h1:8n6I3gXzWJB2DxBDnfxgBaSX6oe0d/t10qGz7OKqMCE= +github.com/aws/smithy-go v1.23.0/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= @@ -84,6 +122,8 @@ github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgY github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= @@ -134,6 +174,8 @@ github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/wo github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/sony/gobreaker v1.0.0 h1:feX5fGGXSl3dYd4aHZItw+FpHLvvoaqkawKjVNiFMNQ= +github.com/sony/gobreaker v1.0.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -158,6 +200,10 @@ github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZ github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= +github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= diff --git a/go.work.sum b/go.work.sum index 20952ab27a..ddc7b7a978 100644 --- a/go.work.sum +++ b/go.work.sum @@ -1062,6 +1062,7 @@ github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.2 h1:71gafPkX0RyJJqq921QJ+JvV github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.2/go.mod h1:7w4Wsl8JbRrZmi6YHRa0fxvLyY+VoYSVmC7OpdJP/VQ= github.com/aws/aws-sdk-go-v2/service/kinesis v1.33.2 h1:t3Ukha929to7c4SZDeCP3aRQBgn01nhwKxggYOVRMR0= github.com/aws/aws-sdk-go-v2/service/kinesis v1.33.2/go.mod h1:dJngkoVMrq0K7QvRkdRZYM4NUp6cdWa2GBdpm8zoY8U= +github.com/aws/aws-sdk-go-v2/service/route53 v1.6.2/go.mod h1:ZnAMilx42P7DgIrdjlWCkNIGSBLzeyk6T31uB8oGTwY= github.com/aws/aws-sdk-go-v2/service/s3 v1.32.0/go.mod h1:aSl9/LJltSz1cVusiR/Mu8tvI4Sv/5w/WWrJmmkNii0= github.com/aws/aws-sdk-go-v2/service/sfn v1.19.4/go.mod h1:uWCH4ATwNrkRO40j8Dmy7u/Y1/BVWgCM+YjBNYZeOro= github.com/aws/aws-sdk-go-v2/service/sns v1.21.4/go.mod h1:bbB779DXXOnPXvB7F3dP7AjuV1Eyr7fNyrA058ExuzY= From 6bbaff070e91add94f646bcb7aa196c3387528f2 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Fri, 5 Sep 2025 15:07:18 -0400 Subject: [PATCH 02/25] copyright header fix --- contrib/aws/datadog-lambda-go/CONTRIBUTING.md | 19 --------- contrib/aws/datadog-lambda-go/README.md | 39 ------------------- .../aws/datadog-lambda-go/awslambdanorpc.go | 11 ++---- .../aws/datadog-lambda-go/awslambdawithrpc.go | 11 ++---- contrib/aws/datadog-lambda-go/ddlambda.go | 13 +++---- .../ddlambda_example_test.go | 8 +++- .../aws/datadog-lambda-go/ddlambda_test.go | 12 +++--- .../internal/extension/extension.go | 11 ++---- .../internal/extension/extension_test.go | 13 +++---- .../datadog-lambda-go/internal/logger/log.go | 5 +++ .../datadog-lambda-go/internal/metrics/api.go | 11 ++---- .../internal/metrics/api_test.go | 11 ++---- .../internal/metrics/batcher.go | 11 ++---- .../internal/metrics/batcher_test.go | 11 ++---- .../internal/metrics/constants.go | 11 ++---- .../internal/metrics/context.go | 11 ++---- .../internal/metrics/context_test.go | 11 ++---- .../internal/metrics/kms_decrypter.go | 15 ++++--- .../internal/metrics/listener.go | 11 ++---- .../internal/metrics/listener_test.go | 11 ++---- .../internal/metrics/model.go | 11 ++---- .../internal/metrics/processor.go | 11 ++---- .../internal/metrics/processor_test.go | 11 ++---- .../internal/metrics/time.go | 11 ++---- .../internal/trace/constants.go | 11 ++---- .../internal/trace/context.go | 15 +++---- .../internal/trace/context_test.go | 11 ++---- .../internal/trace/listener.go | 17 ++++---- .../internal/trace/listener_test.go | 13 +++---- .../internal/version/version.go | 11 ------ .../internal/wrapper/wrap_handler.go | 11 ++---- .../internal/wrapper/wrap_handler_test.go | 11 ++---- .../lambdatest/error/main.go | 6 +++ .../lambdatest/hello/main.go | 7 +++- 34 files changed, 144 insertions(+), 269 deletions(-) delete mode 100644 contrib/aws/datadog-lambda-go/CONTRIBUTING.md delete mode 100644 contrib/aws/datadog-lambda-go/README.md delete mode 100644 contrib/aws/datadog-lambda-go/internal/version/version.go diff --git a/contrib/aws/datadog-lambda-go/CONTRIBUTING.md b/contrib/aws/datadog-lambda-go/CONTRIBUTING.md deleted file mode 100644 index c1950c5d35..0000000000 --- a/contrib/aws/datadog-lambda-go/CONTRIBUTING.md +++ /dev/null @@ -1,19 +0,0 @@ -# Contributing - -We love pull requests. For new features, consider opening an issue to discuss the idea first. When you're ready to open a pull requset, here's a quick guide. - -1. Fork, clone and branch off: - ```bash - git clone git@github.com:/datadog-lambda-go.git - git checkout -b - ``` -1. Make your changes, update tests and ensure the tests pass: - ```bash - go test ./... - ``` -1. Build and test your own serverless application with your modified version of `datadog-lambda-go`. -1. Push to your fork and [submit a pull request][pr]. - -[pr]: https://github.com/your-username/datadog-lambda-go/compare/DataDog:main...main - -At this point you're waiting on us. We may suggest some changes or improvements or alternatives. diff --git a/contrib/aws/datadog-lambda-go/README.md b/contrib/aws/datadog-lambda-go/README.md deleted file mode 100644 index 8c5c90fc9b..0000000000 --- a/contrib/aws/datadog-lambda-go/README.md +++ /dev/null @@ -1,39 +0,0 @@ -# datadog-lambda-go - -![build](https://github.com/DataDog/datadog-lambda-go/workflows/build/badge.svg) -[![Code Coverage](https://img.shields.io/codecov/c/github/DataDog/datadog-lambda-go)](https://codecov.io/gh/DataDog/datadog-lambda-go) -[![Slack](https://chat.datadoghq.com/badge.svg?bg=632CA6)](https://chat.datadoghq.com/) -[![Godoc](https://img.shields.io/badge/godoc-reference-blue.svg)](https://godoc.org/github.com/DataDog/datadog-lambda-go) -[![License](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/DataDog/datadog-lambda-go/blob/main/LICENSE) - -Datadog Lambda Library for Go enables enhanced Lambda metrics, distributed tracing, and custom metric submission from AWS Lambda functions. - -## Installation - -Follow the [installation instructions](https://docs.datadoghq.com/serverless/installation/go/), and view your function's enhanced metrics, traces and logs in Datadog. - -## Configurations - -See the [advanced configuration options](https://docs.datadoghq.com/serverless/configuration) to tag your telemetry, capture request/response payloads, filter or scrub sensitive information from logs or traces, and more. - -## Opening Issues - -If you encounter a bug with this package, we want to hear about it. Before opening a new issue, search the existing issues to avoid duplicates. - -When opening an issue, include the datadog-lambda-go version, `go version`, and stack trace if available. In addition, include the steps to reproduce when appropriate. - -You can also open an issue for a feature request. - -## Contributing - -If you find an issue with this package and have a fix, please feel free to open a pull request following the [procedures](https://github.com/DataDog/datadog-lambda-go/blob/main/CONTRIBUTING.md). - -## Community - -For product feedback and questions, join the `#serverless` channel in the [Datadog community on Slack](https://chat.datadoghq.com/). - -## License - -Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0. - -This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021 Datadog, Inc. diff --git a/contrib/aws/datadog-lambda-go/awslambdanorpc.go b/contrib/aws/datadog-lambda-go/awslambdanorpc.go index 287a285da8..b08f0c8ffd 100644 --- a/contrib/aws/datadog-lambda-go/awslambdanorpc.go +++ b/contrib/aws/datadog-lambda-go/awslambdanorpc.go @@ -1,13 +1,10 @@ //go:build lambda.norpc // +build lambda.norpc -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package ddlambda diff --git a/contrib/aws/datadog-lambda-go/awslambdawithrpc.go b/contrib/aws/datadog-lambda-go/awslambdawithrpc.go index 994629a11a..c2663ba972 100644 --- a/contrib/aws/datadog-lambda-go/awslambdawithrpc.go +++ b/contrib/aws/datadog-lambda-go/awslambdawithrpc.go @@ -1,13 +1,10 @@ //go:build !lambda.norpc // +build !lambda.norpc -/* -* Unless explicitly stated otherwise all files in this repository are licensed -* under the Apache License Version 2.0. -* -* This product includes software developed at Datadog (https://www.datadoghq.com/). -* Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package ddlambda diff --git a/contrib/aws/datadog-lambda-go/ddlambda.go b/contrib/aws/datadog-lambda-go/ddlambda.go index 46dc2725f7..8dd07ed663 100644 --- a/contrib/aws/datadog-lambda-go/ddlambda.go +++ b/contrib/aws/datadog-lambda-go/ddlambda.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package ddlambda @@ -18,8 +15,8 @@ import ( "strings" "time" - "github.com/aws/aws-lambda-go/lambda" "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/aws/aws-lambda-go/lambda" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" diff --git a/contrib/aws/datadog-lambda-go/ddlambda_example_test.go b/contrib/aws/datadog-lambda-go/ddlambda_example_test.go index 1e2a9dc593..08eb013f80 100644 --- a/contrib/aws/datadog-lambda-go/ddlambda_example_test.go +++ b/contrib/aws/datadog-lambda-go/ddlambda_example_test.go @@ -1,12 +1,18 @@ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. + package ddlambda_test import ( "context" "encoding/json" - "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "strings" "testing" + "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/aws/aws-lambda-go/events" ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" diff --git a/contrib/aws/datadog-lambda-go/ddlambda_test.go b/contrib/aws/datadog-lambda-go/ddlambda_test.go index a650bc513e..e553e25bed 100644 --- a/contrib/aws/datadog-lambda-go/ddlambda_test.go +++ b/contrib/aws/datadog-lambda-go/ddlambda_test.go @@ -1,10 +1,8 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. + package ddlambda import ( diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension.go b/contrib/aws/datadog-lambda-go/internal/extension/extension.go index 7da39a5d61..5b27535e01 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package extension diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go index 2d108c3bfd..c4b8c88006 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package extension @@ -18,9 +15,9 @@ import ( "testing" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" - "github.com/stretchr/testify/assert" "github.com/DataDog/dd-trace-go/v2/ddtrace" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/stretchr/testify/assert" ) type ClientErrorMock struct { diff --git a/contrib/aws/datadog-lambda-go/internal/logger/log.go b/contrib/aws/datadog-lambda-go/internal/logger/log.go index c2eec046b0..e25aac741a 100644 --- a/contrib/aws/datadog-lambda-go/internal/logger/log.go +++ b/contrib/aws/datadog-lambda-go/internal/logger/log.go @@ -1,3 +1,8 @@ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. + package logger import ( diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/api.go b/contrib/aws/datadog-lambda-go/internal/metrics/api.go index a6d4572bbf..1f43012314 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/api.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/api.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go index f939fca72e..fbd24e266d 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/api_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go b/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go index 5d52e37781..dd4d939214 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/batcher.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go index 75d262341a..5e04fc1571 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/batcher_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/constants.go b/contrib/aws/datadog-lambda-go/internal/metrics/constants.go index fc553d5ea7..0b80157386 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/constants.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/constants.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/context.go b/contrib/aws/datadog-lambda-go/internal/metrics/context.go index 744cc8ca7c..4f1d9394a5 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/context.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/context.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go index 3a17f2ab29..5bbb94f96b 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go index a7e3681439..7fe0b61d1c 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go @@ -1,19 +1,18 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. + package metrics import ( "context" "encoding/base64" "fmt" - "github.com/aws/aws-sdk-go-v2/aws" "os" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/kms" diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go index 5a97a978f9..61bd2c9407 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go index 6e25870a36..6b01b9a409 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/model.go b/contrib/aws/datadog-lambda-go/internal/metrics/model.go index d4e3aea057..326751d51d 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/model.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/model.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/processor.go b/contrib/aws/datadog-lambda-go/internal/metrics/processor.go index d890bbb271..4ac248d45b 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/processor.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/processor.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go index 3ef25d175e..714bf67ea0 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/processor_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/time.go b/contrib/aws/datadog-lambda-go/internal/metrics/time.go index ed71525eaa..5a0bd362ab 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/time.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/time.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package metrics diff --git a/contrib/aws/datadog-lambda-go/internal/trace/constants.go b/contrib/aws/datadog-lambda-go/internal/trace/constants.go index 21a66e6061..f5b98de38b 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/constants.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/constants.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package trace diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context.go b/contrib/aws/datadog-lambda-go/internal/trace/context.go index 68ed214d11..e82e44a3b3 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/context.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/context.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package trace @@ -19,10 +16,10 @@ import ( "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" - "github.com/aws/aws-xray-sdk-go/v2/header" - "github.com/aws/aws-xray-sdk-go/v2/xray" "github.com/DataDog/dd-trace-go/v2/ddtrace" "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/aws/aws-xray-sdk-go/v2/header" + "github.com/aws/aws-xray-sdk-go/v2/xray" ) type ( diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go index 201d364a1a..4c9d2fe6a7 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package trace diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener.go b/contrib/aws/datadog-lambda-go/internal/trace/listener.go index 4237af75d7..9a163c612b 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package trace @@ -18,11 +15,11 @@ import ( "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" - "github.com/aws/aws-lambda-go/lambdacontext" - "go.opentelemetry.io/otel" "github.com/DataDog/dd-trace-go/v2/ddtrace" ddotel "github.com/DataDog/dd-trace-go/v2/ddtrace/opentelemetry" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/aws/aws-lambda-go/lambdacontext" + "go.opentelemetry.io/otel" ) type ( @@ -167,7 +164,7 @@ func startFunctionExecutionSpan(ctx context.Context, mergeXrayTraces bool, isDdS ddtracer.Tag("datadog_lambda", version.DDLambdaVersion), ddtracer.Tag("dd_trace", version.DDTraceVersion), } - + if parentSpanContext != nil { if sc, ok := parentSpanContext.(*ddtracer.SpanContext); ok { spanOptions = append(spanOptions, ddtracer.ChildOf(sc)) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go index 47b9a4535d..cfa6b6e103 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package trace @@ -14,9 +11,9 @@ import ( "testing" "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/v2/ddtrace/mocktracer" "github.com/aws/aws-lambda-go/lambdacontext" "github.com/stretchr/testify/assert" - "github.com/DataDog/dd-trace-go/v2/ddtrace/mocktracer" ) func TestSeparateVersionFromFunctionArnWithVersion(t *testing.T) { diff --git a/contrib/aws/datadog-lambda-go/internal/version/version.go b/contrib/aws/datadog-lambda-go/internal/version/version.go deleted file mode 100644 index f088b21e1c..0000000000 --- a/contrib/aws/datadog-lambda-go/internal/version/version.go +++ /dev/null @@ -1,11 +0,0 @@ -// Do not modify this file manually. It is modified by the release script. -package version - -// DDLambdaVersion is the current version number of this library (datadog-lambda-go). -// It is automatically updated by the release script. -const DDLambdaVersion = "1.23.0" - -// DDTraceVersion is the version of dd-trace-go required by this libary. -// This should match the version number specified in go.mod. -// It is automatically updated by the release script -const DDTraceVersion = "1.72.1" diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go index e64fe65f28..8def4814f2 100644 --- a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package wrapper diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go index 8c5fe3f097..687fbf963d 100644 --- a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go @@ -1,10 +1,7 @@ -/* - * Unless explicitly stated otherwise all files in this repository are licensed - * under the Apache License Version 2.0. - * - * This product includes software developed at Datadog (https://www.datadoghq.com/). - * Copyright 2021 Datadog, Inc. - */ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. package wrapper diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go index b0d1bfd773..749be43962 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go @@ -1,3 +1,9 @@ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. +// + package main import ( diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go index c3630900c1..9ae4cc3f4b 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go @@ -1,3 +1,8 @@ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2016 Datadog, Inc. + package main import ( @@ -10,9 +15,9 @@ import ( "github.com/aws/aws-lambda-go/lambda" ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" - "github.com/aws/aws-lambda-go/events" httptrace "github.com/DataDog/dd-trace-go/v2/contrib/net/http" "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/aws/aws-lambda-go/events" ) func handleRequest(ctx context.Context, ev events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { From 9eb1e90f0cf9865f0686d7806814cf8b7f26cbb2 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 10 Sep 2025 12:52:01 -0400 Subject: [PATCH 03/25] moving go.mod --- contrib/aws/datadog-lambda-go/go.mod | 105 +++++++++++++++++++++++++++ go.mod | 21 ------ go.sum | 46 ------------ 3 files changed, 105 insertions(+), 67 deletions(-) create mode 100644 contrib/aws/datadog-lambda-go/go.mod diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod new file mode 100644 index 0000000000..4affbe0555 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -0,0 +1,105 @@ +module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 + +go 1.23.0 + +require ( + github.com/DataDog/datadog-go/v5 v5.6.0 + github.com/DataDog/dd-trace-go/v2 v2.1.0 + github.com/aws/aws-lambda-go v1.46.0 + github.com/aws/aws-sdk-go-v2 v1.24.1 + github.com/aws/aws-sdk-go-v2/config v1.26.6 + github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 + github.com/aws/aws-xray-sdk-go/v2 v2.0.0 + github.com/cenkalti/backoff/v4 v4.2.1 + github.com/sony/gobreaker v0.5.0 + github.com/stretchr/testify v1.10.0 + go.opentelemetry.io/otel v1.35.0 +) + +require go.uber.org/atomic v1.11.0 // indirect + +require ( + github.com/DataDog/appsec-internal-go v1.13.0 // indirect + github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/proto v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/trace v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/util/log v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/version v0.66.1 // indirect + github.com/DataDog/go-libddwaf/v4 v4.3.0 // indirect + github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a // indirect + github.com/DataDog/go-sqllexer v0.1.6 // indirect + github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect + github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0 // indirect + github.com/DataDog/sketches-go v1.4.7 // indirect + github.com/Masterminds/semver/v3 v3.3.1 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/andybalholm/brotli v1.1.0 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect + github.com/aws/smithy-go v1.19.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 // indirect + github.com/ebitengine/purego v0.8.3 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/go-viper/mapstructure/v2 v2.2.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/outcaste-io/ristretto v0.2.3 // indirect + github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect + github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect + github.com/shirou/gopsutil/v4 v4.25.1 // indirect + github.com/tinylib/msgp v1.2.5 // indirect + github.com/tklauser/go-sysconf v0.3.14 // indirect + github.com/tklauser/numcpus v0.8.0 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.52.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/collector/component v1.28.1 // indirect + go.opentelemetry.io/collector/pdata v1.28.1 // indirect + go.opentelemetry.io/collector/pdata/pprofile v0.122.1 // indirect + go.opentelemetry.io/collector/semconv v0.122.1 // indirect + go.opentelemetry.io/otel/metric v1.35.0 // indirect + go.opentelemetry.io/otel/trace v1.35.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac // indirect + golang.org/x/mod v0.23.0 // indirect + golang.org/x/net v0.39.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/text v0.24.0 // indirect + golang.org/x/time v0.11.0 // indirect + golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 // indirect + google.golang.org/grpc v1.71.1 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.mod b/go.mod index b08b216b03..9a2ff2a7d8 100644 --- a/go.mod +++ b/go.mod @@ -17,12 +17,6 @@ require ( github.com/DataDog/gostackparse v0.7.0 github.com/DataDog/sketches-go v1.4.7 github.com/Masterminds/semver/v3 v3.3.1 - github.com/aws/aws-lambda-go v1.49.0 - github.com/aws/aws-sdk-go-v2 v1.38.3 - github.com/aws/aws-sdk-go-v2/config v1.31.6 - github.com/aws/aws-sdk-go-v2/service/kms v1.45.1 - github.com/aws/aws-xray-sdk-go/v2 v2.0.0 - github.com/cenkalti/backoff/v4 v4.3.0 github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 github.com/go-viper/mapstructure/v2 v2.4.0 github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db @@ -31,7 +25,6 @@ require ( github.com/puzpuzpuz/xsync/v3 v3.5.1 github.com/quasilyte/go-ruleguard/dsl v0.3.22 github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 - github.com/sony/gobreaker v1.0.0 github.com/spaolacci/murmur3 v1.1.0 github.com/stretchr/testify v1.10.0 github.com/theckman/httpforwarded v0.4.0 @@ -60,18 +53,6 @@ require ( github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/andybalholm/brotli v1.1.0 // indirect - github.com/aws/aws-sdk-go-v2/credentials v1.18.10 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.6 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.6 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.6 // indirect - github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.6 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.29.1 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.34.2 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.38.2 // indirect - github.com/aws/smithy-go v1.23.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dustin/go-humanize v1.0.1 // indirect @@ -98,8 +79,6 @@ require ( github.com/stretchr/objx v0.5.2 // indirect github.com/tklauser/go-sysconf v0.3.14 // indirect github.com/tklauser/numcpus v0.9.0 // indirect - github.com/valyala/bytebufferpool v1.0.0 // indirect - github.com/valyala/fasthttp v1.52.0 // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect go.opentelemetry.io/collector/component v1.31.0 // indirect diff --git a/go.sum b/go.sum index e57b86185a..ba730bfded 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,3 @@ -github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= -github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= @@ -37,42 +35,6 @@ github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lpr github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= -github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= -github.com/aws/aws-lambda-go v1.49.0 h1:z4VhTqkFZPM3xpEtTqWqRqsRH4TZBMJqTkRiBPYLqIQ= -github.com/aws/aws-lambda-go v1.49.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= -github.com/aws/aws-sdk-go-v2 v1.38.3 h1:B6cV4oxnMs45fql4yRH+/Po/YU+597zgWqvDpYMturk= -github.com/aws/aws-sdk-go-v2 v1.38.3/go.mod h1:sDioUELIUO9Znk23YVmIk86/9DOpkbyyVb1i/gUNFXY= -github.com/aws/aws-sdk-go-v2/config v1.31.6 h1:a1t8fXY4GT4xjyJExz4knbuoxSCacB5hT/WgtfPyLjo= -github.com/aws/aws-sdk-go-v2/config v1.31.6/go.mod h1:5ByscNi7R+ztvOGzeUaIu49vkMk2soq5NaH5PYe33MQ= -github.com/aws/aws-sdk-go-v2/credentials v1.18.10 h1:xdJnXCouCx8Y0NncgoptztUocIYLKeQxrCgN6x9sdhg= -github.com/aws/aws-sdk-go-v2/credentials v1.18.10/go.mod h1:7tQk08ntj914F/5i9jC4+2HQTAuJirq7m1vZVIhEkWs= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.6 h1:wbjnrrMnKew78/juW7I2BtKQwa1qlf6EjQgS69uYY14= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.6/go.mod h1:AtiqqNrDioJXuUgz3+3T0mBWN7Hro2n9wll2zRUc0ww= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.6 h1:uF68eJA6+S9iVr9WgX1NaRGyQ/6MdIyc4JNUo6TN1FA= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.6/go.mod h1:qlPeVZCGPiobx8wb1ft0GHT5l+dc6ldnwInDFaMvC7Y= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.6 h1:pa1DEC6JoI0zduhZePp3zmhWvk/xxm4NB8Hy/Tlsgos= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.6/go.mod h1:gxEjPebnhWGJoaDdtDkA0JX46VRg1wcTHYe63OfX5pE= -github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo= -github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1 h1:oegbebPEMA/1Jny7kvwejowCaHz1FWZAQ94WXFNCyTM= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.1/go.mod h1:kemo5Myr9ac0U9JfSjMo9yHLtw+pECEHsFtJ9tqCEI8= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.6 h1:LHS1YAIJXJ4K9zS+1d/xa9JAA9sL2QyXIQCQFQW/X08= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.6/go.mod h1:c9PCiTEuh0wQID5/KqA32J+HAgZxN9tOGXKCiYJjTZI= -github.com/aws/aws-sdk-go-v2/service/kms v1.45.1 h1:NhkI4kfcZYmcIM34a+q9drh3aMG1BthkyziOr7sRTv4= -github.com/aws/aws-sdk-go-v2/service/kms v1.45.1/go.mod h1:elyXIFqx79eHvd0cRAzYDYHajeoJEygkBjJto4HJddc= -github.com/aws/aws-sdk-go-v2/service/sso v1.29.1 h1:8OLZnVJPvjnrxEwHFg9hVUof/P4sibH+Ea4KKuqAGSg= -github.com/aws/aws-sdk-go-v2/service/sso v1.29.1/go.mod h1:27M3BpVi0C02UiQh1w9nsBEit6pLhlaH3NHna6WUbDE= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.34.2 h1:gKWSTnqudpo8dAxqBqZnDoDWCiEh/40FziUjr/mo6uA= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.34.2/go.mod h1:x7+rkNmRoEN1U13A6JE2fXne9EWyJy54o3n6d4mGaXQ= -github.com/aws/aws-sdk-go-v2/service/sts v1.38.2 h1:YZPjhyaGzhDQEvsffDEcpycq49nl7fiGcfJTIo8BszI= -github.com/aws/aws-sdk-go-v2/service/sts v1.38.2/go.mod h1:2dIN8qhQfv37BdUYGgEC8Q3tteM3zFxTI1MLO2O3J3c= -github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= -github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= -github.com/aws/smithy-go v1.23.0 h1:8n6I3gXzWJB2DxBDnfxgBaSX6oe0d/t10qGz7OKqMCE= -github.com/aws/smithy-go v1.23.0/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI= -github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= -github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= @@ -122,8 +84,6 @@ github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgY github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= -github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= @@ -174,8 +134,6 @@ github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/wo github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/sony/gobreaker v1.0.0 h1:feX5fGGXSl3dYd4aHZItw+FpHLvvoaqkawKjVNiFMNQ= -github.com/sony/gobreaker v1.0.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -200,10 +158,6 @@ github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZ github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= -github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= -github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= From 7122306941d5b66a0d7645aa75396e3e0c0f33b6 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 10 Sep 2025 12:56:18 -0400 Subject: [PATCH 04/25] update go.mod --- contrib/aws/datadog-lambda-go/go.mod | 4 +- contrib/aws/datadog-lambda-go/go.sum | 105 +++++++++++++++++++++++++++ 2 files changed, 107 insertions(+), 2 deletions(-) create mode 100644 contrib/aws/datadog-lambda-go/go.sum diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod index 4affbe0555..9e4db53573 100644 --- a/contrib/aws/datadog-lambda-go/go.mod +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -1,6 +1,6 @@ -module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 +module github.com/DataDog/datadog-lambda-go -go 1.23.0 +go 1.24.0 require ( github.com/DataDog/datadog-go/v5 v5.6.0 diff --git a/contrib/aws/datadog-lambda-go/go.sum b/contrib/aws/datadog-lambda-go/go.sum new file mode 100644 index 0000000000..9e4db53573 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/go.sum @@ -0,0 +1,105 @@ +module github.com/DataDog/datadog-lambda-go + +go 1.24.0 + +require ( + github.com/DataDog/datadog-go/v5 v5.6.0 + github.com/DataDog/dd-trace-go/v2 v2.1.0 + github.com/aws/aws-lambda-go v1.46.0 + github.com/aws/aws-sdk-go-v2 v1.24.1 + github.com/aws/aws-sdk-go-v2/config v1.26.6 + github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 + github.com/aws/aws-xray-sdk-go/v2 v2.0.0 + github.com/cenkalti/backoff/v4 v4.2.1 + github.com/sony/gobreaker v0.5.0 + github.com/stretchr/testify v1.10.0 + go.opentelemetry.io/otel v1.35.0 +) + +require go.uber.org/atomic v1.11.0 // indirect + +require ( + github.com/DataDog/appsec-internal-go v1.13.0 // indirect + github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/proto v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/trace v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/util/log v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1 // indirect + github.com/DataDog/datadog-agent/pkg/version v0.66.1 // indirect + github.com/DataDog/go-libddwaf/v4 v4.3.0 // indirect + github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a // indirect + github.com/DataDog/go-sqllexer v0.1.6 // indirect + github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect + github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0 // indirect + github.com/DataDog/sketches-go v1.4.7 // indirect + github.com/Masterminds/semver/v3 v3.3.1 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/andybalholm/brotli v1.1.0 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect + github.com/aws/smithy-go v1.19.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/dustin/go-humanize v1.0.1 // indirect + github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 // indirect + github.com/ebitengine/purego v0.8.3 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/go-viper/mapstructure/v2 v2.2.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/outcaste-io/ristretto v0.2.3 // indirect + github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect + github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect + github.com/shirou/gopsutil/v4 v4.25.1 // indirect + github.com/tinylib/msgp v1.2.5 // indirect + github.com/tklauser/go-sysconf v0.3.14 // indirect + github.com/tklauser/numcpus v0.8.0 // indirect + github.com/valyala/bytebufferpool v1.0.0 // indirect + github.com/valyala/fasthttp v1.52.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/collector/component v1.28.1 // indirect + go.opentelemetry.io/collector/pdata v1.28.1 // indirect + go.opentelemetry.io/collector/pdata/pprofile v0.122.1 // indirect + go.opentelemetry.io/collector/semconv v0.122.1 // indirect + go.opentelemetry.io/otel/metric v1.35.0 // indirect + go.opentelemetry.io/otel/trace v1.35.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac // indirect + golang.org/x/mod v0.23.0 // indirect + golang.org/x/net v0.39.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/text v0.24.0 // indirect + golang.org/x/time v0.11.0 // indirect + golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 // indirect + google.golang.org/grpc v1.71.1 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) From 653424883d22d83b4250930aa88ac04f7f98130c Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Mon, 15 Sep 2025 12:56:43 -0400 Subject: [PATCH 05/25] fix go.mod files --- contrib/aws/datadog-lambda-go/go.mod | 2 +- contrib/aws/datadog-lambda-go/go.sum | 439 +++++++++++++----- .../datadog-lambda-go/lambdatest/error/go.mod | 101 ++-- .../datadog-lambda-go/lambdatest/error/go.sum | 354 ++++++++------ .../datadog-lambda-go/lambdatest/hello/go.mod | 110 +++-- .../datadog-lambda-go/lambdatest/hello/go.sum | 368 +++++++++------ .../lambdatest/hello/main.go | 2 +- 7 files changed, 911 insertions(+), 465 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod index 9e4db53573..ba80cd8923 100644 --- a/contrib/aws/datadog-lambda-go/go.mod +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -1,4 +1,4 @@ -module github.com/DataDog/datadog-lambda-go +module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go go 1.24.0 diff --git a/contrib/aws/datadog-lambda-go/go.sum b/contrib/aws/datadog-lambda-go/go.sum index 9e4db53573..56962cb786 100644 --- a/contrib/aws/datadog-lambda-go/go.sum +++ b/contrib/aws/datadog-lambda-go/go.sum @@ -1,105 +1,334 @@ -module github.com/DataDog/datadog-lambda-go - -go 1.24.0 - -require ( - github.com/DataDog/datadog-go/v5 v5.6.0 - github.com/DataDog/dd-trace-go/v2 v2.1.0 - github.com/aws/aws-lambda-go v1.46.0 - github.com/aws/aws-sdk-go-v2 v1.24.1 - github.com/aws/aws-sdk-go-v2/config v1.26.6 - github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 - github.com/aws/aws-xray-sdk-go/v2 v2.0.0 - github.com/cenkalti/backoff/v4 v4.2.1 - github.com/sony/gobreaker v0.5.0 - github.com/stretchr/testify v1.10.0 - go.opentelemetry.io/otel v1.35.0 -) - -require go.uber.org/atomic v1.11.0 // indirect - -require ( - github.com/DataDog/appsec-internal-go v1.13.0 // indirect - github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/proto v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/trace v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/util/log v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/version v0.66.1 // indirect - github.com/DataDog/go-libddwaf/v4 v4.3.0 // indirect - github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a // indirect - github.com/DataDog/go-sqllexer v0.1.6 // indirect - github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect - github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0 // indirect - github.com/DataDog/sketches-go v1.4.7 // indirect - github.com/Masterminds/semver/v3 v3.3.1 // indirect - github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/andybalholm/brotli v1.1.0 // indirect - github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect - github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect - github.com/aws/smithy-go v1.19.0 // indirect - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect - github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect - github.com/dustin/go-humanize v1.0.1 // indirect - github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 // indirect - github.com/ebitengine/purego v0.8.3 // indirect - github.com/go-logr/logr v1.4.2 // indirect - github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-ole/go-ole v1.3.0 // indirect - github.com/go-viper/mapstructure/v2 v2.2.1 // indirect - github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/protobuf v1.5.4 // indirect - github.com/google/uuid v1.6.0 // indirect - github.com/json-iterator/go v1.1.12 // indirect - github.com/klauspost/compress v1.18.0 // indirect - github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a // indirect - github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.2 // indirect - github.com/outcaste-io/ristretto v0.2.3 // indirect - github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect - github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect - github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect - github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect - github.com/shirou/gopsutil/v4 v4.25.1 // indirect - github.com/tinylib/msgp v1.2.5 // indirect - github.com/tklauser/go-sysconf v0.3.14 // indirect - github.com/tklauser/numcpus v0.8.0 // indirect - github.com/valyala/bytebufferpool v1.0.0 // indirect - github.com/valyala/fasthttp v1.52.0 // indirect - github.com/yusufpapurcu/wmi v1.2.4 // indirect - go.opentelemetry.io/auto/sdk v1.1.0 // indirect - go.opentelemetry.io/collector/component v1.28.1 // indirect - go.opentelemetry.io/collector/pdata v1.28.1 // indirect - go.opentelemetry.io/collector/pdata/pprofile v0.122.1 // indirect - go.opentelemetry.io/collector/semconv v0.122.1 // indirect - go.opentelemetry.io/otel/metric v1.35.0 // indirect - go.opentelemetry.io/otel/trace v1.35.0 // indirect - go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.27.0 // indirect - golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac // indirect - golang.org/x/mod v0.23.0 // indirect - golang.org/x/net v0.39.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.24.0 // indirect - golang.org/x/time v0.11.0 // indirect - golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 // indirect - google.golang.org/grpc v1.71.1 // indirect - google.golang.org/protobuf v1.36.6 // indirect - gopkg.in/ini.v1 v1.67.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect -) +github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= +github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= +github.com/DataDog/appsec-internal-go v1.13.0 h1:aO6DmHYsAU8BNFuvYJByhMKGgcQT3WAbj9J/sgAJxtA= +github.com/DataDog/appsec-internal-go v1.13.0/go.mod h1:9YppRCpElfGX+emXOKruShFYsdPq7WEPq/Fen4tYYpk= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1 h1:tUnckL/NqYQiSN4ceOe5E/qM9vxmU3p77RdHgXC3VNE= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1/go.mod h1:u/ZS2pzrBQ1LokbEvFULjn1SfX+If31uqtz6MJ7UaFo= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1 h1:sZEua4ArlPJyn8DxpIw85iYuDSmCXp1h/utS4jHj8Lo= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1/go.mod h1:NH6IHfS2BEWP3i8JBxr6EIuD4TXprGny8dJZZs5QdwQ= +github.com/DataDog/datadog-agent/pkg/proto v0.66.1 h1:Uqg1gcYDI3RktFr599PWwF05FOEQQgbPMvE9oTSi8NA= +github.com/DataDog/datadog-agent/pkg/proto v0.66.1/go.mod h1:W81BWdx7VxgdshvJuyZhDfWWwJAHROEi4yXX25yzX5A= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1 h1:hA8dg5pgpUXEKFBhcrcb+U6r9h1q3hy+6jYqeC3rZX8= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1/go.mod h1:/AzUUTZn8FZj3xUFJxMh/0/NPqpjsv2z+IMXG/IxRFc= +github.com/DataDog/datadog-agent/pkg/trace v0.66.1 h1:MuZqPlRLEF3dPKtGbn4H4cvdfLIQRncZft6JUtAwy5I= +github.com/DataDog/datadog-agent/pkg/trace v0.66.1/go.mod h1:S+GWyA8N6JT/DHi08xt63kn957wPZs0Kg5ClaY2FPgc= +github.com/DataDog/datadog-agent/pkg/util/log v0.66.1 h1:QE97RJCDO2ZplOqlQM2Oq3S/JKDpI3okdpj+y6rmncU= +github.com/DataDog/datadog-agent/pkg/util/log v0.66.1/go.mod h1:TBGT1NFg9Essf3ypyegWT74PKbIzTuHAHM9V3B+3vXY= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1 h1:K7b6+7ZxrC8mvgMJNpCzCshmNUMEkAWRrNWQZvHVIh8= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1/go.mod h1:1ebZZr2A/0LnD76aK+m1leTOAjKVkJUjCvaw+wTQEcI= +github.com/DataDog/datadog-agent/pkg/version v0.66.1 h1:8eJdgkO/o4/5RlF3u29j0QO8eotaqE+fwKOkIHNJ8RY= +github.com/DataDog/datadog-agent/pkg/version v0.66.1/go.mod h1:LXOHXAHH+vqBwmQKcZa5FgBEi4ECKIC2WsV2Jd9VVJ0= +github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= +github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= +github.com/DataDog/dd-trace-go/v2 v2.1.0 h1:hnwcE5qwj/sPbi+GW0O8UDQx5sNCRBwF4m4QRlgWMDA= +github.com/DataDog/dd-trace-go/v2 v2.1.0/go.mod h1:W1W3dR5b77xwozt/o9JqLGh1cdhydIQOHIfzcyQVHVs= +github.com/DataDog/go-libddwaf/v4 v4.3.0 h1:BZfKyLSbY2YMSn7hEBFN1qlDXI2rMEquOeTiRbSg4xk= +github.com/DataDog/go-libddwaf/v4 v4.3.0/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a h1:+tlbkP/WtD+t0ZDoXIkvqeCd5kj8sl5jN/POUhqFNS8= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a/go.mod h1:quaQJ+wPN41xEC458FCpTwyROZm3MzmTZ8q8XOXQiPs= +github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= +github.com/DataDog/go-sqllexer v0.1.6/go.mod h1:GGpo1h9/BVSN+6NJKaEcJ9Jn44Hqc63Rakeb+24Mjgo= +github.com/DataDog/go-tuf v1.1.0-0.5.2 h1:4CagiIekonLSfL8GMHRHcHudo1fQnxELS9g4tiAupQ4= +github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= +github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0 h1:GlvoS6hJN0uANUC3fjx72rOgM4StAKYo2HtQGaasC7s= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0/go.mod h1:mYQmU7mbHH6DrCaS8N6GZcxwPoeNfyuopUoLQltwSzs= +github.com/DataDog/sketches-go v1.4.7 h1:eHs5/0i2Sdf20Zkj0udVFWuCrXGRFig2Dcfm5rtcTxc= +github.com/DataDog/sketches-go v1.4.7/go.mod h1:eAmQ/EBmtSO+nQp7IZMZVRPT4BQTmIc5RZQ+deGlTPM= +github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= +github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= +github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= +github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= +github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= +github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= +github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= +github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= +github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= +github.com/aws/aws-sdk-go-v2/config v1.26.6/go.mod h1:uKU6cnDmYCvJ+pxO9S4cWDb2yWWIH5hra+32hVh1MI4= +github.com/aws/aws-sdk-go-v2/credentials v1.16.16 h1:8q6Rliyv0aUFAVtzaldUEcS+T5gbadPbWdV1WcAddK8= +github.com/aws/aws-sdk-go-v2/credentials v1.16.16/go.mod h1:UHVZrdUsv63hPXFo1H7c5fEneoVo9UXiz36QG1GEPi0= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 h1:c5I5iH+DZcH3xOIMlz3/tCKJDaHFwYEmxvlh2fAcFo8= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11/go.mod h1:cRrYDYAMUohBJUtUnOhydaMHtiK/1NZ0Otc9lIb6O0Y= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 h1:n3GDfwqF2tzEkXlv5cuy4iy7LpKDtqDMcNLfZDu9rls= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 h1:DBYTXwIGQSGs9w4jKm60F5dmCQ3EEruxdc0MFh+3EY4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10/go.mod h1:wohMUQiFdzo0NtxbBg0mSRGZ4vL3n0dKjLTINdcIino= +github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 h1:W9PbZAZAEcelhhjb7KuwUtf+Lbc+i7ByYJRuWLlnxyQ= +github.com/aws/aws-sdk-go-v2/service/kms v1.27.9/go.mod h1:2tFmR7fQnOdQlM2ZCEPpFnBIQD1U8wmXmduBgZbOag0= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 h1:eajuO3nykDPdYicLlP3AGgOyVN3MOlFmZv7WGTuJPow= +github.com/aws/aws-sdk-go-v2/service/sso v1.18.7/go.mod h1:+mJNDdF+qiUlNKNC3fxn74WWNN+sOiGOEImje+3ScPM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w1NmfkfiSK8mS4zOx3BA= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= +github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= +github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= +github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= +github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= +github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 h1:kHaBemcxl8o/pQ5VM1c8PVE1PubbNx3mjUr09OqWGCs= +github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575/go.mod h1:9d6lWj8KzO/fd/NrVaLscBKmPigpZpn5YawRPw+e3Yo= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y= +github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= +github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg= +github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds= +github.com/ebitengine/purego v0.8.3 h1:K+0AjQp63JEZTEMZiwsI9g0+hAMNohwUOtY0RPGexmc= +github.com/ebitengine/purego v0.8.3/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss= +github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/mock v1.7.0-rc.1 h1:YojYx61/OLFsiv6Rw1Z96LpldJIy31o+UHmwAUMJ6/U= +github.com/golang/mock v1.7.0-rc.1/go.mod h1:s42URUywIqd+OcERslBJvOjepvNymP31m3q8d/GkuRs= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a h1:3Bm7EwfUQUvhNeKIkUct/gl9eod1TcXuj8stxvi/GoI= +github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.122.0 h1:n0nWcGanaHanlih+YRp8etj1/fYZoQFRk+7+/J85dpU= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.122.0/go.mod h1:MMvJIC26DIEZo5DR4Ub/WJD1aPVxKGpgJolXxTtjgLE= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.122.0 h1:zuqwUU8P+IqQMHvMYHlTBXt8lRn1Zu2B9QNAscLP+9A= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.122.0/go.mod h1:vtHjtQU0UlTHBthmnTv8nK0h0GFWQhgxtOVbav87YoU= +github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= +github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg= +github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA= +github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= +github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/secure-systems-lab/go-securesystemslib v0.9.0 h1:rf1HIbL64nUpEIZnjLZ3mcNEL9NBPB0iuVjyxvq3LZc= +github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/woA/peqr+L0joiRXbPpQ042GgJckkFgw= +github.com/shirou/gopsutil/v4 v4.25.1 h1:QSWkTc+fu9LTAWfkZwZ6j8MSUk4A2LV7rbH0ZqmLjXs= +github.com/shirou/gopsutil/v4 v4.25.1/go.mod h1:RoUCUpndaJFtT+2zsZzzmhvbfGoDCJ7nFXKJf8GqJbI= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= +github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= +github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= +github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= +github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= +github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= +github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= +github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= +github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= +github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= +github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= +github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/collector/component v1.28.1 h1:JjwfvLR0UdadRDAANAdM4mOSwGmfGO3va2X+fdk4YdA= +go.opentelemetry.io/collector/component v1.28.1/go.mod h1:jwZRDML3tXo1whueZdRf+y6z3DeEYTLPBmb/O1ujB40= +go.opentelemetry.io/collector/component/componentstatus v0.122.1 h1:zMQC0y8ZBITa87GOwEANdOoAox5I4UgaIHxY79nwCbk= +go.opentelemetry.io/collector/component/componentstatus v0.122.1/go.mod h1:ZYwOgoXyPu4gGqfQ5DeaEpStpUCD/Clctz4rMd9qQYw= +go.opentelemetry.io/collector/component/componenttest v0.122.1 h1:HE4oeLub2FWVTUzCQG6SWwfnJfcK1FMknXhGQ2gOxnY= +go.opentelemetry.io/collector/component/componenttest v0.122.1/go.mod h1:o3Xq6z3C0aVhrd/fD56aKxShrILVnHnbgQVP5NoFuic= +go.opentelemetry.io/collector/consumer v1.28.1 h1:3lHW2e0i7kEkbDqK1vErA8illqPpwDxMzgc5OUDsJ0Y= +go.opentelemetry.io/collector/consumer v1.28.1/go.mod h1:g0T16JPMYFN6T2noh+1YBxJSt5i5Zp+Y0Y6pvkMqsDQ= +go.opentelemetry.io/collector/consumer/consumertest v0.122.1 h1:LKkLMdWwJCuOYyCMVzwc0OG9vncIqpl8Tp9+H8RikNg= +go.opentelemetry.io/collector/consumer/consumertest v0.122.1/go.mod h1:pYqWgx62ou3uUn8nlt2ohRyKod+7xLTf/uA3YfRwVkA= +go.opentelemetry.io/collector/consumer/xconsumer v0.122.1 h1:iK1hGbho/XICdBfGb4MnKwF9lnhLmv09yQ4YlVm+LGo= +go.opentelemetry.io/collector/consumer/xconsumer v0.122.1/go.mod h1:xYbRPP1oWcYUUDQJTlv78M/rlYb+qE4weiv++ObZRSU= +go.opentelemetry.io/collector/pdata v1.28.1 h1:ORl5WLpQJvjzBVpHu12lqKMdcf/qDBwRXMcUubhybiQ= +go.opentelemetry.io/collector/pdata v1.28.1/go.mod h1:asKE8MD/4SOKz1mCrGdAz4VO2U2HUNg8A6094uK7pq0= +go.opentelemetry.io/collector/pdata/pprofile v0.122.1 h1:25Fs0eL/J/M2ZEaVplesbI1H7pYx462zUUVxVOszpOg= +go.opentelemetry.io/collector/pdata/pprofile v0.122.1/go.mod h1:+jSjgb4zRnNmr1R/zgVLVyTVSm9irfGrvGTrk3lDxSE= +go.opentelemetry.io/collector/pdata/testdata v0.122.1 h1:9DO8nUUnPAGYMKmrep6wLAfOHprvKY4w/7LpE4jldPQ= +go.opentelemetry.io/collector/pdata/testdata v0.122.1/go.mod h1:hYdNrn8KxFwq1nf44YYRgNhDjJTBzoyEr/Qa26pN0t4= +go.opentelemetry.io/collector/pipeline v0.122.1 h1:f0uuiDmanVyKwfYo6cWveJsGbLXidV7i+Z7u8QJwWxI= +go.opentelemetry.io/collector/pipeline v0.122.1/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= +go.opentelemetry.io/collector/processor v0.122.1 h1:AvZvEujq8+FYdJsm9lmAMwuuae5Y2/vKIkOJwsoxsxQ= +go.opentelemetry.io/collector/processor v0.122.1/go.mod h1:nYKctftba7SbdLml6LxgIrnYRXCShDe2bnNWjTIpF7g= +go.opentelemetry.io/collector/processor/processortest v0.122.1 h1:n4UOx1mq+kLaRiHGsu7vBLq+EGXfzWhSxyFweMjMl54= +go.opentelemetry.io/collector/processor/processortest v0.122.1/go.mod h1:8/NRWx18tNJMBwCQ8/YPWr4qsFUrwk27qE7/dXoJb1M= +go.opentelemetry.io/collector/processor/xprocessor v0.122.1 h1:Wfv4/7n4YK1HunAVTMS6yf0xmDjCkftJ6EECNcSwzfs= +go.opentelemetry.io/collector/processor/xprocessor v0.122.1/go.mod h1:9zMW3NQ9+DzcJ1cUq5BhZg3ajoUEMGhNY0ZdYjpX+VI= +go.opentelemetry.io/collector/semconv v0.122.1 h1:WLzDi3QC4/+LpNMLY90zn5aMDJKyqg/ujW2O4T4sxHg= +go.opentelemetry.io/collector/semconv v0.122.1/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= +go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= +go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= +go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= +go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= +go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= +go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= +go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o= +go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= +go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs= +go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE= +golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc= +golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac h1:l5+whBCLH3iH2ZNHYLbAe58bo7yrN4mVcnkHDYz5vvs= +golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac/go.mod h1:hH+7mtFmImwwcMvScyxUhjuVHR3HGaDPMn9rMSUUbxo= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM= +golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY= +golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0= +golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU= +golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= +golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 h1:ZSlhAUqC4r8TPzqLXQ0m3upBNZeF+Y8jQ3c4CR3Ujms= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99/go.mod h1:LuRYeWDFV6WOn90g357N17oMCaxpgCnbi/44qJvDn2I= +google.golang.org/grpc v1.71.1 h1:ffsFWr7ygTUscGPI0KKK6TLrGz0476KUvvsbqWK0rPI= +google.golang.org/grpc v1.71.1/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +k8s.io/apimachinery v0.31.4 h1:8xjE2C4CzhYVm9DGf60yohpNUh5AEBnPxCryPBECmlM= +k8s.io/apimachinery v0.31.4/go.mod h1:rsPdaZJfTfLsNJSQzNHQvYoTmxhoOEofxtOsF3rtsMo= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod index a9877557e7..1d75c29865 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod @@ -1,6 +1,6 @@ module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/lambdatest/error -go 1.24 +go 1.24.0 require ( github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go v0.0.0-00010101000000-000000000000 @@ -8,17 +8,25 @@ require ( ) require ( - github.com/DataDog/appsec-internal-go v1.9.0 // indirect - github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0 // indirect - github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0 // indirect - github.com/DataDog/datadog-go/v5 v5.5.0 // indirect - github.com/DataDog/go-libddwaf/v3 v3.5.1 // indirect - github.com/DataDog/go-sqllexer v0.0.14 // indirect + github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/proto v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 // indirect + github.com/DataDog/datadog-agent/pkg/trace v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/version v0.67.0 // indirect + github.com/DataDog/datadog-go/v5 v5.6.0 // indirect + github.com/DataDog/dd-trace-go/v2 v2.1.0 // indirect + github.com/DataDog/go-libddwaf/v4 v4.3.2 // indirect + github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 // indirect + github.com/DataDog/go-sqllexer v0.1.6 // indirect github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect - github.com/DataDog/sketches-go v1.4.5 // indirect - github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect + github.com/DataDog/sketches-go v1.4.7 // indirect + github.com/Masterminds/semver/v3 v3.3.1 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect github.com/andybalholm/brotli v1.1.0 // indirect - github.com/aws/aws-sdk-go v1.50.9 // indirect github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect @@ -32,42 +40,71 @@ require ( github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect - github.com/aws/aws-xray-sdk-go v1.8.3 // indirect + github.com/aws/aws-xray-sdk-go/v2 v2.0.0 // indirect github.com/aws/smithy-go v1.19.0 // indirect github.com/cenkalti/backoff/v4 v4.2.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/ebitengine/purego v0.6.0-alpha.5 // indirect - github.com/go-logr/logr v1.4.1 // indirect + github.com/ebitengine/purego v0.8.3 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect + github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/jmespath/go-jmespath v0.4.0 // indirect - github.com/klauspost/compress v1.17.6 // indirect + github.com/hashicorp/go-version v1.7.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/outcaste-io/ristretto v0.2.3 // indirect - github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986 // indirect + github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/secure-systems-lab/go-securesystemslib v0.8.0 // indirect + github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect + github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect + github.com/shirou/gopsutil/v4 v4.25.3 // indirect github.com/sony/gobreaker v0.5.0 // indirect - github.com/tinylib/msgp v1.2.1 // indirect + github.com/theckman/httpforwarded v0.4.0 // indirect + github.com/tinylib/msgp v1.2.5 // indirect + github.com/tklauser/go-sysconf v0.3.14 // indirect + github.com/tklauser/numcpus v0.9.0 // indirect github.com/valyala/bytebufferpool v1.0.0 // indirect github.com/valyala/fasthttp v1.52.0 // indirect - go.opentelemetry.io/otel v1.27.0 // indirect - go.opentelemetry.io/otel/metric v1.27.0 // indirect - go.opentelemetry.io/otel/trace v1.27.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/collector/component v1.31.0 // indirect + go.opentelemetry.io/collector/featuregate v1.31.0 // indirect + go.opentelemetry.io/collector/internal/telemetry v0.125.0 // indirect + go.opentelemetry.io/collector/pdata v1.31.0 // indirect + go.opentelemetry.io/collector/semconv v0.125.0 // indirect + go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 // indirect + go.opentelemetry.io/otel v1.35.0 // indirect + go.opentelemetry.io/otel/log v0.11.0 // indirect + go.opentelemetry.io/otel/metric v1.35.0 // indirect + go.opentelemetry.io/otel/sdk v1.35.0 // indirect + go.opentelemetry.io/otel/trace v1.35.0 // indirect go.uber.org/atomic v1.11.0 // indirect - golang.org/x/mod v0.20.0 // indirect - golang.org/x/net v0.33.0 // indirect - golang.org/x/sys v0.28.0 // indirect - golang.org/x/text v0.21.0 // indirect - golang.org/x/time v0.6.0 // indirect - golang.org/x/tools v0.24.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.40.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/text v0.26.0 // indirect + golang.org/x/time v0.11.0 // indirect golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5 // indirect - google.golang.org/grpc v1.64.1 // indirect - google.golang.org/protobuf v1.34.2 // indirect - gopkg.in/DataDog/dd-trace-go.v1 v1.72.1 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 // indirect + google.golang.org/grpc v1.72.0 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) replace github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go => ../../ -replace github.com/DataDog/dd-trace-go/v2 => ../../../../../ + +replace github.com/DataDog/dd-trace-go/v2 => ../../../../.. diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum b/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum index 2aeebb7710..b78bf03702 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum @@ -1,38 +1,46 @@ -github.com/DATA-DOG/go-sqlmock v1.4.1 h1:ThlnYciV1iM/V0OSF/dtkqWb6xo5qITT1TJBG1MRDJM= -github.com/DATA-DOG/go-sqlmock v1.4.1/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= -github.com/DataDog/appsec-internal-go v1.6.0 h1:QHvPOv/O0s2fSI/BraZJNpRDAtdlrRm5APJFZNBxjAw= -github.com/DataDog/appsec-internal-go v1.6.0/go.mod h1:pEp8gjfNLtEOmz+iZqC8bXhu0h4k7NUsW/qiQb34k1U= -github.com/DataDog/appsec-internal-go v1.9.0/go.mod h1:wW0cRfWBo4C044jHGwYiyh5moQV2x0AhnwqMuiX7O/g= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 h1:y08IzbpFM/HBaKfgayFZe1FpcbZn6bVPXoZ++93vxv8= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2/go.mod h1:A4nLJvxlg6BO/8/zg81til9yT0uRPuXDFMAzDMpmgn4= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0/go.mod h1:MfDvphBMmEMwE3a30h27AtPO7OzmvdoVTiGY1alEmo4= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 h1:7jn5EOu84uph4sd+pB3vF8LnsdTjhh+1/NnCvfNpG4A= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2/go.mod h1:Vc+snp0Bey4MrrJyiV2tVxxJb6BmLomPvN1RgAvjGaQ= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0/go.mod h1:jN5BsZI+VilHJV1Wac/efGxS4TPtXa1Lh9SiUyv93F4= -github.com/DataDog/datadog-go/v5 v5.5.0 h1:G5KHeB8pWBNXT4Jtw0zAkhdxEAWSpWH00geHI6LDrKU= -github.com/DataDog/datadog-go/v5 v5.5.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/go-libddwaf/v3 v3.2.1 h1:lZPc6UxCOwioHc++nsldKR50FpIrRh1uGnGLuryqnE8= -github.com/DataDog/go-libddwaf/v3 v3.2.1/go.mod h1:AP+7Atb8ftSsrha35wht7+K3R+xuzfVSQhabSO4w6CY= -github.com/DataDog/go-libddwaf/v3 v3.5.1/go.mod h1:n98d9nZ1gzenRSk53wz8l6d34ikxS+hs62A31Fqmyi4= -github.com/DataDog/go-sqllexer v0.0.10 h1:u07DuRfdlPPmOX/dclb1gcn/zaqWxUiURRRVenKILxc= -github.com/DataDog/go-sqllexer v0.0.10/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= -github.com/DataDog/go-sqllexer v0.0.14/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= -github.com/DataDog/go-tuf v1.0.2-0.5.2 h1:EeZr937eKAWPxJ26IykAdWA4A0jQXJgkhUjqEI/w7+I= -github.com/DataDog/go-tuf v1.0.2-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= +github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0/go.mod h1:1oPcs3BUTQhiTkmk789rb7ob105MxNV6OuBa28BdukQ= +github.com/DataDog/datadog-agent/pkg/proto v0.67.0 h1:7dO6mKYRb7qSiXEu7Q2mfeKbhp4hykCAULy4BfMPmsQ= +github.com/DataDog/datadog-agent/pkg/proto v0.67.0/go.mod h1:bKVXB7pxBg0wqXF6YSJ+KU6PeCWKDyJj83kUH1ab+7o= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 h1:/DsN4R+IkC6t1+4cHSfkxzLtDl84rBbPC5Wa9srBAoM= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0/go.mod h1:Th2LD/IGid5Rza55pzqGu6nUdOv/Rts6wPwLjTyOSTs= +github.com/DataDog/datadog-agent/pkg/trace v0.67.0 h1:dqt+/nObo0JKyaEqIMZgfqGZbx9TfEHpCkrjQ/zzH7k= +github.com/DataDog/datadog-agent/pkg/trace v0.67.0/go.mod h1:zmZoEtKvOnaKHbJGBKH3a4xuyPrSfBaF0ZE3Q3rCoDw= +github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 h1:xrH15QNqeJZkYoXYi44VCIvGvTwlQ3z2iT2QVTGiT7s= +github.com/DataDog/datadog-agent/pkg/util/log v0.67.0/go.mod h1:dfVLR+euzEyg1CeiExgJQq1c1dod42S6IeiRPj8H7Yk= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 h1:aIWF85OKxXGo7rVyqJ7jm7lm2qCQrgyXzYyFuw0T2EQ= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0/go.mod h1:Lfap5FuM4b/Pw9IrTuAvWBWZEmXOvZhCya3dYv4G8O0= +github.com/DataDog/datadog-agent/pkg/version v0.67.0 h1:TB8H8r+laB1Qdttvvc6XJVyLGxp8E6j2f2Mh5IPbYmQ= +github.com/DataDog/datadog-agent/pkg/version v0.67.0/go.mod h1:kvAw/WbI7qLAsDI2wHabZfM7Cv2zraD3JA3323GEB+8= +github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= +github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= +github.com/DataDog/go-libddwaf/v4 v4.3.2 h1:YGvW2Of1C4e1yU+p7iibmhN2zEOgi9XEchbhQjBxb/A= +github.com/DataDog/go-libddwaf/v4 v4.3.2/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 h1:ZRLR9Lbym748e8RznWzmSoK+OfV+8qW6SdNYA4/IqdA= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633/go.mod h1:YFoTl1xsMzdSRFIu33oCSPS/3+HZAPGpO3oOM96wXCM= +github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= +github.com/DataDog/go-sqllexer v0.1.6/go.mod h1:GGpo1h9/BVSN+6NJKaEcJ9Jn44Hqc63Rakeb+24Mjgo= +github.com/DataDog/go-tuf v1.1.0-0.5.2 h1:4CagiIekonLSfL8GMHRHcHudo1fQnxELS9g4tiAupQ4= github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= -github.com/DataDog/sketches-go v1.4.5 h1:ki7VfeNz7IcNafq7yI/j5U/YCkO3LJiMDtXz9OMQbyE= -github.com/DataDog/sketches-go v1.4.5/go.mod h1:7Y8GN8Jf66DLyDhc94zuWA3uHEt/7ttt8jHOBWWrSOg= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 h1:5US5SqqhfkZkg/E64uvn7YmeTwnudJHtlPEH/LOT99w= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0/go.mod h1:VRo4D6rj92AExpVBlq3Gcuol9Nm1bber12KyxRjKGWw= +github.com/DataDog/sketches-go v1.4.7 h1:eHs5/0i2Sdf20Zkj0udVFWuCrXGRFig2Dcfm5rtcTxc= +github.com/DataDog/sketches-go v1.4.7/go.mod h1:eAmQ/EBmtSO+nQp7IZMZVRPT4BQTmIc5RZQ+deGlTPM= +github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= +github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= -github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= -github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= -github.com/aws/aws-sdk-go v1.50.9 h1:yX66aKnEtRc/uNV/1EH8CudRT5aLwVwcSwTBphuVPt8= -github.com/aws/aws-sdk-go v1.50.9/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= @@ -59,90 +67,107 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= -github.com/aws/aws-xray-sdk-go v1.8.3 h1:S8GdgVncBRhzbNnNUgTPwhEqhwt2alES/9rLASyhxjU= -github.com/aws/aws-xray-sdk-go v1.8.3/go.mod h1:tv8uLMOSCABolrIF8YCcp3ghyswArsan8dfLCA1ZATk= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= -github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 h1:kHaBemcxl8o/pQ5VM1c8PVE1PubbNx3mjUr09OqWGCs= +github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575/go.mod h1:9d6lWj8KzO/fd/NrVaLscBKmPigpZpn5YawRPw+e3Yo= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc= -github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg= -github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds= -github.com/ebitengine/purego v0.6.0-alpha.5 h1:EYID3JOAdmQ4SNZYJHu9V6IqOeRQDBYxqKAg9PyoHFY= -github.com/ebitengine/purego v0.6.0-alpha.5/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ= -github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk= -github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/ebitengine/purego v0.8.3 h1:K+0AjQp63JEZTEMZiwsI9g0+hAMNohwUOtY0RPGexmc= +github.com/ebitengine/purego v0.8.3/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= -github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= -github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/mock v1.7.0-rc.1 h1:YojYx61/OLFsiv6Rw1Z96LpldJIy31o+UHmwAUMJ6/U= +github.com/golang/mock v1.7.0-rc.1/go.mod h1:s42URUywIqd+OcERslBJvOjepvNymP31m3q8d/GkuRs= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b h1:h9U78+dx9a4BKdQkBBos92HalKpaGKHrp+3Uo6yTodo= -github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= -github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7 h1:UpiO20jno/eV1eVZcxqWnUohyKRe1g8FPV/xH1s/2qs= -github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7/go.mod h1:QmrqtbKuxxSWTN3ETMPuB+VtEiBJ/A9XhoYGv8E1uD8= -github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 h1:kes8mmyCpxJsI7FTwtzRqEy9CdjCtrXrXGuOpxEA7Ts= -github.com/hashicorp/go-secure-stdlib/strutil v0.1.2/go.mod h1:Gou2R9+il93BqX25LAKCLuM+y9U2T4hlwvT1yprcna4= -github.com/hashicorp/go-sockaddr v1.0.2 h1:ztczhD1jLxIRjVejw8gFomI1BQZOe2WoVOu0SyteCQc= -github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A= -github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= -github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= -github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= -github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= -github.com/klauspost/compress v1.17.5 h1:d4vBd+7CHydUqpFBgUEKkSdtSugf9YFmSkvUYPquI5E= -github.com/klauspost/compress v1.17.5/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= -github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= -github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= +github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= +github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= -github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0= +github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0 h1:0dOJCEtabevxxDQmxed69oMzSw+gb3ErCnFwFYZFu0M= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0/go.mod h1:QwzQhtxPThXMUDW1XRXNQ+l0GrI2BRsvNhX6ZuKyAds= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0 h1:F68/Nbpcvo3JZpaWlRUDJtG7xs8FHBZ7A8GOMauDkyc= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0/go.mod h1:haO4cJtAk05Y0p7NO9ME660xxtSh54ifCIIT7+PO9C0= github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= -github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw= -github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0= -github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg= +github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA= github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= -github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk= -github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= -github.com/secure-systems-lab/go-securesystemslib v0.8.0 h1:mr5An6X45Kb2nddcFlbmfHkLguCE9laoZCUzEEpIZXA= -github.com/secure-systems-lab/go-securesystemslib v0.8.0/go.mod h1:UH2VZVuJfCYR8WgMlCU1uFsOUU+KeyrTWcSS73NBOzU= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/secure-systems-lab/go-securesystemslib v0.9.0 h1:rf1HIbL64nUpEIZnjLZ3mcNEL9NBPB0iuVjyxvq3LZc= +github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/woA/peqr+L0joiRXbPpQ042GgJckkFgw= +github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= +github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= @@ -151,113 +176,168 @@ github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.1 h1:4VhoImhV/Bm0ToFkXFi8hXNXwpDRZ/ynw3amt82mzq0= -github.com/stretchr/objx v0.5.1/go.mod h1:/iHQpkQwBD6DLUmQ4pE+s1TXdob1mORJ4/UFdrifcy0= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/tinylib/msgp v1.1.9 h1:SHf3yoO2sGA0veCJeCBYLHuttAVFHGm2RHgNodW7wQU= -github.com/tinylib/msgp v1.1.9/go.mod h1:BCXGB54lDD8qUEPmiG0cQQUANC4IUQyB2ItS2UDlO/k= -github.com/tinylib/msgp v1.2.1/go.mod h1:2vIGs3lcUo8izAATNobrCHevYZC/LMsJtw4JPiYPHro= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/theckman/httpforwarded v0.4.0 h1:N55vGJT+6ojTnLY3LQCNliJC4TW0P0Pkeys1G1WpX2w= +github.com/theckman/httpforwarded v0.4.0/go.mod h1:GVkFynv6FJreNbgH/bpOU9ITDZ7a5WuzdNCtIMI1pVI= +github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= +github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= +github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= +github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= +github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA= -github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g= +github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= +github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= +github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= +github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= +github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0 h1:KfYpVmrjI7JuToy5k8XV3nkapjWx48k4E4JOtVstzQI= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0/go.mod h1:SeQhzAEccGVZVEy7aH87Nh0km+utSpo1pTv6eMMop48= -go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= -go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= -go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ= -go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= -go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= -go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak= -go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= -go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= -go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/collector/component v1.31.0 h1:9LzU8X1RhV3h8/QsAoTX23aFUfoJ3EUc9O/vK+hFpSI= +go.opentelemetry.io/collector/component v1.31.0/go.mod h1:JbZl/KywXJxpUXPbt96qlEXJSym1zQ2hauMxYMuvlxM= +go.opentelemetry.io/collector/component/componentstatus v0.125.0 h1:zlxGQZYd9kknRZSjRpOYW5SBjl0a5zYFYRPbreobXoU= +go.opentelemetry.io/collector/component/componentstatus v0.125.0/go.mod h1:bHXc2W8bqqo9adOvCgvhcO7pYzJOSpyV4cuQ1wiIl04= +go.opentelemetry.io/collector/component/componenttest v0.125.0 h1:E2mpnMQbkMpYoZ3Q8pHx4kod7kedjwRs1xqDpzCe/84= +go.opentelemetry.io/collector/component/componenttest v0.125.0/go.mod h1:pQtsE1u/SPZdTphP5BZP64XbjXSq6wc+mDut5Ws/JDI= +go.opentelemetry.io/collector/consumer v1.31.0 h1:L+y66ywxLHnAxnUxv0JDwUf5bFj53kMxCCyEfRKlM7s= +go.opentelemetry.io/collector/consumer v1.31.0/go.mod h1:rPsqy5ni+c6xNMUkOChleZYO/nInVY6eaBNZ1FmWJVk= +go.opentelemetry.io/collector/consumer/consumertest v0.125.0 h1:TUkxomGS4DAtjBvcWQd2UY4FDLLEKMQD6iOIDUr/5dM= +go.opentelemetry.io/collector/consumer/consumertest v0.125.0/go.mod h1:vkHf3y85cFLDHARO/cTREVjLjOPAV+cQg7lkC44DWOY= +go.opentelemetry.io/collector/consumer/xconsumer v0.125.0 h1:oTreUlk1KpMSWwuHFnstW+orrjGTyvs2xd3o/Dpy+hI= +go.opentelemetry.io/collector/consumer/xconsumer v0.125.0/go.mod h1:FX0G37r0W+wXRgxxFtwEJ4rlsCB+p0cIaxtU3C4hskw= +go.opentelemetry.io/collector/featuregate v1.31.0 h1:20q7plPQZwmAiaYAa6l1m/i2qDITZuWlhjr4EkmeQls= +go.opentelemetry.io/collector/featuregate v1.31.0/go.mod h1:Y/KsHbvREENKvvN9RlpiWk/IGBK+CATBYzIIpU7nccc= +go.opentelemetry.io/collector/internal/telemetry v0.125.0 h1:6lcGOxw3dAg7LfXTKdN8ZjR+l7KvzLdEiPMhhLwG4r4= +go.opentelemetry.io/collector/internal/telemetry v0.125.0/go.mod h1:5GyFslLqjZgq1DZTtFiluxYhhXrCofHgOOOybodDPGE= +go.opentelemetry.io/collector/pdata v1.31.0 h1:P5WuLr1l2JcIvr6Dw2hl01ltp2ZafPnC4Isv+BLTBqU= +go.opentelemetry.io/collector/pdata v1.31.0/go.mod h1:m41io9nWpy7aCm/uD1L9QcKiZwOP0ldj83JEA34dmlk= +go.opentelemetry.io/collector/pdata/pprofile v0.125.0 h1:Qqlx8w1HpiYZ9RQqjmMQIysI0cHNO1nh3E/fCTeFysA= +go.opentelemetry.io/collector/pdata/pprofile v0.125.0/go.mod h1:p/yK023VxAp8hm27/1G5DPTcMIpnJy3cHGAFUQZGyaQ= +go.opentelemetry.io/collector/pdata/testdata v0.125.0 h1:due1Hl0EEVRVwfCkiamRy5E8lS6yalv0lo8Zl/SJtGw= +go.opentelemetry.io/collector/pdata/testdata v0.125.0/go.mod h1:1GpEWlgdMrd+fWsBk37ZC2YmOP5YU3gFQ4rWuCu9g24= +go.opentelemetry.io/collector/pipeline v0.125.0 h1:oitBgcAFqntDB4ihQJUHJSQ8IHqKFpPkaTVbTYdIUzM= +go.opentelemetry.io/collector/pipeline v0.125.0/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= +go.opentelemetry.io/collector/processor v1.31.0 h1:+u7sBUpnCBsHYoALp4hfr9VEjLHHYa4uKENGITe0K9Q= +go.opentelemetry.io/collector/processor v1.31.0/go.mod h1:5hDYJ7/hTdfd2tF2Rj5Hs6+mfyFz2O7CaPzVvW1qHQc= +go.opentelemetry.io/collector/processor/processorhelper v0.125.0 h1:QRpX7oFW88DAZhy+Q93npklRoaQr8ue0GKpeup7C/Fk= +go.opentelemetry.io/collector/processor/processorhelper v0.125.0/go.mod h1:oXRvslUuN62wErcoJrcEJYoTXu5wHyNyJsE+/a9Cc9s= +go.opentelemetry.io/collector/processor/processortest v0.125.0 h1:ZVAN4iZPDcWhpzKqnuok2NIuS5hwGVVQUOWkJFR12tA= +go.opentelemetry.io/collector/processor/processortest v0.125.0/go.mod h1:VAw0IRG35cWTBjBtreXeXJEgqkRegfjrH/EuLhNX2+I= +go.opentelemetry.io/collector/processor/xprocessor v0.125.0 h1:VWYPMW1VmDq6xB7M5SYjBpQCCIq3MhQ3W++wU47QpZM= +go.opentelemetry.io/collector/processor/xprocessor v0.125.0/go.mod h1:bCxUyFVlksANg8wjYZqWVsRB33lkLQ294rTrju/IZiM= +go.opentelemetry.io/collector/semconv v0.125.0 h1:SyRP617YGvNSWRSKMy7Lbk9RaJSR+qFAAfyxJOeZe4s= +go.opentelemetry.io/collector/semconv v0.125.0/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= +go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 h1:ojdSRDvjrnm30beHOmwsSvLpoRF40MlwNCA+Oo93kXU= +go.opentelemetry.io/contrib/bridges/otelzap v0.10.0/go.mod h1:oTTm4g7NEtHSV2i/0FeVdPaPgUIZPfQkFbq0vbzqnv0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= +go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= +go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= +go.opentelemetry.io/otel/log v0.11.0 h1:c24Hrlk5WJ8JWcwbQxdBqxZdOK7PcP/LFtOtwpDTe3Y= +go.opentelemetry.io/otel/log v0.11.0/go.mod h1:U/sxQ83FPmT29trrifhQg+Zj2lo1/IPN1PF6RTFqdwc= +go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= +go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= +go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= +go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= +go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o= +go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= +go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs= +go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= -golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= +golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= -golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= +golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= +golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= -golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= -golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= -golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= +golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= -golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= -golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe h1:bQnxqljG/wqi4NTXu2+DJ3n7APcEA882QZ1JvhQAq9o= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:PAREbraiVEVGVdTZsVWjSbbTtSyGbAgIIvni8a8CD5s= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0= -google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0= -google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= -google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= -google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -gopkg.in/DataDog/dd-trace-go.v1 v1.65.1 h1:Ne7kzWr/br/jwhUJR7CnqPl/mUpNxa6LfgZs0S4htZM= -gopkg.in/DataDog/dd-trace-go.v1 v1.65.1/go.mod h1:beNFIWd/H04d0k96cfltgiDH2+t0T5sDbyYLF3VTXqk= -gopkg.in/DataDog/dd-trace-go.v1 v1.72.1/go.mod h1:XqDhDqsLpThFnJc4z0FvAEItISIAUka+RHwmQ6EfN1U= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 h1:29cjnHVylHwTzH66WfFZqgSQgnxzvWE+jvBwpZCLRxY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= +google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM= +google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -honnef.co/go/gotraceui v0.2.0 h1:dmNsfQ9Vl3GwbiVD7Z8d/osC6WtGGrasyrC2suc4ZIQ= -honnef.co/go/gotraceui v0.2.0/go.mod h1:qHo4/W75cA3bX0QQoSvDjbJa4R8mAyyFjbWAj63XElc= +k8s.io/apimachinery v0.32.3 h1:JmDuDarhDmA/Li7j3aPrwhpNBA94Nvk5zLeOge9HH1U= +k8s.io/apimachinery v0.32.3/go.mod h1:GpHVgxoKlTxClKcteaeuF1Ul/lDVb74KpZcxcmLDElE= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod index 3e0c760a6d..1078bc71ab 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod @@ -1,25 +1,33 @@ module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/lambdatest/hello -go 1.24 +go 1.24.0 require ( + github.com/DataDog/dd-trace-go/contrib/net/http/v2 v2.0.0-00010101000000-000000000000 + github.com/DataDog/dd-trace-go/v2 v2.4.0-dev github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go v0.0.0-00010101000000-000000000000 github.com/aws/aws-lambda-go v1.46.0 - github.com/DataDog/dd-trace-go/v2 v2.0.0 ) require ( - github.com/DataDog/appsec-internal-go v1.9.0 // indirect - github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0 // indirect - github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0 // indirect - github.com/DataDog/datadog-go/v5 v5.5.0 // indirect - github.com/DataDog/go-libddwaf/v3 v3.5.1 // indirect - github.com/DataDog/go-sqllexer v0.0.14 // indirect + github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/proto v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 // indirect + github.com/DataDog/datadog-agent/pkg/trace v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/version v0.67.0 // indirect + github.com/DataDog/datadog-go/v5 v5.6.0 // indirect + github.com/DataDog/go-libddwaf/v4 v4.3.2 // indirect + github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 // indirect + github.com/DataDog/go-sqllexer v0.1.6 // indirect github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect - github.com/DataDog/sketches-go v1.4.5 // indirect - github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect + github.com/DataDog/sketches-go v1.4.7 // indirect + github.com/Masterminds/semver/v3 v3.3.1 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect github.com/andybalholm/brotli v1.1.0 // indirect - github.com/aws/aws-sdk-go v1.50.9 // indirect github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect @@ -33,47 +41,73 @@ require ( github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect - github.com/aws/aws-xray-sdk-go v1.8.3 // indirect + github.com/aws/aws-xray-sdk-go/v2 v2.0.0 // indirect github.com/aws/smithy-go v1.19.0 // indirect github.com/cenkalti/backoff/v4 v4.2.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 // indirect - github.com/ebitengine/purego v0.6.0-alpha.5 // indirect - github.com/go-logr/logr v1.4.1 // indirect + github.com/ebitengine/purego v0.8.3 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect + github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7 // indirect - github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 // indirect - github.com/hashicorp/go-sockaddr v1.0.2 // indirect - github.com/jmespath/go-jmespath v0.4.0 // indirect - github.com/klauspost/compress v1.17.6 // indirect - github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c // indirect + github.com/hashicorp/go-version v1.7.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/outcaste-io/ristretto v0.2.3 // indirect - github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986 // indirect + github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/ryanuber/go-glob v1.0.0 // indirect - github.com/secure-systems-lab/go-securesystemslib v0.8.0 // indirect + github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect + github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect + github.com/shirou/gopsutil/v4 v4.25.3 // indirect github.com/sony/gobreaker v0.5.0 // indirect - github.com/tinylib/msgp v1.2.1 // indirect + github.com/theckman/httpforwarded v0.4.0 // indirect + github.com/tinylib/msgp v1.2.5 // indirect + github.com/tklauser/go-sysconf v0.3.14 // indirect + github.com/tklauser/numcpus v0.9.0 // indirect github.com/valyala/bytebufferpool v1.0.0 // indirect github.com/valyala/fasthttp v1.52.0 // indirect - go.opentelemetry.io/otel v1.27.0 // indirect - go.opentelemetry.io/otel/metric v1.27.0 // indirect - go.opentelemetry.io/otel/trace v1.27.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/collector/component v1.31.0 // indirect + go.opentelemetry.io/collector/featuregate v1.31.0 // indirect + go.opentelemetry.io/collector/internal/telemetry v0.125.0 // indirect + go.opentelemetry.io/collector/pdata v1.31.0 // indirect + go.opentelemetry.io/collector/semconv v0.125.0 // indirect + go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 // indirect + go.opentelemetry.io/otel v1.35.0 // indirect + go.opentelemetry.io/otel/log v0.11.0 // indirect + go.opentelemetry.io/otel/metric v1.35.0 // indirect + go.opentelemetry.io/otel/sdk v1.35.0 // indirect + go.opentelemetry.io/otel/trace v1.35.0 // indirect go.uber.org/atomic v1.11.0 // indirect - golang.org/x/mod v0.20.0 // indirect - golang.org/x/net v0.33.0 // indirect - golang.org/x/sys v0.28.0 // indirect - golang.org/x/text v0.21.0 // indirect - golang.org/x/time v0.6.0 // indirect - golang.org/x/tools v0.24.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.40.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/text v0.26.0 // indirect + golang.org/x/time v0.11.0 // indirect golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5 // indirect - google.golang.org/grpc v1.64.1 // indirect - google.golang.org/protobuf v1.34.2 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 // indirect + google.golang.org/grpc v1.72.0 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) replace github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go => ../../ -replace github.com/DataDog/dd-trace-go/v2 => ../../../../../ + +replace github.com/DataDog/dd-trace-go/v2 => ../../../../.. + +replace github.com/DataDog/dd-trace-go/contrib/net/http/v2 => ../../../../../contrib/net/http diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum index c7b939ab90..b78bf03702 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum @@ -1,39 +1,46 @@ -github.com/DATA-DOG/go-sqlmock v1.4.1 h1:ThlnYciV1iM/V0OSF/dtkqWb6xo5qITT1TJBG1MRDJM= -github.com/DATA-DOG/go-sqlmock v1.4.1/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= -github.com/DataDog/appsec-internal-go v1.6.0 h1:QHvPOv/O0s2fSI/BraZJNpRDAtdlrRm5APJFZNBxjAw= -github.com/DataDog/appsec-internal-go v1.6.0/go.mod h1:pEp8gjfNLtEOmz+iZqC8bXhu0h4k7NUsW/qiQb34k1U= -github.com/DataDog/appsec-internal-go v1.9.0/go.mod h1:wW0cRfWBo4C044jHGwYiyh5moQV2x0AhnwqMuiX7O/g= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2 h1:y08IzbpFM/HBaKfgayFZe1FpcbZn6bVPXoZ++93vxv8= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.50.2/go.mod h1:A4nLJvxlg6BO/8/zg81til9yT0uRPuXDFMAzDMpmgn4= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.58.0/go.mod h1:MfDvphBMmEMwE3a30h27AtPO7OzmvdoVTiGY1alEmo4= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2 h1:7jn5EOu84uph4sd+pB3vF8LnsdTjhh+1/NnCvfNpG4A= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.50.2/go.mod h1:Vc+snp0Bey4MrrJyiV2tVxxJb6BmLomPvN1RgAvjGaQ= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.58.0/go.mod h1:jN5BsZI+VilHJV1Wac/efGxS4TPtXa1Lh9SiUyv93F4= -github.com/DataDog/datadog-go/v5 v5.5.0 h1:G5KHeB8pWBNXT4Jtw0zAkhdxEAWSpWH00geHI6LDrKU= -github.com/DataDog/datadog-go/v5 v5.5.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/go-libddwaf/v3 v3.2.1 h1:lZPc6UxCOwioHc++nsldKR50FpIrRh1uGnGLuryqnE8= -github.com/DataDog/go-libddwaf/v3 v3.2.1/go.mod h1:AP+7Atb8ftSsrha35wht7+K3R+xuzfVSQhabSO4w6CY= -github.com/DataDog/go-libddwaf/v3 v3.5.1/go.mod h1:n98d9nZ1gzenRSk53wz8l6d34ikxS+hs62A31Fqmyi4= -github.com/DataDog/go-sqllexer v0.0.10 h1:u07DuRfdlPPmOX/dclb1gcn/zaqWxUiURRRVenKILxc= -github.com/DataDog/go-sqllexer v0.0.10/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= -github.com/DataDog/go-sqllexer v0.0.14/go.mod h1:KwkYhpFEVIq+BfobkTC1vfqm4gTi65skV/DpDBXtexc= -github.com/DataDog/go-tuf v1.0.2-0.5.2 h1:EeZr937eKAWPxJ26IykAdWA4A0jQXJgkhUjqEI/w7+I= -github.com/DataDog/go-tuf v1.0.2-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= +github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= +github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0/go.mod h1:1oPcs3BUTQhiTkmk789rb7ob105MxNV6OuBa28BdukQ= +github.com/DataDog/datadog-agent/pkg/proto v0.67.0 h1:7dO6mKYRb7qSiXEu7Q2mfeKbhp4hykCAULy4BfMPmsQ= +github.com/DataDog/datadog-agent/pkg/proto v0.67.0/go.mod h1:bKVXB7pxBg0wqXF6YSJ+KU6PeCWKDyJj83kUH1ab+7o= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 h1:/DsN4R+IkC6t1+4cHSfkxzLtDl84rBbPC5Wa9srBAoM= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0/go.mod h1:Th2LD/IGid5Rza55pzqGu6nUdOv/Rts6wPwLjTyOSTs= +github.com/DataDog/datadog-agent/pkg/trace v0.67.0 h1:dqt+/nObo0JKyaEqIMZgfqGZbx9TfEHpCkrjQ/zzH7k= +github.com/DataDog/datadog-agent/pkg/trace v0.67.0/go.mod h1:zmZoEtKvOnaKHbJGBKH3a4xuyPrSfBaF0ZE3Q3rCoDw= +github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 h1:xrH15QNqeJZkYoXYi44VCIvGvTwlQ3z2iT2QVTGiT7s= +github.com/DataDog/datadog-agent/pkg/util/log v0.67.0/go.mod h1:dfVLR+euzEyg1CeiExgJQq1c1dod42S6IeiRPj8H7Yk= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 h1:aIWF85OKxXGo7rVyqJ7jm7lm2qCQrgyXzYyFuw0T2EQ= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0/go.mod h1:Lfap5FuM4b/Pw9IrTuAvWBWZEmXOvZhCya3dYv4G8O0= +github.com/DataDog/datadog-agent/pkg/version v0.67.0 h1:TB8H8r+laB1Qdttvvc6XJVyLGxp8E6j2f2Mh5IPbYmQ= +github.com/DataDog/datadog-agent/pkg/version v0.67.0/go.mod h1:kvAw/WbI7qLAsDI2wHabZfM7Cv2zraD3JA3323GEB+8= +github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= +github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= +github.com/DataDog/go-libddwaf/v4 v4.3.2 h1:YGvW2Of1C4e1yU+p7iibmhN2zEOgi9XEchbhQjBxb/A= +github.com/DataDog/go-libddwaf/v4 v4.3.2/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 h1:ZRLR9Lbym748e8RznWzmSoK+OfV+8qW6SdNYA4/IqdA= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633/go.mod h1:YFoTl1xsMzdSRFIu33oCSPS/3+HZAPGpO3oOM96wXCM= +github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= +github.com/DataDog/go-sqllexer v0.1.6/go.mod h1:GGpo1h9/BVSN+6NJKaEcJ9Jn44Hqc63Rakeb+24Mjgo= +github.com/DataDog/go-tuf v1.1.0-0.5.2 h1:4CagiIekonLSfL8GMHRHcHudo1fQnxELS9g4tiAupQ4= github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= -github.com/DataDog/sketches-go v1.4.5 h1:ki7VfeNz7IcNafq7yI/j5U/YCkO3LJiMDtXz9OMQbyE= -github.com/DataDog/sketches-go v1.4.5/go.mod h1:7Y8GN8Jf66DLyDhc94zuWA3uHEt/7ttt8jHOBWWrSOg= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 h1:5US5SqqhfkZkg/E64uvn7YmeTwnudJHtlPEH/LOT99w= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0/go.mod h1:VRo4D6rj92AExpVBlq3Gcuol9Nm1bber12KyxRjKGWw= +github.com/DataDog/sketches-go v1.4.7 h1:eHs5/0i2Sdf20Zkj0udVFWuCrXGRFig2Dcfm5rtcTxc= +github.com/DataDog/sketches-go v1.4.7/go.mod h1:eAmQ/EBmtSO+nQp7IZMZVRPT4BQTmIc5RZQ+deGlTPM= +github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= +github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= -github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= -github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= -github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= -github.com/aws/aws-sdk-go v1.50.9 h1:yX66aKnEtRc/uNV/1EH8CudRT5aLwVwcSwTBphuVPt8= -github.com/aws/aws-sdk-go v1.50.9/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= @@ -60,102 +67,107 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= -github.com/aws/aws-xray-sdk-go v1.8.3 h1:S8GdgVncBRhzbNnNUgTPwhEqhwt2alES/9rLASyhxjU= -github.com/aws/aws-xray-sdk-go v1.8.3/go.mod h1:tv8uLMOSCABolrIF8YCcp3ghyswArsan8dfLCA1ZATk= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= +github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= -github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= -github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 h1:kHaBemcxl8o/pQ5VM1c8PVE1PubbNx3mjUr09OqWGCs= +github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575/go.mod h1:9d6lWj8KzO/fd/NrVaLscBKmPigpZpn5YawRPw+e3Yo= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg= -github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds= -github.com/ebitengine/purego v0.6.0-alpha.5 h1:EYID3JOAdmQ4SNZYJHu9V6IqOeRQDBYxqKAg9PyoHFY= -github.com/ebitengine/purego v0.6.0-alpha.5/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ= -github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk= -github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/ebitengine/purego v0.8.3 h1:K+0AjQp63JEZTEMZiwsI9g0+hAMNohwUOtY0RPGexmc= +github.com/ebitengine/purego v0.8.3/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= -github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= -github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/mock v1.7.0-rc.1 h1:YojYx61/OLFsiv6Rw1Z96LpldJIy31o+UHmwAUMJ6/U= +github.com/golang/mock v1.7.0-rc.1/go.mod h1:s42URUywIqd+OcERslBJvOjepvNymP31m3q8d/GkuRs= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b h1:h9U78+dx9a4BKdQkBBos92HalKpaGKHrp+3Uo6yTodo= -github.com/google/pprof v0.0.0-20230817174616-7a8ec2ada47b/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= +github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= -github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= -github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= -github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7 h1:UpiO20jno/eV1eVZcxqWnUohyKRe1g8FPV/xH1s/2qs= -github.com/hashicorp/go-secure-stdlib/parseutil v0.1.7/go.mod h1:QmrqtbKuxxSWTN3ETMPuB+VtEiBJ/A9XhoYGv8E1uD8= -github.com/hashicorp/go-secure-stdlib/strutil v0.1.1/go.mod h1:gKOamz3EwoIoJq7mlMIRBpVTAUn8qPCrEclOKKWhD3U= -github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 h1:kes8mmyCpxJsI7FTwtzRqEy9CdjCtrXrXGuOpxEA7Ts= -github.com/hashicorp/go-secure-stdlib/strutil v0.1.2/go.mod h1:Gou2R9+il93BqX25LAKCLuM+y9U2T4hlwvT1yprcna4= -github.com/hashicorp/go-sockaddr v1.0.2 h1:ztczhD1jLxIRjVejw8gFomI1BQZOe2WoVOu0SyteCQc= -github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A= -github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= -github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= -github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= -github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= -github.com/klauspost/compress v1.17.5 h1:d4vBd+7CHydUqpFBgUEKkSdtSugf9YFmSkvUYPquI5E= -github.com/klauspost/compress v1.17.5/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= -github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= -github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= -github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= +github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= +github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= -github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= -github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= -github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/mapstructure v1.5.1-0.20231216201459-8508981c8b6c/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= -github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0= +github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0 h1:0dOJCEtabevxxDQmxed69oMzSw+gb3ErCnFwFYZFu0M= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0/go.mod h1:QwzQhtxPThXMUDW1XRXNQ+l0GrI2BRsvNhX6ZuKyAds= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0 h1:F68/Nbpcvo3JZpaWlRUDJtG7xs8FHBZ7A8GOMauDkyc= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0/go.mod h1:haO4cJtAk05Y0p7NO9ME660xxtSh54ifCIIT7+PO9C0= github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= -github.com/philhofer/fwd v1.1.2 h1:bnDivRJ1EWPjUIRXV5KfORO897HTbpFAQddBdE8t7Gw= -github.com/philhofer/fwd v1.1.2/go.mod h1:qkPdfjR2SIEbspLqpe1tO4n5yICnr2DY7mqEx2tUTP0= -github.com/philhofer/fwd v1.1.3-0.20240612014219-fbbf4953d986/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= +github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= +github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg= +github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA= github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= -github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= -github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk= -github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= -github.com/secure-systems-lab/go-securesystemslib v0.8.0 h1:mr5An6X45Kb2nddcFlbmfHkLguCE9laoZCUzEEpIZXA= -github.com/secure-systems-lab/go-securesystemslib v0.8.0/go.mod h1:UH2VZVuJfCYR8WgMlCU1uFsOUU+KeyrTWcSS73NBOzU= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/secure-systems-lab/go-securesystemslib v0.9.0 h1:rf1HIbL64nUpEIZnjLZ3mcNEL9NBPB0iuVjyxvq3LZc= +github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/woA/peqr+L0joiRXbPpQ042GgJckkFgw= +github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= +github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= @@ -164,114 +176,168 @@ github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.1 h1:4VhoImhV/Bm0ToFkXFi8hXNXwpDRZ/ynw3amt82mzq0= -github.com/stretchr/objx v0.5.1/go.mod h1:/iHQpkQwBD6DLUmQ4pE+s1TXdob1mORJ4/UFdrifcy0= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/tinylib/msgp v1.1.9 h1:SHf3yoO2sGA0veCJeCBYLHuttAVFHGm2RHgNodW7wQU= -github.com/tinylib/msgp v1.1.9/go.mod h1:BCXGB54lDD8qUEPmiG0cQQUANC4IUQyB2ItS2UDlO/k= -github.com/tinylib/msgp v1.2.1/go.mod h1:2vIGs3lcUo8izAATNobrCHevYZC/LMsJtw4JPiYPHro= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/theckman/httpforwarded v0.4.0 h1:N55vGJT+6ojTnLY3LQCNliJC4TW0P0Pkeys1G1WpX2w= +github.com/theckman/httpforwarded v0.4.0/go.mod h1:GVkFynv6FJreNbgH/bpOU9ITDZ7a5WuzdNCtIMI1pVI= +github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= +github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= +github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= +github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= +github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA= -github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g= +github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= +github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= +github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= +github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= +github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0 h1:KfYpVmrjI7JuToy5k8XV3nkapjWx48k4E4JOtVstzQI= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.44.0/go.mod h1:SeQhzAEccGVZVEy7aH87Nh0km+utSpo1pTv6eMMop48= -go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= -go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= -go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ= -go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= -go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= -go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak= -go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= -go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= -go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/collector/component v1.31.0 h1:9LzU8X1RhV3h8/QsAoTX23aFUfoJ3EUc9O/vK+hFpSI= +go.opentelemetry.io/collector/component v1.31.0/go.mod h1:JbZl/KywXJxpUXPbt96qlEXJSym1zQ2hauMxYMuvlxM= +go.opentelemetry.io/collector/component/componentstatus v0.125.0 h1:zlxGQZYd9kknRZSjRpOYW5SBjl0a5zYFYRPbreobXoU= +go.opentelemetry.io/collector/component/componentstatus v0.125.0/go.mod h1:bHXc2W8bqqo9adOvCgvhcO7pYzJOSpyV4cuQ1wiIl04= +go.opentelemetry.io/collector/component/componenttest v0.125.0 h1:E2mpnMQbkMpYoZ3Q8pHx4kod7kedjwRs1xqDpzCe/84= +go.opentelemetry.io/collector/component/componenttest v0.125.0/go.mod h1:pQtsE1u/SPZdTphP5BZP64XbjXSq6wc+mDut5Ws/JDI= +go.opentelemetry.io/collector/consumer v1.31.0 h1:L+y66ywxLHnAxnUxv0JDwUf5bFj53kMxCCyEfRKlM7s= +go.opentelemetry.io/collector/consumer v1.31.0/go.mod h1:rPsqy5ni+c6xNMUkOChleZYO/nInVY6eaBNZ1FmWJVk= +go.opentelemetry.io/collector/consumer/consumertest v0.125.0 h1:TUkxomGS4DAtjBvcWQd2UY4FDLLEKMQD6iOIDUr/5dM= +go.opentelemetry.io/collector/consumer/consumertest v0.125.0/go.mod h1:vkHf3y85cFLDHARO/cTREVjLjOPAV+cQg7lkC44DWOY= +go.opentelemetry.io/collector/consumer/xconsumer v0.125.0 h1:oTreUlk1KpMSWwuHFnstW+orrjGTyvs2xd3o/Dpy+hI= +go.opentelemetry.io/collector/consumer/xconsumer v0.125.0/go.mod h1:FX0G37r0W+wXRgxxFtwEJ4rlsCB+p0cIaxtU3C4hskw= +go.opentelemetry.io/collector/featuregate v1.31.0 h1:20q7plPQZwmAiaYAa6l1m/i2qDITZuWlhjr4EkmeQls= +go.opentelemetry.io/collector/featuregate v1.31.0/go.mod h1:Y/KsHbvREENKvvN9RlpiWk/IGBK+CATBYzIIpU7nccc= +go.opentelemetry.io/collector/internal/telemetry v0.125.0 h1:6lcGOxw3dAg7LfXTKdN8ZjR+l7KvzLdEiPMhhLwG4r4= +go.opentelemetry.io/collector/internal/telemetry v0.125.0/go.mod h1:5GyFslLqjZgq1DZTtFiluxYhhXrCofHgOOOybodDPGE= +go.opentelemetry.io/collector/pdata v1.31.0 h1:P5WuLr1l2JcIvr6Dw2hl01ltp2ZafPnC4Isv+BLTBqU= +go.opentelemetry.io/collector/pdata v1.31.0/go.mod h1:m41io9nWpy7aCm/uD1L9QcKiZwOP0ldj83JEA34dmlk= +go.opentelemetry.io/collector/pdata/pprofile v0.125.0 h1:Qqlx8w1HpiYZ9RQqjmMQIysI0cHNO1nh3E/fCTeFysA= +go.opentelemetry.io/collector/pdata/pprofile v0.125.0/go.mod h1:p/yK023VxAp8hm27/1G5DPTcMIpnJy3cHGAFUQZGyaQ= +go.opentelemetry.io/collector/pdata/testdata v0.125.0 h1:due1Hl0EEVRVwfCkiamRy5E8lS6yalv0lo8Zl/SJtGw= +go.opentelemetry.io/collector/pdata/testdata v0.125.0/go.mod h1:1GpEWlgdMrd+fWsBk37ZC2YmOP5YU3gFQ4rWuCu9g24= +go.opentelemetry.io/collector/pipeline v0.125.0 h1:oitBgcAFqntDB4ihQJUHJSQ8IHqKFpPkaTVbTYdIUzM= +go.opentelemetry.io/collector/pipeline v0.125.0/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= +go.opentelemetry.io/collector/processor v1.31.0 h1:+u7sBUpnCBsHYoALp4hfr9VEjLHHYa4uKENGITe0K9Q= +go.opentelemetry.io/collector/processor v1.31.0/go.mod h1:5hDYJ7/hTdfd2tF2Rj5Hs6+mfyFz2O7CaPzVvW1qHQc= +go.opentelemetry.io/collector/processor/processorhelper v0.125.0 h1:QRpX7oFW88DAZhy+Q93npklRoaQr8ue0GKpeup7C/Fk= +go.opentelemetry.io/collector/processor/processorhelper v0.125.0/go.mod h1:oXRvslUuN62wErcoJrcEJYoTXu5wHyNyJsE+/a9Cc9s= +go.opentelemetry.io/collector/processor/processortest v0.125.0 h1:ZVAN4iZPDcWhpzKqnuok2NIuS5hwGVVQUOWkJFR12tA= +go.opentelemetry.io/collector/processor/processortest v0.125.0/go.mod h1:VAw0IRG35cWTBjBtreXeXJEgqkRegfjrH/EuLhNX2+I= +go.opentelemetry.io/collector/processor/xprocessor v0.125.0 h1:VWYPMW1VmDq6xB7M5SYjBpQCCIq3MhQ3W++wU47QpZM= +go.opentelemetry.io/collector/processor/xprocessor v0.125.0/go.mod h1:bCxUyFVlksANg8wjYZqWVsRB33lkLQ294rTrju/IZiM= +go.opentelemetry.io/collector/semconv v0.125.0 h1:SyRP617YGvNSWRSKMy7Lbk9RaJSR+qFAAfyxJOeZe4s= +go.opentelemetry.io/collector/semconv v0.125.0/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= +go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 h1:ojdSRDvjrnm30beHOmwsSvLpoRF40MlwNCA+Oo93kXU= +go.opentelemetry.io/contrib/bridges/otelzap v0.10.0/go.mod h1:oTTm4g7NEtHSV2i/0FeVdPaPgUIZPfQkFbq0vbzqnv0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= +go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= +go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= +go.opentelemetry.io/otel/log v0.11.0 h1:c24Hrlk5WJ8JWcwbQxdBqxZdOK7PcP/LFtOtwpDTe3Y= +go.opentelemetry.io/otel/log v0.11.0/go.mod h1:U/sxQ83FPmT29trrifhQg+Zj2lo1/IPN1PF6RTFqdwc= +go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= +go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= +go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= +go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= +go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o= +go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= +go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs= +go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= -golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= +golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= -golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= +golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= +golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= -golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= -golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= -golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= +golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= -golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= -golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe h1:bQnxqljG/wqi4NTXu2+DJ3n7APcEA882QZ1JvhQAq9o= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:PAREbraiVEVGVdTZsVWjSbbTtSyGbAgIIvni8a8CD5s= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0= -google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0= -google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= -google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= -google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= -google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= -gopkg.in/DataDog/dd-trace-go.v1 v1.65.1 h1:Ne7kzWr/br/jwhUJR7CnqPl/mUpNxa6LfgZs0S4htZM= -gopkg.in/DataDog/dd-trace-go.v1 v1.65.1/go.mod h1:beNFIWd/H04d0k96cfltgiDH2+t0T5sDbyYLF3VTXqk= -gopkg.in/DataDog/dd-trace-go.v1 v1.72.1/go.mod h1:XqDhDqsLpThFnJc4z0FvAEItISIAUka+RHwmQ6EfN1U= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 h1:29cjnHVylHwTzH66WfFZqgSQgnxzvWE+jvBwpZCLRxY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= +google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM= +google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -honnef.co/go/gotraceui v0.2.0 h1:dmNsfQ9Vl3GwbiVD7Z8d/osC6WtGGrasyrC2suc4ZIQ= -honnef.co/go/gotraceui v0.2.0/go.mod h1:qHo4/W75cA3bX0QQoSvDjbJa4R8mAyyFjbWAj63XElc= +k8s.io/apimachinery v0.32.3 h1:JmDuDarhDmA/Li7j3aPrwhpNBA94Nvk5zLeOge9HH1U= +k8s.io/apimachinery v0.32.3/go.mod h1:GpHVgxoKlTxClKcteaeuF1Ul/lDVb74KpZcxcmLDElE= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go index 9ae4cc3f4b..abf9a86f80 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go @@ -14,8 +14,8 @@ import ( "github.com/aws/aws-lambda-go/lambda" + httptrace "github.com/DataDog/dd-trace-go/contrib/net/http/v2" ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" - httptrace "github.com/DataDog/dd-trace-go/v2/contrib/net/http" "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "github.com/aws/aws-lambda-go/events" ) From 0947de89abc6c18218885afe3a9eeae089365472 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Mon, 15 Sep 2025 13:43:51 -0400 Subject: [PATCH 06/25] follow the versioning convention --- contrib/aws/datadog-lambda-go/ddlambda.go | 10 +++++----- .../aws/datadog-lambda-go/ddlambda_example_test.go | 2 +- contrib/aws/datadog-lambda-go/go.mod | 2 +- .../internal/extension/extension.go | 2 +- .../internal/extension/extension_test.go | 14 +++++++------- .../aws/datadog-lambda-go/internal/metrics/api.go | 2 +- .../internal/metrics/context_test.go | 2 +- .../internal/metrics/kms_decrypter.go | 2 +- .../datadog-lambda-go/internal/metrics/listener.go | 6 +++--- .../internal/metrics/listener_test.go | 12 ++++++------ .../internal/metrics/processor.go | 2 +- .../datadog-lambda-go/internal/trace/context.go | 4 ++-- .../internal/trace/context_test.go | 2 +- .../datadog-lambda-go/internal/trace/listener.go | 6 +++--- .../internal/trace/listener_test.go | 2 +- .../internal/wrapper/wrap_handler.go | 4 ++-- .../aws/datadog-lambda-go/lambdatest/error/go.mod | 6 +++--- .../aws/datadog-lambda-go/lambdatest/error/main.go | 2 +- .../aws/datadog-lambda-go/lambdatest/hello/go.mod | 6 +++--- .../aws/datadog-lambda-go/lambdatest/hello/main.go | 2 +- 20 files changed, 45 insertions(+), 45 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/ddlambda.go b/contrib/aws/datadog-lambda-go/ddlambda.go index 8dd07ed663..22d262a59e 100644 --- a/contrib/aws/datadog-lambda-go/ddlambda.go +++ b/contrib/aws/datadog-lambda-go/ddlambda.go @@ -18,11 +18,11 @@ import ( "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "github.com/aws/aws-lambda-go/lambda" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/metrics" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/trace" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/wrapper" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/metrics" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/trace" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/wrapper" ) type ( diff --git a/contrib/aws/datadog-lambda-go/ddlambda_example_test.go b/contrib/aws/datadog-lambda-go/ddlambda_example_test.go index 08eb013f80..c289a7e85c 100644 --- a/contrib/aws/datadog-lambda-go/ddlambda_example_test.go +++ b/contrib/aws/datadog-lambda-go/ddlambda_example_test.go @@ -15,7 +15,7 @@ import ( "github.com/aws/aws-lambda-go/events" - ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" + ddlambda "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2" ) var exampleSQSExtractor = func(ctx context.Context, ev json.RawMessage) map[string]string { diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod index ba80cd8923..f99bd0fa60 100644 --- a/contrib/aws/datadog-lambda-go/go.mod +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -1,4 +1,4 @@ -module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go +module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 go 1.24.0 diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension.go b/contrib/aws/datadog-lambda-go/internal/extension/extension.go index 5b27535e01..78d689c94f 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension.go @@ -19,7 +19,7 @@ import ( "strings" "time" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" ) diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go index c4b8c88006..9ac6aba767 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go @@ -14,7 +14,7 @@ import ( "os" "testing" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/DataDog/dd-trace-go/v2/ddtrace" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "github.com/stretchr/testify/assert" @@ -224,11 +224,11 @@ type mockSpanContext struct { ddtrace.SpanContext } -func (m mockSpanContext) TraceID() string { return "123" } -func (m mockSpanContext) TraceIDBytes() [16]byte { return [16]byte{} } -func (m mockSpanContext) TraceIDLower() uint64 { return 123 } -func (m mockSpanContext) SpanID() uint64 { return 456 } -func (m mockSpanContext) SamplingPriority() (int, bool) { return -1, true } +func (m mockSpanContext) TraceID() string { return "123" } +func (m mockSpanContext) TraceIDBytes() [16]byte { return [16]byte{} } +func (m mockSpanContext) TraceIDLower() uint64 { return 123 } +func (m mockSpanContext) SpanID() uint64 { return 456 } +func (m mockSpanContext) SamplingPriority() (int, bool) { return -1, true } func (m mockSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {} type mockSpan struct{ ddtrace.Span } @@ -276,7 +276,7 @@ func TestExtensionEndInvocationErrorHeaders(t *testing.T) { data, err := base64.StdEncoding.DecodeString(hdr.Get("X-Datadog-Invocation-Error-Stack")) assert.Nil(t, err) - assert.Contains(t, string(data), "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go") + assert.Contains(t, string(data), "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2") assert.Contains(t, string(data), "TestExtensionEndInvocationErrorHeaders") } diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/api.go b/contrib/aws/datadog-lambda-go/internal/metrics/api.go index 1f43012314..05de180d59 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/api.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/api.go @@ -14,7 +14,7 @@ import ( "net/http" "time" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" ) type ( diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go index 5bbb94f96b..84a1f0dec2 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/context_test.go @@ -9,7 +9,7 @@ import ( "context" "testing" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/stretchr/testify/assert" ) diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go index 7fe0b61d1c..50572cdc6d 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/kms_decrypter.go @@ -13,7 +13,7 @@ import ( "github.com/aws/aws-sdk-go-v2/aws" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/kms" ) diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go index 61bd2c9407..3bb21ff0fe 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -17,9 +17,9 @@ import ( "github.com/aws/aws-lambda-go/lambdacontext" "github.com/DataDog/datadog-go/v5/statsd" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/version" ) type ( diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go index 6b01b9a409..f0e1ff52a4 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -19,9 +19,9 @@ import ( "testing" "time" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/version" "github.com/aws/aws-lambda-go/lambdacontext" "github.com/stretchr/testify/assert" @@ -107,9 +107,9 @@ func TestAddDistributionMetricWithFIPSMode(t *testing.T) { // Create a listener with FIPS mode enabled listener := MakeListener(Config{ - APIKey: "12345", - Site: server.URL, - FIPSMode: true, + APIKey: "12345", + Site: server.URL, + FIPSMode: true, }, &extension.ExtensionManager{}) // Verify the API client wasn't created diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/processor.go b/contrib/aws/datadog-lambda-go/internal/metrics/processor.go index 4ac248d45b..bc24536396 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/processor.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/processor.go @@ -11,7 +11,7 @@ import ( "sync" "time" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/cenkalti/backoff/v4" "github.com/sony/gobreaker" ) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context.go b/contrib/aws/datadog-lambda-go/internal/trace/context.go index e82e44a3b3..dc6a067659 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/context.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/context.go @@ -14,8 +14,8 @@ import ( "strconv" "strings" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/DataDog/dd-trace-go/v2/ddtrace" "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "github.com/aws/aws-xray-sdk-go/v2/header" diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go index 4c9d2fe6a7..fb1ff892ee 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go @@ -11,7 +11,7 @@ import ( "os" "testing" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/aws/aws-xray-sdk-go/v2/header" "github.com/aws/aws-xray-sdk-go/v2/xray" "github.com/stretchr/testify/assert" diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener.go b/contrib/aws/datadog-lambda-go/internal/trace/listener.go index 9a163c612b..3e3991776f 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener.go @@ -12,9 +12,9 @@ import ( "os" "strings" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/version" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/version" "github.com/DataDog/dd-trace-go/v2/ddtrace" ddotel "github.com/DataDog/dd-trace-go/v2/ddtrace/opentelemetry" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go index cfa6b6e103..bea636cc35 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go @@ -10,7 +10,7 @@ import ( "fmt" "testing" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/v2/ddtrace/mocktracer" "github.com/aws/aws-lambda-go/lambdacontext" "github.com/stretchr/testify/assert" diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go index 8def4814f2..b521ba49ff 100644 --- a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler.go @@ -11,8 +11,8 @@ import ( "errors" "fmt" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/extension" - "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/internal/logger" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/aws/aws-lambda-go/lambda" "reflect" diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod index 1d75c29865..58f435fe83 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod @@ -1,9 +1,9 @@ -module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/lambdatest/error +module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/lambdatest/error/v2 go 1.24.0 require ( - github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go v0.0.0-00010101000000-000000000000 + github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 v2.4.0-dev github.com/aws/aws-lambda-go v1.46.0 ) @@ -105,6 +105,6 @@ require ( gopkg.in/yaml.v3 v3.0.1 // indirect ) -replace github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go => ../../ +replace github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 => ../../ replace github.com/DataDog/dd-trace-go/v2 => ../../../../.. diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go index 749be43962..c658cabfa3 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go +++ b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go @@ -12,7 +12,7 @@ import ( "github.com/aws/aws-lambda-go/lambda" - ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" + ddlambda "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2" "github.com/aws/aws-lambda-go/events" ) diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod index 1078bc71ab..a1cb793b91 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod @@ -1,11 +1,11 @@ -module github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go/lambdatest/hello +module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/lambdatest/hello/v2 go 1.24.0 require ( + github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 v2.4.0-dev github.com/DataDog/dd-trace-go/contrib/net/http/v2 v2.0.0-00010101000000-000000000000 github.com/DataDog/dd-trace-go/v2 v2.4.0-dev - github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go v0.0.0-00010101000000-000000000000 github.com/aws/aws-lambda-go v1.46.0 ) @@ -106,7 +106,7 @@ require ( gopkg.in/yaml.v3 v3.0.1 // indirect ) -replace github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go => ../../ +replace github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 => ../../ replace github.com/DataDog/dd-trace-go/v2 => ../../../../.. diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go index abf9a86f80..32687718ee 100644 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go +++ b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go @@ -14,8 +14,8 @@ import ( "github.com/aws/aws-lambda-go/lambda" + ddlambda "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2" httptrace "github.com/DataDog/dd-trace-go/contrib/net/http/v2" - ddlambda "github.com/DataDog/dd-trace-go/v2/contrib/aws/datadog-lambda-go" "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "github.com/aws/aws-lambda-go/events" ) From edee75f0525b8df78c490526462b2a9450fd7b16 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Tue, 16 Sep 2025 14:44:22 -0400 Subject: [PATCH 07/25] follow the new versioning convention --- contrib/aws/datadog-lambda-go/go.mod | 64 +++--- contrib/aws/datadog-lambda-go/go.sum | 183 +++++++++--------- .../datadog-lambda-go/internal/internal.go | 16 ++ .../internal/metrics/listener.go | 4 +- .../internal/metrics/listener_test.go | 6 +- .../internal/trace/context_test.go | 20 +- .../internal/trace/listener.go | 6 +- .../internal/wrapper/wrap_handler_test.go | 16 +- .../lambdatest/run_integration_tests.sh | 4 +- instrumentation/packages.go | 13 ++ 10 files changed, 188 insertions(+), 144 deletions(-) create mode 100644 contrib/aws/datadog-lambda-go/internal/internal.go diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod index f99bd0fa60..18050e0b4f 100644 --- a/contrib/aws/datadog-lambda-go/go.mod +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -4,7 +4,7 @@ go 1.24.0 require ( github.com/DataDog/datadog-go/v5 v5.6.0 - github.com/DataDog/dd-trace-go/v2 v2.1.0 + github.com/DataDog/dd-trace-go/v2 v2.4.0-dev github.com/aws/aws-lambda-go v1.46.0 github.com/aws/aws-sdk-go-v2 v1.24.1 github.com/aws/aws-sdk-go-v2/config v1.26.6 @@ -19,20 +19,19 @@ require ( require go.uber.org/atomic v1.11.0 // indirect require ( - github.com/DataDog/appsec-internal-go v1.13.0 // indirect - github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/proto v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/trace v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/util/log v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1 // indirect - github.com/DataDog/datadog-agent/pkg/version v0.66.1 // indirect - github.com/DataDog/go-libddwaf/v4 v4.3.0 // indirect - github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a // indirect + github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/proto v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 // indirect + github.com/DataDog/datadog-agent/pkg/trace v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 // indirect + github.com/DataDog/datadog-agent/pkg/version v0.67.0 // indirect + github.com/DataDog/go-libddwaf/v4 v4.3.2 // indirect + github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 // indirect github.com/DataDog/go-sqllexer v0.1.6 // indirect github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect - github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0 // indirect + github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect github.com/DataDog/sketches-go v1.4.7 // indirect github.com/Masterminds/semver/v3 v3.3.1 // indirect github.com/Microsoft/go-winio v0.6.2 // indirect @@ -52,20 +51,20 @@ require ( github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dustin/go-humanize v1.0.1 // indirect - github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 // indirect github.com/ebitengine/purego v0.8.3 // indirect github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-ole/go-ole v1.3.0 // indirect - github.com/go-viper/mapstructure/v2 v2.2.1 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/protobuf v1.5.4 // indirect github.com/google/uuid v1.6.0 // indirect + github.com/hashicorp/go-version v1.7.0 // indirect github.com/json-iterator/go v1.1.12 // indirect github.com/klauspost/compress v1.18.0 // indirect - github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a // indirect + github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/outcaste-io/ristretto v0.2.3 // indirect github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect github.com/pkg/errors v0.9.1 // indirect @@ -74,32 +73,39 @@ require ( github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect - github.com/shirou/gopsutil/v4 v4.25.1 // indirect + github.com/shirou/gopsutil/v4 v4.25.3 // indirect + github.com/theckman/httpforwarded v0.4.0 // indirect github.com/tinylib/msgp v1.2.5 // indirect github.com/tklauser/go-sysconf v0.3.14 // indirect - github.com/tklauser/numcpus v0.8.0 // indirect + github.com/tklauser/numcpus v0.9.0 // indirect github.com/valyala/bytebufferpool v1.0.0 // indirect github.com/valyala/fasthttp v1.52.0 // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect - go.opentelemetry.io/collector/component v1.28.1 // indirect - go.opentelemetry.io/collector/pdata v1.28.1 // indirect - go.opentelemetry.io/collector/pdata/pprofile v0.122.1 // indirect - go.opentelemetry.io/collector/semconv v0.122.1 // indirect + go.opentelemetry.io/collector/component v1.31.0 // indirect + go.opentelemetry.io/collector/featuregate v1.31.0 // indirect + go.opentelemetry.io/collector/internal/telemetry v0.125.0 // indirect + go.opentelemetry.io/collector/pdata v1.31.0 // indirect + go.opentelemetry.io/collector/semconv v0.125.0 // indirect + go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 // indirect + go.opentelemetry.io/otel/log v0.11.0 // indirect go.opentelemetry.io/otel/metric v1.35.0 // indirect + go.opentelemetry.io/otel/sdk v1.35.0 // indirect go.opentelemetry.io/otel/trace v1.35.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.27.0 // indirect - golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac // indirect - golang.org/x/mod v0.23.0 // indirect - golang.org/x/net v0.39.0 // indirect + golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.40.0 // indirect golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.24.0 // indirect + golang.org/x/text v0.26.0 // indirect golang.org/x/time v0.11.0 // indirect golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 // indirect - google.golang.org/grpc v1.71.1 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 // indirect + google.golang.org/grpc v1.72.0 // indirect google.golang.org/protobuf v1.36.6 // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) + +replace github.com/DataDog/dd-trace-go/v2 => ../../.. diff --git a/contrib/aws/datadog-lambda-go/go.sum b/contrib/aws/datadog-lambda-go/go.sum index 56962cb786..b78bf03702 100644 --- a/contrib/aws/datadog-lambda-go/go.sum +++ b/contrib/aws/datadog-lambda-go/go.sum @@ -1,39 +1,35 @@ github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/DataDog/appsec-internal-go v1.13.0 h1:aO6DmHYsAU8BNFuvYJByhMKGgcQT3WAbj9J/sgAJxtA= -github.com/DataDog/appsec-internal-go v1.13.0/go.mod h1:9YppRCpElfGX+emXOKruShFYsdPq7WEPq/Fen4tYYpk= -github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1 h1:tUnckL/NqYQiSN4ceOe5E/qM9vxmU3p77RdHgXC3VNE= -github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.66.1/go.mod h1:u/ZS2pzrBQ1LokbEvFULjn1SfX+If31uqtz6MJ7UaFo= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1 h1:sZEua4ArlPJyn8DxpIw85iYuDSmCXp1h/utS4jHj8Lo= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.66.1/go.mod h1:NH6IHfS2BEWP3i8JBxr6EIuD4TXprGny8dJZZs5QdwQ= -github.com/DataDog/datadog-agent/pkg/proto v0.66.1 h1:Uqg1gcYDI3RktFr599PWwF05FOEQQgbPMvE9oTSi8NA= -github.com/DataDog/datadog-agent/pkg/proto v0.66.1/go.mod h1:W81BWdx7VxgdshvJuyZhDfWWwJAHROEi4yXX25yzX5A= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1 h1:hA8dg5pgpUXEKFBhcrcb+U6r9h1q3hy+6jYqeC3rZX8= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.66.1/go.mod h1:/AzUUTZn8FZj3xUFJxMh/0/NPqpjsv2z+IMXG/IxRFc= -github.com/DataDog/datadog-agent/pkg/trace v0.66.1 h1:MuZqPlRLEF3dPKtGbn4H4cvdfLIQRncZft6JUtAwy5I= -github.com/DataDog/datadog-agent/pkg/trace v0.66.1/go.mod h1:S+GWyA8N6JT/DHi08xt63kn957wPZs0Kg5ClaY2FPgc= -github.com/DataDog/datadog-agent/pkg/util/log v0.66.1 h1:QE97RJCDO2ZplOqlQM2Oq3S/JKDpI3okdpj+y6rmncU= -github.com/DataDog/datadog-agent/pkg/util/log v0.66.1/go.mod h1:TBGT1NFg9Essf3ypyegWT74PKbIzTuHAHM9V3B+3vXY= -github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1 h1:K7b6+7ZxrC8mvgMJNpCzCshmNUMEkAWRrNWQZvHVIh8= -github.com/DataDog/datadog-agent/pkg/util/scrubber v0.66.1/go.mod h1:1ebZZr2A/0LnD76aK+m1leTOAjKVkJUjCvaw+wTQEcI= -github.com/DataDog/datadog-agent/pkg/version v0.66.1 h1:8eJdgkO/o4/5RlF3u29j0QO8eotaqE+fwKOkIHNJ8RY= -github.com/DataDog/datadog-agent/pkg/version v0.66.1/go.mod h1:LXOHXAHH+vqBwmQKcZa5FgBEi4ECKIC2WsV2Jd9VVJ0= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= +github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= +github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0/go.mod h1:1oPcs3BUTQhiTkmk789rb7ob105MxNV6OuBa28BdukQ= +github.com/DataDog/datadog-agent/pkg/proto v0.67.0 h1:7dO6mKYRb7qSiXEu7Q2mfeKbhp4hykCAULy4BfMPmsQ= +github.com/DataDog/datadog-agent/pkg/proto v0.67.0/go.mod h1:bKVXB7pxBg0wqXF6YSJ+KU6PeCWKDyJj83kUH1ab+7o= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 h1:/DsN4R+IkC6t1+4cHSfkxzLtDl84rBbPC5Wa9srBAoM= +github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0/go.mod h1:Th2LD/IGid5Rza55pzqGu6nUdOv/Rts6wPwLjTyOSTs= +github.com/DataDog/datadog-agent/pkg/trace v0.67.0 h1:dqt+/nObo0JKyaEqIMZgfqGZbx9TfEHpCkrjQ/zzH7k= +github.com/DataDog/datadog-agent/pkg/trace v0.67.0/go.mod h1:zmZoEtKvOnaKHbJGBKH3a4xuyPrSfBaF0ZE3Q3rCoDw= +github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 h1:xrH15QNqeJZkYoXYi44VCIvGvTwlQ3z2iT2QVTGiT7s= +github.com/DataDog/datadog-agent/pkg/util/log v0.67.0/go.mod h1:dfVLR+euzEyg1CeiExgJQq1c1dod42S6IeiRPj8H7Yk= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 h1:aIWF85OKxXGo7rVyqJ7jm7lm2qCQrgyXzYyFuw0T2EQ= +github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0/go.mod h1:Lfap5FuM4b/Pw9IrTuAvWBWZEmXOvZhCya3dYv4G8O0= +github.com/DataDog/datadog-agent/pkg/version v0.67.0 h1:TB8H8r+laB1Qdttvvc6XJVyLGxp8E6j2f2Mh5IPbYmQ= +github.com/DataDog/datadog-agent/pkg/version v0.67.0/go.mod h1:kvAw/WbI7qLAsDI2wHabZfM7Cv2zraD3JA3323GEB+8= github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/dd-trace-go/v2 v2.1.0 h1:hnwcE5qwj/sPbi+GW0O8UDQx5sNCRBwF4m4QRlgWMDA= -github.com/DataDog/dd-trace-go/v2 v2.1.0/go.mod h1:W1W3dR5b77xwozt/o9JqLGh1cdhydIQOHIfzcyQVHVs= -github.com/DataDog/go-libddwaf/v4 v4.3.0 h1:BZfKyLSbY2YMSn7hEBFN1qlDXI2rMEquOeTiRbSg4xk= -github.com/DataDog/go-libddwaf/v4 v4.3.0/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= -github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a h1:+tlbkP/WtD+t0ZDoXIkvqeCd5kj8sl5jN/POUhqFNS8= -github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250603194815-7edb7c2ad56a/go.mod h1:quaQJ+wPN41xEC458FCpTwyROZm3MzmTZ8q8XOXQiPs= +github.com/DataDog/go-libddwaf/v4 v4.3.2 h1:YGvW2Of1C4e1yU+p7iibmhN2zEOgi9XEchbhQjBxb/A= +github.com/DataDog/go-libddwaf/v4 v4.3.2/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 h1:ZRLR9Lbym748e8RznWzmSoK+OfV+8qW6SdNYA4/IqdA= +github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633/go.mod h1:YFoTl1xsMzdSRFIu33oCSPS/3+HZAPGpO3oOM96wXCM= github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= github.com/DataDog/go-sqllexer v0.1.6/go.mod h1:GGpo1h9/BVSN+6NJKaEcJ9Jn44Hqc63Rakeb+24Mjgo= github.com/DataDog/go-tuf v1.1.0-0.5.2 h1:4CagiIekonLSfL8GMHRHcHudo1fQnxELS9g4tiAupQ4= github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= -github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0 h1:GlvoS6hJN0uANUC3fjx72rOgM4StAKYo2HtQGaasC7s= -github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.26.0/go.mod h1:mYQmU7mbHH6DrCaS8N6GZcxwPoeNfyuopUoLQltwSzs= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 h1:5US5SqqhfkZkg/E64uvn7YmeTwnudJHtlPEH/LOT99w= +github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0/go.mod h1:VRo4D6rj92AExpVBlq3Gcuol9Nm1bber12KyxRjKGWw= github.com/DataDog/sketches-go v1.4.7 h1:eHs5/0i2Sdf20Zkj0udVFWuCrXGRFig2Dcfm5rtcTxc= github.com/DataDog/sketches-go v1.4.7/go.mod h1:eAmQ/EBmtSO+nQp7IZMZVRPT4BQTmIc5RZQ+deGlTPM= github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= @@ -87,13 +83,11 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= -github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y= -github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= +github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4 h1:8EXxF+tCLqaVk8AOC29zl2mnhQjwyLxxOTuhUazWRsg= -github.com/eapache/queue/v2 v2.0.0-20230407133247-75960ed334e4/go.mod h1:I5sHm0Y0T1u5YjlyqC5GVArM7aNZRUYtTjmJ8mPJFds= github.com/ebitengine/purego v0.8.3 h1:K+0AjQp63JEZTEMZiwsI9g0+hAMNohwUOtY0RPGexmc= github.com/ebitengine/purego v0.8.3/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= @@ -106,8 +100,8 @@ github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-viper/mapstructure/v2 v2.2.1 h1:ZAaOCxANMuZx5RCeg0mBdEZk7DZasvvZIxtHqx8aGss= -github.com/go-viper/mapstructure/v2 v2.2.1/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= @@ -127,6 +121,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= +github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= +github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= @@ -137,17 +133,18 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a h1:3Bm7EwfUQUvhNeKIkUct/gl9eod1TcXuj8stxvi/GoI= -github.com/lufia/plan9stats v0.0.0-20240226150601-1dcf7310316a/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= +github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0= +github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.122.0 h1:n0nWcGanaHanlih+YRp8etj1/fYZoQFRk+7+/J85dpU= -github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.122.0/go.mod h1:MMvJIC26DIEZo5DR4Ub/WJD1aPVxKGpgJolXxTtjgLE= -github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.122.0 h1:zuqwUU8P+IqQMHvMYHlTBXt8lRn1Zu2B9QNAscLP+9A= -github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.122.0/go.mod h1:vtHjtQU0UlTHBthmnTv8nK0h0GFWQhgxtOVbav87YoU= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= +github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0 h1:0dOJCEtabevxxDQmxed69oMzSw+gb3ErCnFwFYZFu0M= +github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0/go.mod h1:QwzQhtxPThXMUDW1XRXNQ+l0GrI2BRsvNhX6ZuKyAds= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0 h1:F68/Nbpcvo3JZpaWlRUDJtG7xs8FHBZ7A8GOMauDkyc= +github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0/go.mod h1:haO4cJtAk05Y0p7NO9ME660xxtSh54ifCIIT7+PO9C0= github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= @@ -169,8 +166,8 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/secure-systems-lab/go-securesystemslib v0.9.0 h1:rf1HIbL64nUpEIZnjLZ3mcNEL9NBPB0iuVjyxvq3LZc= github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/woA/peqr+L0joiRXbPpQ042GgJckkFgw= -github.com/shirou/gopsutil/v4 v4.25.1 h1:QSWkTc+fu9LTAWfkZwZ6j8MSUk4A2LV7rbH0ZqmLjXs= -github.com/shirou/gopsutil/v4 v4.25.1/go.mod h1:RoUCUpndaJFtT+2zsZzzmhvbfGoDCJ7nFXKJf8GqJbI= +github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= +github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= @@ -189,12 +186,14 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/theckman/httpforwarded v0.4.0 h1:N55vGJT+6ojTnLY3LQCNliJC4TW0P0Pkeys1G1WpX2w= +github.com/theckman/httpforwarded v0.4.0/go.mod h1:GVkFynv6FJreNbgH/bpOU9ITDZ7a5WuzdNCtIMI1pVI= github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= -github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= -github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= +github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= +github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= @@ -210,38 +209,48 @@ github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= -go.opentelemetry.io/collector/component v1.28.1 h1:JjwfvLR0UdadRDAANAdM4mOSwGmfGO3va2X+fdk4YdA= -go.opentelemetry.io/collector/component v1.28.1/go.mod h1:jwZRDML3tXo1whueZdRf+y6z3DeEYTLPBmb/O1ujB40= -go.opentelemetry.io/collector/component/componentstatus v0.122.1 h1:zMQC0y8ZBITa87GOwEANdOoAox5I4UgaIHxY79nwCbk= -go.opentelemetry.io/collector/component/componentstatus v0.122.1/go.mod h1:ZYwOgoXyPu4gGqfQ5DeaEpStpUCD/Clctz4rMd9qQYw= -go.opentelemetry.io/collector/component/componenttest v0.122.1 h1:HE4oeLub2FWVTUzCQG6SWwfnJfcK1FMknXhGQ2gOxnY= -go.opentelemetry.io/collector/component/componenttest v0.122.1/go.mod h1:o3Xq6z3C0aVhrd/fD56aKxShrILVnHnbgQVP5NoFuic= -go.opentelemetry.io/collector/consumer v1.28.1 h1:3lHW2e0i7kEkbDqK1vErA8illqPpwDxMzgc5OUDsJ0Y= -go.opentelemetry.io/collector/consumer v1.28.1/go.mod h1:g0T16JPMYFN6T2noh+1YBxJSt5i5Zp+Y0Y6pvkMqsDQ= -go.opentelemetry.io/collector/consumer/consumertest v0.122.1 h1:LKkLMdWwJCuOYyCMVzwc0OG9vncIqpl8Tp9+H8RikNg= -go.opentelemetry.io/collector/consumer/consumertest v0.122.1/go.mod h1:pYqWgx62ou3uUn8nlt2ohRyKod+7xLTf/uA3YfRwVkA= -go.opentelemetry.io/collector/consumer/xconsumer v0.122.1 h1:iK1hGbho/XICdBfGb4MnKwF9lnhLmv09yQ4YlVm+LGo= -go.opentelemetry.io/collector/consumer/xconsumer v0.122.1/go.mod h1:xYbRPP1oWcYUUDQJTlv78M/rlYb+qE4weiv++ObZRSU= -go.opentelemetry.io/collector/pdata v1.28.1 h1:ORl5WLpQJvjzBVpHu12lqKMdcf/qDBwRXMcUubhybiQ= -go.opentelemetry.io/collector/pdata v1.28.1/go.mod h1:asKE8MD/4SOKz1mCrGdAz4VO2U2HUNg8A6094uK7pq0= -go.opentelemetry.io/collector/pdata/pprofile v0.122.1 h1:25Fs0eL/J/M2ZEaVplesbI1H7pYx462zUUVxVOszpOg= -go.opentelemetry.io/collector/pdata/pprofile v0.122.1/go.mod h1:+jSjgb4zRnNmr1R/zgVLVyTVSm9irfGrvGTrk3lDxSE= -go.opentelemetry.io/collector/pdata/testdata v0.122.1 h1:9DO8nUUnPAGYMKmrep6wLAfOHprvKY4w/7LpE4jldPQ= -go.opentelemetry.io/collector/pdata/testdata v0.122.1/go.mod h1:hYdNrn8KxFwq1nf44YYRgNhDjJTBzoyEr/Qa26pN0t4= -go.opentelemetry.io/collector/pipeline v0.122.1 h1:f0uuiDmanVyKwfYo6cWveJsGbLXidV7i+Z7u8QJwWxI= -go.opentelemetry.io/collector/pipeline v0.122.1/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= -go.opentelemetry.io/collector/processor v0.122.1 h1:AvZvEujq8+FYdJsm9lmAMwuuae5Y2/vKIkOJwsoxsxQ= -go.opentelemetry.io/collector/processor v0.122.1/go.mod h1:nYKctftba7SbdLml6LxgIrnYRXCShDe2bnNWjTIpF7g= -go.opentelemetry.io/collector/processor/processortest v0.122.1 h1:n4UOx1mq+kLaRiHGsu7vBLq+EGXfzWhSxyFweMjMl54= -go.opentelemetry.io/collector/processor/processortest v0.122.1/go.mod h1:8/NRWx18tNJMBwCQ8/YPWr4qsFUrwk27qE7/dXoJb1M= -go.opentelemetry.io/collector/processor/xprocessor v0.122.1 h1:Wfv4/7n4YK1HunAVTMS6yf0xmDjCkftJ6EECNcSwzfs= -go.opentelemetry.io/collector/processor/xprocessor v0.122.1/go.mod h1:9zMW3NQ9+DzcJ1cUq5BhZg3ajoUEMGhNY0ZdYjpX+VI= -go.opentelemetry.io/collector/semconv v0.122.1 h1:WLzDi3QC4/+LpNMLY90zn5aMDJKyqg/ujW2O4T4sxHg= -go.opentelemetry.io/collector/semconv v0.122.1/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= +go.opentelemetry.io/collector/component v1.31.0 h1:9LzU8X1RhV3h8/QsAoTX23aFUfoJ3EUc9O/vK+hFpSI= +go.opentelemetry.io/collector/component v1.31.0/go.mod h1:JbZl/KywXJxpUXPbt96qlEXJSym1zQ2hauMxYMuvlxM= +go.opentelemetry.io/collector/component/componentstatus v0.125.0 h1:zlxGQZYd9kknRZSjRpOYW5SBjl0a5zYFYRPbreobXoU= +go.opentelemetry.io/collector/component/componentstatus v0.125.0/go.mod h1:bHXc2W8bqqo9adOvCgvhcO7pYzJOSpyV4cuQ1wiIl04= +go.opentelemetry.io/collector/component/componenttest v0.125.0 h1:E2mpnMQbkMpYoZ3Q8pHx4kod7kedjwRs1xqDpzCe/84= +go.opentelemetry.io/collector/component/componenttest v0.125.0/go.mod h1:pQtsE1u/SPZdTphP5BZP64XbjXSq6wc+mDut5Ws/JDI= +go.opentelemetry.io/collector/consumer v1.31.0 h1:L+y66ywxLHnAxnUxv0JDwUf5bFj53kMxCCyEfRKlM7s= +go.opentelemetry.io/collector/consumer v1.31.0/go.mod h1:rPsqy5ni+c6xNMUkOChleZYO/nInVY6eaBNZ1FmWJVk= +go.opentelemetry.io/collector/consumer/consumertest v0.125.0 h1:TUkxomGS4DAtjBvcWQd2UY4FDLLEKMQD6iOIDUr/5dM= +go.opentelemetry.io/collector/consumer/consumertest v0.125.0/go.mod h1:vkHf3y85cFLDHARO/cTREVjLjOPAV+cQg7lkC44DWOY= +go.opentelemetry.io/collector/consumer/xconsumer v0.125.0 h1:oTreUlk1KpMSWwuHFnstW+orrjGTyvs2xd3o/Dpy+hI= +go.opentelemetry.io/collector/consumer/xconsumer v0.125.0/go.mod h1:FX0G37r0W+wXRgxxFtwEJ4rlsCB+p0cIaxtU3C4hskw= +go.opentelemetry.io/collector/featuregate v1.31.0 h1:20q7plPQZwmAiaYAa6l1m/i2qDITZuWlhjr4EkmeQls= +go.opentelemetry.io/collector/featuregate v1.31.0/go.mod h1:Y/KsHbvREENKvvN9RlpiWk/IGBK+CATBYzIIpU7nccc= +go.opentelemetry.io/collector/internal/telemetry v0.125.0 h1:6lcGOxw3dAg7LfXTKdN8ZjR+l7KvzLdEiPMhhLwG4r4= +go.opentelemetry.io/collector/internal/telemetry v0.125.0/go.mod h1:5GyFslLqjZgq1DZTtFiluxYhhXrCofHgOOOybodDPGE= +go.opentelemetry.io/collector/pdata v1.31.0 h1:P5WuLr1l2JcIvr6Dw2hl01ltp2ZafPnC4Isv+BLTBqU= +go.opentelemetry.io/collector/pdata v1.31.0/go.mod h1:m41io9nWpy7aCm/uD1L9QcKiZwOP0ldj83JEA34dmlk= +go.opentelemetry.io/collector/pdata/pprofile v0.125.0 h1:Qqlx8w1HpiYZ9RQqjmMQIysI0cHNO1nh3E/fCTeFysA= +go.opentelemetry.io/collector/pdata/pprofile v0.125.0/go.mod h1:p/yK023VxAp8hm27/1G5DPTcMIpnJy3cHGAFUQZGyaQ= +go.opentelemetry.io/collector/pdata/testdata v0.125.0 h1:due1Hl0EEVRVwfCkiamRy5E8lS6yalv0lo8Zl/SJtGw= +go.opentelemetry.io/collector/pdata/testdata v0.125.0/go.mod h1:1GpEWlgdMrd+fWsBk37ZC2YmOP5YU3gFQ4rWuCu9g24= +go.opentelemetry.io/collector/pipeline v0.125.0 h1:oitBgcAFqntDB4ihQJUHJSQ8IHqKFpPkaTVbTYdIUzM= +go.opentelemetry.io/collector/pipeline v0.125.0/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= +go.opentelemetry.io/collector/processor v1.31.0 h1:+u7sBUpnCBsHYoALp4hfr9VEjLHHYa4uKENGITe0K9Q= +go.opentelemetry.io/collector/processor v1.31.0/go.mod h1:5hDYJ7/hTdfd2tF2Rj5Hs6+mfyFz2O7CaPzVvW1qHQc= +go.opentelemetry.io/collector/processor/processorhelper v0.125.0 h1:QRpX7oFW88DAZhy+Q93npklRoaQr8ue0GKpeup7C/Fk= +go.opentelemetry.io/collector/processor/processorhelper v0.125.0/go.mod h1:oXRvslUuN62wErcoJrcEJYoTXu5wHyNyJsE+/a9Cc9s= +go.opentelemetry.io/collector/processor/processortest v0.125.0 h1:ZVAN4iZPDcWhpzKqnuok2NIuS5hwGVVQUOWkJFR12tA= +go.opentelemetry.io/collector/processor/processortest v0.125.0/go.mod h1:VAw0IRG35cWTBjBtreXeXJEgqkRegfjrH/EuLhNX2+I= +go.opentelemetry.io/collector/processor/xprocessor v0.125.0 h1:VWYPMW1VmDq6xB7M5SYjBpQCCIq3MhQ3W++wU47QpZM= +go.opentelemetry.io/collector/processor/xprocessor v0.125.0/go.mod h1:bCxUyFVlksANg8wjYZqWVsRB33lkLQ294rTrju/IZiM= +go.opentelemetry.io/collector/semconv v0.125.0 h1:SyRP617YGvNSWRSKMy7Lbk9RaJSR+qFAAfyxJOeZe4s= +go.opentelemetry.io/collector/semconv v0.125.0/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= +go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 h1:ojdSRDvjrnm30beHOmwsSvLpoRF40MlwNCA+Oo93kXU= +go.opentelemetry.io/contrib/bridges/otelzap v0.10.0/go.mod h1:oTTm4g7NEtHSV2i/0FeVdPaPgUIZPfQkFbq0vbzqnv0= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= +go.opentelemetry.io/otel/log v0.11.0 h1:c24Hrlk5WJ8JWcwbQxdBqxZdOK7PcP/LFtOtwpDTe3Y= +go.opentelemetry.io/otel/log v0.11.0/go.mod h1:U/sxQ83FPmT29trrifhQg+Zj2lo1/IPN1PF6RTFqdwc= go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= @@ -262,22 +271,22 @@ go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE= -golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc= -golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac h1:l5+whBCLH3iH2ZNHYLbAe58bo7yrN4mVcnkHDYz5vvs= -golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac/go.mod h1:hH+7mtFmImwwcMvScyxUhjuVHR3HGaDPMn9rMSUUbxo= +golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= +golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM= -golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= +golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY= -golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E= +golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= +golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -299,8 +308,8 @@ golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0= -golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU= +golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -316,10 +325,10 @@ golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSm golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 h1:ZSlhAUqC4r8TPzqLXQ0m3upBNZeF+Y8jQ3c4CR3Ujms= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99/go.mod h1:LuRYeWDFV6WOn90g357N17oMCaxpgCnbi/44qJvDn2I= -google.golang.org/grpc v1.71.1 h1:ffsFWr7ygTUscGPI0KKK6TLrGz0476KUvvsbqWK0rPI= -google.golang.org/grpc v1.71.1/go.mod h1:H0GRtasmQOh9LkFoCPDu3ZrwUtD1YGE+b2vYBYd/8Ec= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 h1:29cjnHVylHwTzH66WfFZqgSQgnxzvWE+jvBwpZCLRxY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= +google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM= +google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM= google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -330,5 +339,5 @@ gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -k8s.io/apimachinery v0.31.4 h1:8xjE2C4CzhYVm9DGf60yohpNUh5AEBnPxCryPBECmlM= -k8s.io/apimachinery v0.31.4/go.mod h1:rsPdaZJfTfLsNJSQzNHQvYoTmxhoOEofxtOsF3rtsMo= +k8s.io/apimachinery v0.32.3 h1:JmDuDarhDmA/Li7j3aPrwhpNBA94Nvk5zLeOge9HH1U= +k8s.io/apimachinery v0.32.3/go.mod h1:GpHVgxoKlTxClKcteaeuF1Ul/lDVb74KpZcxcmLDElE= diff --git a/contrib/aws/datadog-lambda-go/internal/internal.go b/contrib/aws/datadog-lambda-go/internal/internal.go new file mode 100644 index 0000000000..07fbb91ff4 --- /dev/null +++ b/contrib/aws/datadog-lambda-go/internal/internal.go @@ -0,0 +1,16 @@ +// Unless explicitly stated otherwise all files in this repository are licensed +// under the Apache License Version 2.0. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2025 Datadog, Inc. + +package internal + +import ( + "github.com/DataDog/dd-trace-go/v2/instrumentation" +) + +var Instr *instrumentation.Instrumentation + +func init() { + Instr = instrumentation.Load(instrumentation.PackageAWSDatadogLambdaGo) +} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go index 3bb21ff0fe..a5d52c6bed 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -17,9 +17,9 @@ import ( "github.com/aws/aws-lambda-go/lambdacontext" "github.com/DataDog/datadog-go/v5/statsd" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" - "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/version" ) type ( @@ -248,7 +248,7 @@ func getEnhancedMetricsTags(ctx context.Context) []string { memorySize := fmt.Sprintf("memorysize:%d", lambdacontext.MemoryLimitInMB) coldStart := fmt.Sprintf("cold_start:%t", isColdStart.(bool)) resource := fmt.Sprintf("resource:%s", lambdacontext.FunctionName) - datadogLambda := fmt.Sprintf("datadog_lambda:v%s", version.DDLambdaVersion) + datadogLambda := fmt.Sprintf("datadog_lambda:v%s", internal.Instr.Version()) tags := []string{functionName, region, accountId, memorySize, coldStart, datadogLambda} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go index f0e1ff52a4..034cffe21b 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -19,9 +19,9 @@ import ( "testing" "time" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" - "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/version" "github.com/aws/aws-lambda-go/lambdacontext" "github.com/stretchr/testify/assert" @@ -150,7 +150,7 @@ func TestGetEnhancedMetricsTags(t *testing.T) { } tags := getEnhancedMetricsTags(lambdacontext.NewContext(ctx, lc)) - assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:v" + version.DDLambdaVersion}) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:v" + internal.Instr.Version()}) } func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { @@ -165,7 +165,7 @@ func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { } tags := getEnhancedMetricsTags((lambdacontext.NewContext(ctx, lc))) - assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:v" + version.DDLambdaVersion}) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:v" + internal.Instr.Version()}) } func TestGetEnhancedMetricsTagsNoLambdaContext(t *testing.T) { diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go index fb1ff892ee..9633fa12b7 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go @@ -68,7 +68,7 @@ func loadRawJSON(t *testing.T, filename string) *json.RawMessage { } func TestGetDatadogTraceContextForTraceMetadataNonProxyEvent(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-with-headers.json") headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.True(t, ok) @@ -83,7 +83,7 @@ func TestGetDatadogTraceContextForTraceMetadataNonProxyEvent(t *testing.T) { func TestGetDatadogTraceContextForTraceMetadataWithMixedCaseHeaders(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/non-proxy-with-mixed-case-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-with-mixed-case-headers.json") headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.True(t, ok) @@ -98,7 +98,7 @@ func TestGetDatadogTraceContextForTraceMetadataWithMixedCaseHeaders(t *testing.T func TestGetDatadogTraceContextForTraceMetadataWithMissingSamplingPriority(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/non-proxy-with-missing-sampling-priority.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-with-missing-sampling-priority.json") headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.True(t, ok) @@ -113,7 +113,7 @@ func TestGetDatadogTraceContextForTraceMetadataWithMissingSamplingPriority(t *te func TestGetDatadogTraceContextForInvalidData(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/invalid.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/invalid.json") _, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.False(t, ok) @@ -121,7 +121,7 @@ func TestGetDatadogTraceContextForInvalidData(t *testing.T) { func TestGetDatadogTraceContextForMissingData(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/non-proxy-no-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json") _, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.False(t, ok) @@ -173,7 +173,7 @@ func TestGetDatadogTraceContextFromContextObject(t *testing.T) { }, } - ev := loadRawJSON(t, "../testdata/non-proxy-no-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json") for _, test := range testcases { t.Run(test.traceID+test.parentID+test.samplingPriority, func(t *testing.T) { ctx := mockTraceContext(test.traceID, test.parentID, test.samplingPriority) @@ -244,7 +244,7 @@ func TestXrayTraceContextWithSegment(t *testing.T) { func TestContextWithRootTraceContextNoDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/apig-event-no-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, false, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) @@ -255,7 +255,7 @@ func TestContextWithRootTraceContextNoDatadogContext(t *testing.T) { func TestContextWithRootTraceContextWithDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-with-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, false, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) @@ -270,7 +270,7 @@ func TestContextWithRootTraceContextWithDatadogContext(t *testing.T) { func TestContextWithRootTraceContextMergeXrayTracesNoDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/apig-event-no-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, true, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) @@ -285,7 +285,7 @@ func TestContextWithRootTraceContextMergeXrayTracesNoDatadogContext(t *testing.T func TestContextWithRootTraceContextMergeXrayTracesWithDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") + ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-with-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, true, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener.go b/contrib/aws/datadog-lambda-go/internal/trace/listener.go index 3e3991776f..2e152ddae2 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener.go @@ -12,9 +12,9 @@ import ( "os" "strings" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" - "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/version" "github.com/DataDog/dd-trace-go/v2/ddtrace" ddotel "github.com/DataDog/dd-trace-go/v2/ddtrace/opentelemetry" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" @@ -161,8 +161,8 @@ func startFunctionExecutionSpan(ctx context.Context, mergeXrayTraces bool, isDdS ddtracer.Tag("request_id", lambdaCtx.AwsRequestID), ddtracer.Tag("resource_names", lambdacontext.FunctionName), ddtracer.Tag("functionname", strings.ToLower(lambdacontext.FunctionName)), - ddtracer.Tag("datadog_lambda", version.DDLambdaVersion), - ddtracer.Tag("dd_trace", version.DDTraceVersion), + ddtracer.Tag("datadog_lambda", internal.Instr.Version()), + ddtracer.Tag("dd_trace", internal.Instr.Version()), } if parentSpanContext != nil { diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go index 687fbf963d..922c350d6c 100644 --- a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go @@ -152,7 +152,7 @@ func TestWrapHandlerAPIGEvent(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "../testdata/apig-event-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -168,7 +168,7 @@ func TestWrapHandlerNonProxyEvent(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -184,7 +184,7 @@ func TestWrapHandlerEventArgumentOnly(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -213,7 +213,7 @@ func TestWrapHandlerNoArguments(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -228,7 +228,7 @@ func TestWrapHandlerInvalidData(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "../testdata/invalid.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/invalid.json", handler) assert.False(t, called) assert.Error(t, err) @@ -244,7 +244,7 @@ func TestWrapHandlerReturnsError(t *testing.T) { return 5, defaultErr } - _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.Equal(t, defaultErr, err) @@ -260,7 +260,7 @@ func TestWrapHandlerReturnsErrorOnly(t *testing.T) { return defaultErr } - _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.Equal(t, defaultErr, err) @@ -289,7 +289,7 @@ func TestWrapHandlerInterfaceWithListeners(t *testing.T) { return 5, nil }) - _, response, err := runHandlerInterfaceWithJSON(t, "../testdata/apig-event-no-headers.json", handler) + _, response, err := runHandlerInterfaceWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) diff --git a/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh b/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh index 56de1e3bdf..f718b4bcdf 100755 --- a/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh +++ b/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh @@ -40,8 +40,8 @@ if [ -n "$UPDATE_SNAPSHOTS" ]; then fi echo "Building Go binaries" -CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o build/hello/bootstrap hello/main.go -CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o build/error/bootstrap error/main.go +cd hello && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o ../build/hello/bootstrap && cd .. +cd error && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o ../build/error/bootstrap && cd .. zip -j build/hello.zip build/hello/bootstrap zip -j build/error.zip build/error/bootstrap diff --git a/instrumentation/packages.go b/instrumentation/packages.go index 3c7d0202a7..a7bb951b20 100644 --- a/instrumentation/packages.go +++ b/instrumentation/packages.go @@ -18,6 +18,7 @@ const ( Package99DesignsGQLGen Package = "99designs/gqlgen" PackageAWSSDKGo Package = "aws/aws-sdk-go" PackageAWSSDKGoV2 Package = "aws/aws-sdk-go-v2" + PackageAWSDatadogLambdaGo Package = "aws/datadog-lambda-go" PackageBradfitzGoMemcache Package = "bradfitz/gomemcache" PackageGCPPubsub Package = "cloud.google.com/go/pubsub.v1" PackageGCPPubsubV2 Package = "cloud.google.com/go/pubsub.v2" @@ -167,6 +168,18 @@ var packages = map[Package]PackageInfo{ }, }, }, + PackageAWSDatadogLambdaGo: { + TracedPackage: "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go", + EnvVarPrefix: "LAMBDA", + naming: map[Component]componentNames{ + ComponentDefault: { + useDDServiceV0: false, + buildServiceNameV0: staticName("aws.lambda"), + buildOpNameV0: staticName("aws.lambda.invoke"), + buildOpNameV1: staticName("aws.lambda.invoke"), + }, + }, + }, PackageBradfitzGoMemcache: { TracedPackage: "github.com/bradfitz/gomemcache", EnvVarPrefix: "MEMCACHE", From 0de2caa38d95789569f369f391de1d2be9aa04aa Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Tue, 16 Sep 2025 14:50:23 -0400 Subject: [PATCH 08/25] update go.work file for datadog-lambda-go --- go.work | 1 + 1 file changed, 1 insertion(+) diff --git a/go.work b/go.work index 139309cdc0..c31339584e 100644 --- a/go.work +++ b/go.work @@ -8,6 +8,7 @@ use ( ./contrib/Shopify/sarama ./contrib/aws/aws-sdk-go ./contrib/aws/aws-sdk-go-v2 + ./contrib/aws/datadog-lambda-go ./contrib/bradfitz/gomemcache ./contrib/cloud.google.com/go/pubsub.v1 ./contrib/cloud.google.com/go/pubsub.v2 From 13e4222133b7850975eccd52928a8e07c7b9b045 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Tue, 16 Sep 2025 15:03:07 -0400 Subject: [PATCH 09/25] remove lambdatest(integration test) for now --- .../datadog-lambda-go/lambdatest/README.md | 16 - .../datadog-lambda-go/lambdatest/error/go.mod | 110 ------ .../datadog-lambda-go/lambdatest/error/go.sum | 343 ------------------ .../lambdatest/error/main.go | 28 -- .../datadog-lambda-go/lambdatest/hello/go.mod | 113 ------ .../datadog-lambda-go/lambdatest/hello/go.sum | 343 ------------------ .../lambdatest/hello/main.go | 53 --- .../input_events/api-gateway-get.json | 55 --- .../datadog-lambda-go/lambdatest/package.json | 4 - .../lambdatest/parse-json.js | 17 - .../lambdatest/run_integration_tests.sh | 210 ----------- .../lambdatest/serverless.yml | 37 -- .../lambdatest/snapshots/logs/error.log | 46 --- .../lambdatest/snapshots/logs/hello.log | 45 --- .../return_values/error_api-gateway-get.json | 1 - .../return_values/hello_api-gateway-get.json | 6 - 16 files changed, 1427 deletions(-) delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/README.md delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/error/go.mod delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/error/go.sum delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/error/main.go delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/hello/main.go delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/package.json delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/parse-json.js delete mode 100755 contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/serverless.yml delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json delete mode 100644 contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json diff --git a/contrib/aws/datadog-lambda-go/lambdatest/README.md b/contrib/aws/datadog-lambda-go/lambdatest/README.md deleted file mode 100644 index af1b0c6cb3..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/README.md +++ /dev/null @@ -1,16 +0,0 @@ -# Integration tests - - -## Requirements - -- Node -- Go -- DD_API_KEY - -## Running - -```bash -DD_API_KEY= aws-vault exec sandbox-account-admin -- ./run_integration_tests.sh -``` - -Use `UPDATE_SNAPSHOTS=true` to update snapshots diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod deleted file mode 100644 index 58f435fe83..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/go.mod +++ /dev/null @@ -1,110 +0,0 @@ -module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/lambdatest/error/v2 - -go 1.24.0 - -require ( - github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 v2.4.0-dev - github.com/aws/aws-lambda-go v1.46.0 -) - -require ( - github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/proto v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 // indirect - github.com/DataDog/datadog-agent/pkg/trace v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/version v0.67.0 // indirect - github.com/DataDog/datadog-go/v5 v5.6.0 // indirect - github.com/DataDog/dd-trace-go/v2 v2.1.0 // indirect - github.com/DataDog/go-libddwaf/v4 v4.3.2 // indirect - github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 // indirect - github.com/DataDog/go-sqllexer v0.1.6 // indirect - github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect - github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect - github.com/DataDog/sketches-go v1.4.7 // indirect - github.com/Masterminds/semver/v3 v3.3.1 // indirect - github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/andybalholm/brotli v1.1.0 // indirect - github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect - github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect - github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect - github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect - github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect - github.com/aws/aws-xray-sdk-go/v2 v2.0.0 // indirect - github.com/aws/smithy-go v1.19.0 // indirect - github.com/cenkalti/backoff/v4 v4.2.1 // indirect - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect - github.com/dustin/go-humanize v1.0.1 // indirect - github.com/ebitengine/purego v0.8.3 // indirect - github.com/go-logr/logr v1.4.2 // indirect - github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-ole/go-ole v1.3.0 // indirect - github.com/go-viper/mapstructure/v2 v2.4.0 // indirect - github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/protobuf v1.5.4 // indirect - github.com/google/uuid v1.6.0 // indirect - github.com/hashicorp/go-version v1.7.0 // indirect - github.com/json-iterator/go v1.1.12 // indirect - github.com/klauspost/compress v1.18.0 // indirect - github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect - github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect - github.com/outcaste-io/ristretto v0.2.3 // indirect - github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect - github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect - github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect - github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect - github.com/shirou/gopsutil/v4 v4.25.3 // indirect - github.com/sony/gobreaker v0.5.0 // indirect - github.com/theckman/httpforwarded v0.4.0 // indirect - github.com/tinylib/msgp v1.2.5 // indirect - github.com/tklauser/go-sysconf v0.3.14 // indirect - github.com/tklauser/numcpus v0.9.0 // indirect - github.com/valyala/bytebufferpool v1.0.0 // indirect - github.com/valyala/fasthttp v1.52.0 // indirect - github.com/yusufpapurcu/wmi v1.2.4 // indirect - go.opentelemetry.io/auto/sdk v1.1.0 // indirect - go.opentelemetry.io/collector/component v1.31.0 // indirect - go.opentelemetry.io/collector/featuregate v1.31.0 // indirect - go.opentelemetry.io/collector/internal/telemetry v0.125.0 // indirect - go.opentelemetry.io/collector/pdata v1.31.0 // indirect - go.opentelemetry.io/collector/semconv v0.125.0 // indirect - go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 // indirect - go.opentelemetry.io/otel v1.35.0 // indirect - go.opentelemetry.io/otel/log v0.11.0 // indirect - go.opentelemetry.io/otel/metric v1.35.0 // indirect - go.opentelemetry.io/otel/sdk v1.35.0 // indirect - go.opentelemetry.io/otel/trace v1.35.0 // indirect - go.uber.org/atomic v1.11.0 // indirect - go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.27.0 // indirect - golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect - golang.org/x/mod v0.25.0 // indirect - golang.org/x/net v0.40.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.26.0 // indirect - golang.org/x/time v0.11.0 // indirect - golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 // indirect - google.golang.org/grpc v1.72.0 // indirect - google.golang.org/protobuf v1.36.6 // indirect - gopkg.in/ini.v1 v1.67.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect -) - -replace github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 => ../../ - -replace github.com/DataDog/dd-trace-go/v2 => ../../../../.. diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum b/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum deleted file mode 100644 index b78bf03702..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/go.sum +++ /dev/null @@ -1,343 +0,0 @@ -github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= -github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= -github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0/go.mod h1:1oPcs3BUTQhiTkmk789rb7ob105MxNV6OuBa28BdukQ= -github.com/DataDog/datadog-agent/pkg/proto v0.67.0 h1:7dO6mKYRb7qSiXEu7Q2mfeKbhp4hykCAULy4BfMPmsQ= -github.com/DataDog/datadog-agent/pkg/proto v0.67.0/go.mod h1:bKVXB7pxBg0wqXF6YSJ+KU6PeCWKDyJj83kUH1ab+7o= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 h1:/DsN4R+IkC6t1+4cHSfkxzLtDl84rBbPC5Wa9srBAoM= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0/go.mod h1:Th2LD/IGid5Rza55pzqGu6nUdOv/Rts6wPwLjTyOSTs= -github.com/DataDog/datadog-agent/pkg/trace v0.67.0 h1:dqt+/nObo0JKyaEqIMZgfqGZbx9TfEHpCkrjQ/zzH7k= -github.com/DataDog/datadog-agent/pkg/trace v0.67.0/go.mod h1:zmZoEtKvOnaKHbJGBKH3a4xuyPrSfBaF0ZE3Q3rCoDw= -github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 h1:xrH15QNqeJZkYoXYi44VCIvGvTwlQ3z2iT2QVTGiT7s= -github.com/DataDog/datadog-agent/pkg/util/log v0.67.0/go.mod h1:dfVLR+euzEyg1CeiExgJQq1c1dod42S6IeiRPj8H7Yk= -github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 h1:aIWF85OKxXGo7rVyqJ7jm7lm2qCQrgyXzYyFuw0T2EQ= -github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0/go.mod h1:Lfap5FuM4b/Pw9IrTuAvWBWZEmXOvZhCya3dYv4G8O0= -github.com/DataDog/datadog-agent/pkg/version v0.67.0 h1:TB8H8r+laB1Qdttvvc6XJVyLGxp8E6j2f2Mh5IPbYmQ= -github.com/DataDog/datadog-agent/pkg/version v0.67.0/go.mod h1:kvAw/WbI7qLAsDI2wHabZfM7Cv2zraD3JA3323GEB+8= -github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= -github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/go-libddwaf/v4 v4.3.2 h1:YGvW2Of1C4e1yU+p7iibmhN2zEOgi9XEchbhQjBxb/A= -github.com/DataDog/go-libddwaf/v4 v4.3.2/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= -github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 h1:ZRLR9Lbym748e8RznWzmSoK+OfV+8qW6SdNYA4/IqdA= -github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633/go.mod h1:YFoTl1xsMzdSRFIu33oCSPS/3+HZAPGpO3oOM96wXCM= -github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= -github.com/DataDog/go-sqllexer v0.1.6/go.mod h1:GGpo1h9/BVSN+6NJKaEcJ9Jn44Hqc63Rakeb+24Mjgo= -github.com/DataDog/go-tuf v1.1.0-0.5.2 h1:4CagiIekonLSfL8GMHRHcHudo1fQnxELS9g4tiAupQ4= -github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= -github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= -github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= -github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 h1:5US5SqqhfkZkg/E64uvn7YmeTwnudJHtlPEH/LOT99w= -github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0/go.mod h1:VRo4D6rj92AExpVBlq3Gcuol9Nm1bber12KyxRjKGWw= -github.com/DataDog/sketches-go v1.4.7 h1:eHs5/0i2Sdf20Zkj0udVFWuCrXGRFig2Dcfm5rtcTxc= -github.com/DataDog/sketches-go v1.4.7/go.mod h1:eAmQ/EBmtSO+nQp7IZMZVRPT4BQTmIc5RZQ+deGlTPM= -github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= -github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= -github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= -github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= -github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= -github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= -github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= -github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= -github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= -github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= -github.com/aws/aws-sdk-go-v2/config v1.26.6/go.mod h1:uKU6cnDmYCvJ+pxO9S4cWDb2yWWIH5hra+32hVh1MI4= -github.com/aws/aws-sdk-go-v2/credentials v1.16.16 h1:8q6Rliyv0aUFAVtzaldUEcS+T5gbadPbWdV1WcAddK8= -github.com/aws/aws-sdk-go-v2/credentials v1.16.16/go.mod h1:UHVZrdUsv63hPXFo1H7c5fEneoVo9UXiz36QG1GEPi0= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 h1:c5I5iH+DZcH3xOIMlz3/tCKJDaHFwYEmxvlh2fAcFo8= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11/go.mod h1:cRrYDYAMUohBJUtUnOhydaMHtiK/1NZ0Otc9lIb6O0Y= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw= -github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 h1:n3GDfwqF2tzEkXlv5cuy4iy7LpKDtqDMcNLfZDu9rls= -github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 h1:DBYTXwIGQSGs9w4jKm60F5dmCQ3EEruxdc0MFh+3EY4= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10/go.mod h1:wohMUQiFdzo0NtxbBg0mSRGZ4vL3n0dKjLTINdcIino= -github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 h1:W9PbZAZAEcelhhjb7KuwUtf+Lbc+i7ByYJRuWLlnxyQ= -github.com/aws/aws-sdk-go-v2/service/kms v1.27.9/go.mod h1:2tFmR7fQnOdQlM2ZCEPpFnBIQD1U8wmXmduBgZbOag0= -github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 h1:eajuO3nykDPdYicLlP3AGgOyVN3MOlFmZv7WGTuJPow= -github.com/aws/aws-sdk-go-v2/service/sso v1.18.7/go.mod h1:+mJNDdF+qiUlNKNC3fxn74WWNN+sOiGOEImje+3ScPM= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w1NmfkfiSK8mS4zOx3BA= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= -github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= -github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= -github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= -github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= -github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= -github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= -github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= -github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= -github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 h1:kHaBemcxl8o/pQ5VM1c8PVE1PubbNx3mjUr09OqWGCs= -github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575/go.mod h1:9d6lWj8KzO/fd/NrVaLscBKmPigpZpn5YawRPw+e3Yo= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= -github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= -github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= -github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= -github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/ebitengine/purego v0.8.3 h1:K+0AjQp63JEZTEMZiwsI9g0+hAMNohwUOtY0RPGexmc= -github.com/ebitengine/purego v0.8.3/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= -github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= -github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= -github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= -github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= -github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= -github.com/golang/mock v1.7.0-rc.1 h1:YojYx61/OLFsiv6Rw1Z96LpldJIy31o+UHmwAUMJ6/U= -github.com/golang/mock v1.7.0-rc.1/go.mod h1:s42URUywIqd+OcERslBJvOjepvNymP31m3q8d/GkuRs= -github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= -github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= -github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= -github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= -github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= -github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= -github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= -github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= -github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= -github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0= -github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= -github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0 h1:0dOJCEtabevxxDQmxed69oMzSw+gb3ErCnFwFYZFu0M= -github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0/go.mod h1:QwzQhtxPThXMUDW1XRXNQ+l0GrI2BRsvNhX6ZuKyAds= -github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0 h1:F68/Nbpcvo3JZpaWlRUDJtG7xs8FHBZ7A8GOMauDkyc= -github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0/go.mod h1:haO4cJtAk05Y0p7NO9ME660xxtSh54ifCIIT7+PO9C0= -github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= -github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= -github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= -github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= -github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= -github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= -github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg= -github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA= -github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= -github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/secure-systems-lab/go-securesystemslib v0.9.0 h1:rf1HIbL64nUpEIZnjLZ3mcNEL9NBPB0iuVjyxvq3LZc= -github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/woA/peqr+L0joiRXbPpQ042GgJckkFgw= -github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= -github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= -github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= -github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= -github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= -github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/theckman/httpforwarded v0.4.0 h1:N55vGJT+6ojTnLY3LQCNliJC4TW0P0Pkeys1G1WpX2w= -github.com/theckman/httpforwarded v0.4.0/go.mod h1:GVkFynv6FJreNbgH/bpOU9ITDZ7a5WuzdNCtIMI1pVI= -github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= -github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= -github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= -github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= -github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= -github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= -github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= -github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= -github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= -github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= -github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= -github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= -github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= -go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= -go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= -go.opentelemetry.io/collector/component v1.31.0 h1:9LzU8X1RhV3h8/QsAoTX23aFUfoJ3EUc9O/vK+hFpSI= -go.opentelemetry.io/collector/component v1.31.0/go.mod h1:JbZl/KywXJxpUXPbt96qlEXJSym1zQ2hauMxYMuvlxM= -go.opentelemetry.io/collector/component/componentstatus v0.125.0 h1:zlxGQZYd9kknRZSjRpOYW5SBjl0a5zYFYRPbreobXoU= -go.opentelemetry.io/collector/component/componentstatus v0.125.0/go.mod h1:bHXc2W8bqqo9adOvCgvhcO7pYzJOSpyV4cuQ1wiIl04= -go.opentelemetry.io/collector/component/componenttest v0.125.0 h1:E2mpnMQbkMpYoZ3Q8pHx4kod7kedjwRs1xqDpzCe/84= -go.opentelemetry.io/collector/component/componenttest v0.125.0/go.mod h1:pQtsE1u/SPZdTphP5BZP64XbjXSq6wc+mDut5Ws/JDI= -go.opentelemetry.io/collector/consumer v1.31.0 h1:L+y66ywxLHnAxnUxv0JDwUf5bFj53kMxCCyEfRKlM7s= -go.opentelemetry.io/collector/consumer v1.31.0/go.mod h1:rPsqy5ni+c6xNMUkOChleZYO/nInVY6eaBNZ1FmWJVk= -go.opentelemetry.io/collector/consumer/consumertest v0.125.0 h1:TUkxomGS4DAtjBvcWQd2UY4FDLLEKMQD6iOIDUr/5dM= -go.opentelemetry.io/collector/consumer/consumertest v0.125.0/go.mod h1:vkHf3y85cFLDHARO/cTREVjLjOPAV+cQg7lkC44DWOY= -go.opentelemetry.io/collector/consumer/xconsumer v0.125.0 h1:oTreUlk1KpMSWwuHFnstW+orrjGTyvs2xd3o/Dpy+hI= -go.opentelemetry.io/collector/consumer/xconsumer v0.125.0/go.mod h1:FX0G37r0W+wXRgxxFtwEJ4rlsCB+p0cIaxtU3C4hskw= -go.opentelemetry.io/collector/featuregate v1.31.0 h1:20q7plPQZwmAiaYAa6l1m/i2qDITZuWlhjr4EkmeQls= -go.opentelemetry.io/collector/featuregate v1.31.0/go.mod h1:Y/KsHbvREENKvvN9RlpiWk/IGBK+CATBYzIIpU7nccc= -go.opentelemetry.io/collector/internal/telemetry v0.125.0 h1:6lcGOxw3dAg7LfXTKdN8ZjR+l7KvzLdEiPMhhLwG4r4= -go.opentelemetry.io/collector/internal/telemetry v0.125.0/go.mod h1:5GyFslLqjZgq1DZTtFiluxYhhXrCofHgOOOybodDPGE= -go.opentelemetry.io/collector/pdata v1.31.0 h1:P5WuLr1l2JcIvr6Dw2hl01ltp2ZafPnC4Isv+BLTBqU= -go.opentelemetry.io/collector/pdata v1.31.0/go.mod h1:m41io9nWpy7aCm/uD1L9QcKiZwOP0ldj83JEA34dmlk= -go.opentelemetry.io/collector/pdata/pprofile v0.125.0 h1:Qqlx8w1HpiYZ9RQqjmMQIysI0cHNO1nh3E/fCTeFysA= -go.opentelemetry.io/collector/pdata/pprofile v0.125.0/go.mod h1:p/yK023VxAp8hm27/1G5DPTcMIpnJy3cHGAFUQZGyaQ= -go.opentelemetry.io/collector/pdata/testdata v0.125.0 h1:due1Hl0EEVRVwfCkiamRy5E8lS6yalv0lo8Zl/SJtGw= -go.opentelemetry.io/collector/pdata/testdata v0.125.0/go.mod h1:1GpEWlgdMrd+fWsBk37ZC2YmOP5YU3gFQ4rWuCu9g24= -go.opentelemetry.io/collector/pipeline v0.125.0 h1:oitBgcAFqntDB4ihQJUHJSQ8IHqKFpPkaTVbTYdIUzM= -go.opentelemetry.io/collector/pipeline v0.125.0/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= -go.opentelemetry.io/collector/processor v1.31.0 h1:+u7sBUpnCBsHYoALp4hfr9VEjLHHYa4uKENGITe0K9Q= -go.opentelemetry.io/collector/processor v1.31.0/go.mod h1:5hDYJ7/hTdfd2tF2Rj5Hs6+mfyFz2O7CaPzVvW1qHQc= -go.opentelemetry.io/collector/processor/processorhelper v0.125.0 h1:QRpX7oFW88DAZhy+Q93npklRoaQr8ue0GKpeup7C/Fk= -go.opentelemetry.io/collector/processor/processorhelper v0.125.0/go.mod h1:oXRvslUuN62wErcoJrcEJYoTXu5wHyNyJsE+/a9Cc9s= -go.opentelemetry.io/collector/processor/processortest v0.125.0 h1:ZVAN4iZPDcWhpzKqnuok2NIuS5hwGVVQUOWkJFR12tA= -go.opentelemetry.io/collector/processor/processortest v0.125.0/go.mod h1:VAw0IRG35cWTBjBtreXeXJEgqkRegfjrH/EuLhNX2+I= -go.opentelemetry.io/collector/processor/xprocessor v0.125.0 h1:VWYPMW1VmDq6xB7M5SYjBpQCCIq3MhQ3W++wU47QpZM= -go.opentelemetry.io/collector/processor/xprocessor v0.125.0/go.mod h1:bCxUyFVlksANg8wjYZqWVsRB33lkLQ294rTrju/IZiM= -go.opentelemetry.io/collector/semconv v0.125.0 h1:SyRP617YGvNSWRSKMy7Lbk9RaJSR+qFAAfyxJOeZe4s= -go.opentelemetry.io/collector/semconv v0.125.0/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= -go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 h1:ojdSRDvjrnm30beHOmwsSvLpoRF40MlwNCA+Oo93kXU= -go.opentelemetry.io/contrib/bridges/otelzap v0.10.0/go.mod h1:oTTm4g7NEtHSV2i/0FeVdPaPgUIZPfQkFbq0vbzqnv0= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= -go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= -go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= -go.opentelemetry.io/otel/log v0.11.0 h1:c24Hrlk5WJ8JWcwbQxdBqxZdOK7PcP/LFtOtwpDTe3Y= -go.opentelemetry.io/otel/log v0.11.0/go.mod h1:U/sxQ83FPmT29trrifhQg+Zj2lo1/IPN1PF6RTFqdwc= -go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= -go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= -go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= -go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= -go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o= -go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= -go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs= -go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= -go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= -go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= -go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= -go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= -go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= -go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= -golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= -golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= -golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= -golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= -golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= -golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= -golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= -golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= -google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= -google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 h1:29cjnHVylHwTzH66WfFZqgSQgnxzvWE+jvBwpZCLRxY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= -google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM= -google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM= -google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= -google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= -gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -k8s.io/apimachinery v0.32.3 h1:JmDuDarhDmA/Li7j3aPrwhpNBA94Nvk5zLeOge9HH1U= -k8s.io/apimachinery v0.32.3/go.mod h1:GpHVgxoKlTxClKcteaeuF1Ul/lDVb74KpZcxcmLDElE= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go b/contrib/aws/datadog-lambda-go/lambdatest/error/main.go deleted file mode 100644 index c658cabfa3..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/error/main.go +++ /dev/null @@ -1,28 +0,0 @@ -// Unless explicitly stated otherwise all files in this repository are licensed -// under the Apache License Version 2.0. -// This product includes software developed at Datadog (https://www.datadoghq.com/). -// Copyright 2016 Datadog, Inc. -// - -package main - -import ( - "context" - "errors" - - "github.com/aws/aws-lambda-go/lambda" - - ddlambda "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2" - "github.com/aws/aws-lambda-go/events" -) - -func handleRequest(ctx context.Context, ev events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { - return events.APIGatewayProxyResponse{ - StatusCode: 500, - Body: "error", - }, errors.New("something went wrong") -} - -func main() { - lambda.Start(ddlambda.WrapHandler(handleRequest, nil)) -} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod deleted file mode 100644 index a1cb793b91..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.mod +++ /dev/null @@ -1,113 +0,0 @@ -module github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/lambdatest/hello/v2 - -go 1.24.0 - -require ( - github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 v2.4.0-dev - github.com/DataDog/dd-trace-go/contrib/net/http/v2 v2.0.0-00010101000000-000000000000 - github.com/DataDog/dd-trace-go/v2 v2.4.0-dev - github.com/aws/aws-lambda-go v1.46.0 -) - -require ( - github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/proto v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 // indirect - github.com/DataDog/datadog-agent/pkg/trace v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 // indirect - github.com/DataDog/datadog-agent/pkg/version v0.67.0 // indirect - github.com/DataDog/datadog-go/v5 v5.6.0 // indirect - github.com/DataDog/go-libddwaf/v4 v4.3.2 // indirect - github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 // indirect - github.com/DataDog/go-sqllexer v0.1.6 // indirect - github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect - github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 // indirect - github.com/DataDog/sketches-go v1.4.7 // indirect - github.com/Masterminds/semver/v3 v3.3.1 // indirect - github.com/Microsoft/go-winio v0.6.2 // indirect - github.com/andybalholm/brotli v1.1.0 // indirect - github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect - github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect - github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect - github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect - github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect - github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect - github.com/aws/aws-xray-sdk-go/v2 v2.0.0 // indirect - github.com/aws/smithy-go v1.19.0 // indirect - github.com/cenkalti/backoff/v4 v4.2.1 // indirect - github.com/cespare/xxhash/v2 v2.3.0 // indirect - github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 // indirect - github.com/dustin/go-humanize v1.0.1 // indirect - github.com/ebitengine/purego v0.8.3 // indirect - github.com/go-logr/logr v1.4.2 // indirect - github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-ole/go-ole v1.3.0 // indirect - github.com/go-viper/mapstructure/v2 v2.4.0 // indirect - github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/protobuf v1.5.4 // indirect - github.com/google/uuid v1.6.0 // indirect - github.com/hashicorp/go-version v1.7.0 // indirect - github.com/json-iterator/go v1.1.12 // indirect - github.com/klauspost/compress v1.18.0 // indirect - github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect - github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect - github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect - github.com/outcaste-io/ristretto v0.2.3 // indirect - github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c // indirect - github.com/pkg/errors v0.9.1 // indirect - github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect - github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect - github.com/puzpuzpuz/xsync/v3 v3.5.1 // indirect - github.com/secure-systems-lab/go-securesystemslib v0.9.0 // indirect - github.com/shirou/gopsutil/v4 v4.25.3 // indirect - github.com/sony/gobreaker v0.5.0 // indirect - github.com/theckman/httpforwarded v0.4.0 // indirect - github.com/tinylib/msgp v1.2.5 // indirect - github.com/tklauser/go-sysconf v0.3.14 // indirect - github.com/tklauser/numcpus v0.9.0 // indirect - github.com/valyala/bytebufferpool v1.0.0 // indirect - github.com/valyala/fasthttp v1.52.0 // indirect - github.com/yusufpapurcu/wmi v1.2.4 // indirect - go.opentelemetry.io/auto/sdk v1.1.0 // indirect - go.opentelemetry.io/collector/component v1.31.0 // indirect - go.opentelemetry.io/collector/featuregate v1.31.0 // indirect - go.opentelemetry.io/collector/internal/telemetry v0.125.0 // indirect - go.opentelemetry.io/collector/pdata v1.31.0 // indirect - go.opentelemetry.io/collector/semconv v0.125.0 // indirect - go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 // indirect - go.opentelemetry.io/otel v1.35.0 // indirect - go.opentelemetry.io/otel/log v0.11.0 // indirect - go.opentelemetry.io/otel/metric v1.35.0 // indirect - go.opentelemetry.io/otel/sdk v1.35.0 // indirect - go.opentelemetry.io/otel/trace v1.35.0 // indirect - go.uber.org/atomic v1.11.0 // indirect - go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.27.0 // indirect - golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect - golang.org/x/mod v0.25.0 // indirect - golang.org/x/net v0.40.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.26.0 // indirect - golang.org/x/time v0.11.0 // indirect - golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 // indirect - google.golang.org/grpc v1.72.0 // indirect - google.golang.org/protobuf v1.36.6 // indirect - gopkg.in/ini.v1 v1.67.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect -) - -replace github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2 => ../../ - -replace github.com/DataDog/dd-trace-go/v2 => ../../../../.. - -replace github.com/DataDog/dd-trace-go/contrib/net/http/v2 => ../../../../../contrib/net/http diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum b/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum deleted file mode 100644 index b78bf03702..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/go.sum +++ /dev/null @@ -1,343 +0,0 @@ -github.com/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= -github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= -github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0 h1:2mEwRWvhIPHMPK4CMD8iKbsrYBxeMBSuuCXumQAwShU= -github.com/DataDog/datadog-agent/comp/core/tagger/origindetection v0.67.0/go.mod h1:ejJHsyJTG7NU6c6TDbF7dmckD3g+AUGSdiSXy+ZyaCE= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0 h1:NcvyDVIUA0NbBDbp7QJnsYhoBv548g8bXq886795mCQ= -github.com/DataDog/datadog-agent/pkg/obfuscate v0.67.0/go.mod h1:1oPcs3BUTQhiTkmk789rb7ob105MxNV6OuBa28BdukQ= -github.com/DataDog/datadog-agent/pkg/proto v0.67.0 h1:7dO6mKYRb7qSiXEu7Q2mfeKbhp4hykCAULy4BfMPmsQ= -github.com/DataDog/datadog-agent/pkg/proto v0.67.0/go.mod h1:bKVXB7pxBg0wqXF6YSJ+KU6PeCWKDyJj83kUH1ab+7o= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0 h1:/DsN4R+IkC6t1+4cHSfkxzLtDl84rBbPC5Wa9srBAoM= -github.com/DataDog/datadog-agent/pkg/remoteconfig/state v0.69.0/go.mod h1:Th2LD/IGid5Rza55pzqGu6nUdOv/Rts6wPwLjTyOSTs= -github.com/DataDog/datadog-agent/pkg/trace v0.67.0 h1:dqt+/nObo0JKyaEqIMZgfqGZbx9TfEHpCkrjQ/zzH7k= -github.com/DataDog/datadog-agent/pkg/trace v0.67.0/go.mod h1:zmZoEtKvOnaKHbJGBKH3a4xuyPrSfBaF0ZE3Q3rCoDw= -github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 h1:xrH15QNqeJZkYoXYi44VCIvGvTwlQ3z2iT2QVTGiT7s= -github.com/DataDog/datadog-agent/pkg/util/log v0.67.0/go.mod h1:dfVLR+euzEyg1CeiExgJQq1c1dod42S6IeiRPj8H7Yk= -github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 h1:aIWF85OKxXGo7rVyqJ7jm7lm2qCQrgyXzYyFuw0T2EQ= -github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0/go.mod h1:Lfap5FuM4b/Pw9IrTuAvWBWZEmXOvZhCya3dYv4G8O0= -github.com/DataDog/datadog-agent/pkg/version v0.67.0 h1:TB8H8r+laB1Qdttvvc6XJVyLGxp8E6j2f2Mh5IPbYmQ= -github.com/DataDog/datadog-agent/pkg/version v0.67.0/go.mod h1:kvAw/WbI7qLAsDI2wHabZfM7Cv2zraD3JA3323GEB+8= -github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= -github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/go-libddwaf/v4 v4.3.2 h1:YGvW2Of1C4e1yU+p7iibmhN2zEOgi9XEchbhQjBxb/A= -github.com/DataDog/go-libddwaf/v4 v4.3.2/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= -github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 h1:ZRLR9Lbym748e8RznWzmSoK+OfV+8qW6SdNYA4/IqdA= -github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633/go.mod h1:YFoTl1xsMzdSRFIu33oCSPS/3+HZAPGpO3oOM96wXCM= -github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= -github.com/DataDog/go-sqllexer v0.1.6/go.mod h1:GGpo1h9/BVSN+6NJKaEcJ9Jn44Hqc63Rakeb+24Mjgo= -github.com/DataDog/go-tuf v1.1.0-0.5.2 h1:4CagiIekonLSfL8GMHRHcHudo1fQnxELS9g4tiAupQ4= -github.com/DataDog/go-tuf v1.1.0-0.5.2/go.mod h1:zBcq6f654iVqmkk8n2Cx81E1JnNTMOAx1UEO/wZR+P0= -github.com/DataDog/gostackparse v0.7.0 h1:i7dLkXHvYzHV308hnkvVGDL3BR4FWl7IsXNPz/IGQh4= -github.com/DataDog/gostackparse v0.7.0/go.mod h1:lTfqcJKqS9KnXQGnyQMCugq3u1FP6UZMfWR0aitKFMM= -github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0 h1:5US5SqqhfkZkg/E64uvn7YmeTwnudJHtlPEH/LOT99w= -github.com/DataDog/opentelemetry-mapping-go/pkg/otlp/attributes v0.27.0/go.mod h1:VRo4D6rj92AExpVBlq3Gcuol9Nm1bber12KyxRjKGWw= -github.com/DataDog/sketches-go v1.4.7 h1:eHs5/0i2Sdf20Zkj0udVFWuCrXGRFig2Dcfm5rtcTxc= -github.com/DataDog/sketches-go v1.4.7/go.mod h1:eAmQ/EBmtSO+nQp7IZMZVRPT4BQTmIc5RZQ+deGlTPM= -github.com/Masterminds/semver/v3 v3.3.1 h1:QtNSWtVZ3nBfk8mAOu/B6v7FMJ+NHTIgUPi7rj+4nv4= -github.com/Masterminds/semver/v3 v3.3.1/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM= -github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= -github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= -github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= -github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= -github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= -github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= -github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= -github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU= -github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4= -github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o= -github.com/aws/aws-sdk-go-v2/config v1.26.6/go.mod h1:uKU6cnDmYCvJ+pxO9S4cWDb2yWWIH5hra+32hVh1MI4= -github.com/aws/aws-sdk-go-v2/credentials v1.16.16 h1:8q6Rliyv0aUFAVtzaldUEcS+T5gbadPbWdV1WcAddK8= -github.com/aws/aws-sdk-go-v2/credentials v1.16.16/go.mod h1:UHVZrdUsv63hPXFo1H7c5fEneoVo9UXiz36QG1GEPi0= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 h1:c5I5iH+DZcH3xOIMlz3/tCKJDaHFwYEmxvlh2fAcFo8= -github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11/go.mod h1:cRrYDYAMUohBJUtUnOhydaMHtiK/1NZ0Otc9lIb6O0Y= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw= -github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 h1:n3GDfwqF2tzEkXlv5cuy4iy7LpKDtqDMcNLfZDu9rls= -github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 h1:DBYTXwIGQSGs9w4jKm60F5dmCQ3EEruxdc0MFh+3EY4= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10/go.mod h1:wohMUQiFdzo0NtxbBg0mSRGZ4vL3n0dKjLTINdcIino= -github.com/aws/aws-sdk-go-v2/service/kms v1.27.9 h1:W9PbZAZAEcelhhjb7KuwUtf+Lbc+i7ByYJRuWLlnxyQ= -github.com/aws/aws-sdk-go-v2/service/kms v1.27.9/go.mod h1:2tFmR7fQnOdQlM2ZCEPpFnBIQD1U8wmXmduBgZbOag0= -github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 h1:eajuO3nykDPdYicLlP3AGgOyVN3MOlFmZv7WGTuJPow= -github.com/aws/aws-sdk-go-v2/service/sso v1.18.7/go.mod h1:+mJNDdF+qiUlNKNC3fxn74WWNN+sOiGOEImje+3ScPM= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w1NmfkfiSK8mS4zOx3BA= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8= -github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0= -github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U= -github.com/aws/aws-xray-sdk-go/v2 v2.0.0 h1:/AkLb6rmRWjz8pQTm6BxCGcjebS+W1yFoH9rxy3ekM8= -github.com/aws/aws-xray-sdk-go/v2 v2.0.0/go.mod h1:yyjiofE/pQ9u682QgBw3tkyuyvcN+6piDiQnhwWMyng= -github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM= -github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= -github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= -github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= -github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= -github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575 h1:kHaBemcxl8o/pQ5VM1c8PVE1PubbNx3mjUr09OqWGCs= -github.com/cihub/seelog v0.0.0-20170130134532-f561c5e57575/go.mod h1:9d6lWj8KzO/fd/NrVaLscBKmPigpZpn5YawRPw+e3Yo= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= -github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= -github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= -github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= -github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= -github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/ebitengine/purego v0.8.3 h1:K+0AjQp63JEZTEMZiwsI9g0+hAMNohwUOtY0RPGexmc= -github.com/ebitengine/purego v0.8.3/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= -github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= -github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= -github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= -github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= -github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= -github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= -github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= -github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= -github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= -github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= -github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= -github.com/golang/mock v1.7.0-rc.1 h1:YojYx61/OLFsiv6Rw1Z96LpldJIy31o+UHmwAUMJ6/U= -github.com/golang/mock v1.7.0-rc.1/go.mod h1:s42URUywIqd+OcERslBJvOjepvNymP31m3q8d/GkuRs= -github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= -github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= -github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= -github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgYQBbFN4U4JNXUNYpxael3UzMyo= -github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144= -github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= -github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= -github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= -github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= -github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= -github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= -github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= -github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= -github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= -github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= -github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0= -github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFdJifH4BDsTlE89Zl93FEloxaWZfGcifgq8= -github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0 h1:0dOJCEtabevxxDQmxed69oMzSw+gb3ErCnFwFYZFu0M= -github.com/open-telemetry/opentelemetry-collector-contrib/pkg/sampling v0.125.0/go.mod h1:QwzQhtxPThXMUDW1XRXNQ+l0GrI2BRsvNhX6ZuKyAds= -github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0 h1:F68/Nbpcvo3JZpaWlRUDJtG7xs8FHBZ7A8GOMauDkyc= -github.com/open-telemetry/opentelemetry-collector-contrib/processor/probabilisticsamplerprocessor v0.125.0/go.mod h1:haO4cJtAk05Y0p7NO9ME660xxtSh54ifCIIT7+PO9C0= -github.com/outcaste-io/ristretto v0.2.3 h1:AK4zt/fJ76kjlYObOeNwh4T3asEuaCmp26pOvUOL9w0= -github.com/outcaste-io/ristretto v0.2.3/go.mod h1:W8HywhmtlopSB1jeMg3JtdIhf+DYkLAr0VN/s4+MHac= -github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= -github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo= -github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= -github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= -github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= -github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg= -github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA= -github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3 h1:4+LEVOB87y175cLJC/mbsgKmoDOjrBldtXvioEy96WY= -github.com/richardartoul/molecule v1.0.1-0.20240531184615-7ca0df43c0b3/go.mod h1:vl5+MqJ1nBINuSsUI2mGgH79UweUT/B5Fy8857PqyyI= -github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= -github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/secure-systems-lab/go-securesystemslib v0.9.0 h1:rf1HIbL64nUpEIZnjLZ3mcNEL9NBPB0iuVjyxvq3LZc= -github.com/secure-systems-lab/go-securesystemslib v0.9.0/go.mod h1:DVHKMcZ+V4/woA/peqr+L0joiRXbPpQ042GgJckkFgw= -github.com/shirou/gopsutil/v4 v4.25.3 h1:SeA68lsu8gLggyMbmCn8cmp97V1TI9ld9sVzAUcKcKE= -github.com/shirou/gopsutil/v4 v4.25.3/go.mod h1:xbuxyoZj+UsgnZrENu3lQivsngRR5BdjbJwf2fv4szA= -github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -github.com/sony/gobreaker v0.5.0 h1:dRCvqm0P490vZPmy7ppEk2qCnCieBooFJ+YoXGYB+yg= -github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= -github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= -github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= -github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= -github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/theckman/httpforwarded v0.4.0 h1:N55vGJT+6ojTnLY3LQCNliJC4TW0P0Pkeys1G1WpX2w= -github.com/theckman/httpforwarded v0.4.0/go.mod h1:GVkFynv6FJreNbgH/bpOU9ITDZ7a5WuzdNCtIMI1pVI= -github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= -github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= -github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= -github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= -github.com/tklauser/numcpus v0.9.0 h1:lmyCHtANi8aRUgkckBgoDk1nHCux3n2cgkJLXdQGPDo= -github.com/tklauser/numcpus v0.9.0/go.mod h1:SN6Nq1O3VychhC1npsWostA+oW+VOQTxZrS604NSRyI= -github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.52.0 h1:wqBQpxH71XW0e2g+Og4dzQM8pk34aFYlA1Ga8db7gU0= -github.com/valyala/fasthttp v1.52.0/go.mod h1:hf5C4QnVMkNXMspnsUlfM3WitlgYflyhHYoKol/szxQ= -github.com/vmihailenco/msgpack/v4 v4.3.13 h1:A2wsiTbvp63ilDaWmsk2wjx6xZdxQOvpiNlKBGKKXKI= -github.com/vmihailenco/msgpack/v4 v4.3.13/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= -github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc= -github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= -github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= -go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= -go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= -go.opentelemetry.io/collector/component v1.31.0 h1:9LzU8X1RhV3h8/QsAoTX23aFUfoJ3EUc9O/vK+hFpSI= -go.opentelemetry.io/collector/component v1.31.0/go.mod h1:JbZl/KywXJxpUXPbt96qlEXJSym1zQ2hauMxYMuvlxM= -go.opentelemetry.io/collector/component/componentstatus v0.125.0 h1:zlxGQZYd9kknRZSjRpOYW5SBjl0a5zYFYRPbreobXoU= -go.opentelemetry.io/collector/component/componentstatus v0.125.0/go.mod h1:bHXc2W8bqqo9adOvCgvhcO7pYzJOSpyV4cuQ1wiIl04= -go.opentelemetry.io/collector/component/componenttest v0.125.0 h1:E2mpnMQbkMpYoZ3Q8pHx4kod7kedjwRs1xqDpzCe/84= -go.opentelemetry.io/collector/component/componenttest v0.125.0/go.mod h1:pQtsE1u/SPZdTphP5BZP64XbjXSq6wc+mDut5Ws/JDI= -go.opentelemetry.io/collector/consumer v1.31.0 h1:L+y66ywxLHnAxnUxv0JDwUf5bFj53kMxCCyEfRKlM7s= -go.opentelemetry.io/collector/consumer v1.31.0/go.mod h1:rPsqy5ni+c6xNMUkOChleZYO/nInVY6eaBNZ1FmWJVk= -go.opentelemetry.io/collector/consumer/consumertest v0.125.0 h1:TUkxomGS4DAtjBvcWQd2UY4FDLLEKMQD6iOIDUr/5dM= -go.opentelemetry.io/collector/consumer/consumertest v0.125.0/go.mod h1:vkHf3y85cFLDHARO/cTREVjLjOPAV+cQg7lkC44DWOY= -go.opentelemetry.io/collector/consumer/xconsumer v0.125.0 h1:oTreUlk1KpMSWwuHFnstW+orrjGTyvs2xd3o/Dpy+hI= -go.opentelemetry.io/collector/consumer/xconsumer v0.125.0/go.mod h1:FX0G37r0W+wXRgxxFtwEJ4rlsCB+p0cIaxtU3C4hskw= -go.opentelemetry.io/collector/featuregate v1.31.0 h1:20q7plPQZwmAiaYAa6l1m/i2qDITZuWlhjr4EkmeQls= -go.opentelemetry.io/collector/featuregate v1.31.0/go.mod h1:Y/KsHbvREENKvvN9RlpiWk/IGBK+CATBYzIIpU7nccc= -go.opentelemetry.io/collector/internal/telemetry v0.125.0 h1:6lcGOxw3dAg7LfXTKdN8ZjR+l7KvzLdEiPMhhLwG4r4= -go.opentelemetry.io/collector/internal/telemetry v0.125.0/go.mod h1:5GyFslLqjZgq1DZTtFiluxYhhXrCofHgOOOybodDPGE= -go.opentelemetry.io/collector/pdata v1.31.0 h1:P5WuLr1l2JcIvr6Dw2hl01ltp2ZafPnC4Isv+BLTBqU= -go.opentelemetry.io/collector/pdata v1.31.0/go.mod h1:m41io9nWpy7aCm/uD1L9QcKiZwOP0ldj83JEA34dmlk= -go.opentelemetry.io/collector/pdata/pprofile v0.125.0 h1:Qqlx8w1HpiYZ9RQqjmMQIysI0cHNO1nh3E/fCTeFysA= -go.opentelemetry.io/collector/pdata/pprofile v0.125.0/go.mod h1:p/yK023VxAp8hm27/1G5DPTcMIpnJy3cHGAFUQZGyaQ= -go.opentelemetry.io/collector/pdata/testdata v0.125.0 h1:due1Hl0EEVRVwfCkiamRy5E8lS6yalv0lo8Zl/SJtGw= -go.opentelemetry.io/collector/pdata/testdata v0.125.0/go.mod h1:1GpEWlgdMrd+fWsBk37ZC2YmOP5YU3gFQ4rWuCu9g24= -go.opentelemetry.io/collector/pipeline v0.125.0 h1:oitBgcAFqntDB4ihQJUHJSQ8IHqKFpPkaTVbTYdIUzM= -go.opentelemetry.io/collector/pipeline v0.125.0/go.mod h1:TO02zju/K6E+oFIOdi372Wk0MXd+Szy72zcTsFQwXl4= -go.opentelemetry.io/collector/processor v1.31.0 h1:+u7sBUpnCBsHYoALp4hfr9VEjLHHYa4uKENGITe0K9Q= -go.opentelemetry.io/collector/processor v1.31.0/go.mod h1:5hDYJ7/hTdfd2tF2Rj5Hs6+mfyFz2O7CaPzVvW1qHQc= -go.opentelemetry.io/collector/processor/processorhelper v0.125.0 h1:QRpX7oFW88DAZhy+Q93npklRoaQr8ue0GKpeup7C/Fk= -go.opentelemetry.io/collector/processor/processorhelper v0.125.0/go.mod h1:oXRvslUuN62wErcoJrcEJYoTXu5wHyNyJsE+/a9Cc9s= -go.opentelemetry.io/collector/processor/processortest v0.125.0 h1:ZVAN4iZPDcWhpzKqnuok2NIuS5hwGVVQUOWkJFR12tA= -go.opentelemetry.io/collector/processor/processortest v0.125.0/go.mod h1:VAw0IRG35cWTBjBtreXeXJEgqkRegfjrH/EuLhNX2+I= -go.opentelemetry.io/collector/processor/xprocessor v0.125.0 h1:VWYPMW1VmDq6xB7M5SYjBpQCCIq3MhQ3W++wU47QpZM= -go.opentelemetry.io/collector/processor/xprocessor v0.125.0/go.mod h1:bCxUyFVlksANg8wjYZqWVsRB33lkLQ294rTrju/IZiM= -go.opentelemetry.io/collector/semconv v0.125.0 h1:SyRP617YGvNSWRSKMy7Lbk9RaJSR+qFAAfyxJOeZe4s= -go.opentelemetry.io/collector/semconv v0.125.0/go.mod h1:te6VQ4zZJO5Lp8dM2XIhDxDiL45mwX0YAQQWRQ0Qr9U= -go.opentelemetry.io/contrib/bridges/otelzap v0.10.0 h1:ojdSRDvjrnm30beHOmwsSvLpoRF40MlwNCA+Oo93kXU= -go.opentelemetry.io/contrib/bridges/otelzap v0.10.0/go.mod h1:oTTm4g7NEtHSV2i/0FeVdPaPgUIZPfQkFbq0vbzqnv0= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= -go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= -go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= -go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= -go.opentelemetry.io/otel/log v0.11.0 h1:c24Hrlk5WJ8JWcwbQxdBqxZdOK7PcP/LFtOtwpDTe3Y= -go.opentelemetry.io/otel/log v0.11.0/go.mod h1:U/sxQ83FPmT29trrifhQg+Zj2lo1/IPN1PF6RTFqdwc= -go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= -go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= -go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= -go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= -go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o= -go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= -go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs= -go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= -go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= -go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= -go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= -go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= -go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= -go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= -golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= -golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= -golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= -golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= -golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= -golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= -golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= -golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= -golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= -google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= -google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197 h1:29cjnHVylHwTzH66WfFZqgSQgnxzvWE+jvBwpZCLRxY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20250425173222-7b384671a197/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= -google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM= -google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM= -google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= -google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= -gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -k8s.io/apimachinery v0.32.3 h1:JmDuDarhDmA/Li7j3aPrwhpNBA94Nvk5zLeOge9HH1U= -k8s.io/apimachinery v0.32.3/go.mod h1:GpHVgxoKlTxClKcteaeuF1Ul/lDVb74KpZcxcmLDElE= diff --git a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go b/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go deleted file mode 100644 index 32687718ee..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/hello/main.go +++ /dev/null @@ -1,53 +0,0 @@ -// Unless explicitly stated otherwise all files in this repository are licensed -// under the Apache License Version 2.0. -// This product includes software developed at Datadog (https://www.datadoghq.com/). -// Copyright 2016 Datadog, Inc. - -package main - -import ( - "context" - "fmt" - "net/http" - "strconv" - "time" - - "github.com/aws/aws-lambda-go/lambda" - - ddlambda "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2" - httptrace "github.com/DataDog/dd-trace-go/contrib/net/http/v2" - "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" - "github.com/aws/aws-lambda-go/events" -) - -func handleRequest(ctx context.Context, ev events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { - currentSpan, _ := tracer.SpanFromContext(ctx) - currentSpanContext := currentSpan.Context() - fmt.Println("Current span ID: " + strconv.FormatUint(currentSpanContext.SpanID(), 10)) - fmt.Println("Current trace ID: " + strconv.FormatUint(currentSpanContext.TraceID(), 10)) - - // HTTP request - req, _ := http.NewRequestWithContext(ctx, "GET", "https://www.datadoghq.com", nil) - client := http.Client{} - client = *httptrace.WrapClient(&client) - client.Do(req) - - // Metric - ddlambda.Distribution("hello-go.dog", 1) - - // User-defined span - for i := 0; i < 10; i++ { - s, _ := tracer.StartSpanFromContext(ctx, "child.span") - time.Sleep(100 * time.Millisecond) - s.Finish() - } - - return events.APIGatewayProxyResponse{ - StatusCode: 200, - Body: "hello, dog!", - }, nil -} - -func main() { - lambda.Start(ddlambda.WrapHandler(handleRequest, nil)) -} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json b/contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json deleted file mode 100644 index 496553dee9..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/input_events/api-gateway-get.json +++ /dev/null @@ -1,55 +0,0 @@ -{ - "path": "/test/hello", - "headers": { - "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", - "Accept-Encoding": "gzip, deflate, lzma, sdch, br", - "Accept-Language": "en-US,en;q=0.8", - "CloudFront-Forwarded-Proto": "https", - "CloudFront-Is-Desktop-Viewer": "true", - "CloudFront-Is-Mobile-Viewer": "false", - "CloudFront-Is-SmartTV-Viewer": "false", - "CloudFront-Is-Tablet-Viewer": "false", - "CloudFront-Viewer-Country": "US", - "Host": "wt6mne2s9k.execute-api.us-west-2.amazonaws.com", - "Upgrade-Insecure-Requests": "1", - "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48", - "Via": "1.1 fb7cca60f0ecd82ce07790c9c5eef16c.cloudfront.net (CloudFront)", - "X-Amz-Cf-Id": "nBsWBOrSHMgnaROZJK1wGCZ9PcRcSpq_oSXZNQwQ10OTZL4cimZo3g==", - "X-Forwarded-For": "192.168.100.1, 192.168.1.1", - "X-Forwarded-Port": "443", - "X-Forwarded-Proto": "https" - }, - "pathParameters": { - "proxy": "hello" - }, - "requestContext": { - "accountId": "123456789012", - "resourceId": "us4z18", - "stage": "test", - "requestId": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9", - "identity": { - "cognitoIdentityPoolId": "", - "accountId": "", - "cognitoIdentityId": "", - "caller": "", - "apiKey": "", - "sourceIp": "192.168.100.1", - "cognitoAuthenticationType": "", - "cognitoAuthenticationProvider": "", - "userArn": "", - "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36 OPR/39.0.2256.48", - "user": "" - }, - "resourcePath": "/{proxy+}", - "httpMethod": "GET", - "apiId": "wt6mne2s9k" - }, - "resource": "/{proxy+}", - "httpMethod": "GET", - "queryStringParameters": { - "name": "me" - }, - "stageVariables": { - "stageVarName": "stageVarValue" - } -} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/package.json b/contrib/aws/datadog-lambda-go/lambdatest/package.json deleted file mode 100644 index 8372064182..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/package.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "name": "lambda-sample-go", - "version": "1.0.0" -} diff --git a/contrib/aws/datadog-lambda-go/lambdatest/parse-json.js b/contrib/aws/datadog-lambda-go/lambdatest/parse-json.js deleted file mode 100644 index 29fa0d7c95..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/parse-json.js +++ /dev/null @@ -1,17 +0,0 @@ -'use strict' - -var readline = require('readline'); -var rl = readline.createInterface({ - input: process.stdin, - output: process.stdout, - terminal: false -}); - -rl.on('line', function(line){ - try { - const obj = JSON.parse(line) - console.log(JSON.stringify(obj, Object.keys(obj).sort(), 2)) - } catch (e) { - console.log(line) - } -}) diff --git a/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh b/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh deleted file mode 100755 index f718b4bcdf..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/run_integration_tests.sh +++ /dev/null @@ -1,210 +0,0 @@ -#!/bin/bash - -# Usage - run commands from the /integration_tests directory: -# To check if new changes to the library cause changes to any snapshots: -# DD_API_KEY=XXXX aws-vault exec sandbox-account-admin -- ./run_integration_tests.sh -# To regenerate snapshots: -# UPDATE_SNAPSHOTS=true DD_API_KEY=XXXX aws-vault exec sandbox-account-admin -- ./run_integration_tests.sh - -set -e - -# Disable deprecation warnings. -export SLS_DEPRECATION_DISABLE=* - -# These values need to be in sync with serverless.yml, where there needs to be a function -# defined for every handler_runtime combination -LAMBDA_HANDLERS=("hello" "error") - -LOGS_WAIT_SECONDS=20 - -integration_tests_dir=$(cd `dirname $0` && pwd) -echo $integration_tests_dir - -script_utc_start_time=$(date -u +"%Y%m%dT%H%M%S") - -mismatch_found=false - -if [ -z "$AWS_SECRET_ACCESS_KEY" ]; then - echo "No AWS credentials were found in the environment." - echo "Note that only Datadog employees can run these integration tests." - exit 1 -fi - -if [ -z "$DD_API_KEY" ]; then - echo "No DD_API_KEY env var set, exiting" - exit 1 -fi - -if [ -n "$UPDATE_SNAPSHOTS" ]; then - echo "Overwriting snapshots in this execution" -fi - -echo "Building Go binaries" -cd hello && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o ../build/hello/bootstrap && cd .. -cd error && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o ../build/error/bootstrap && cd .. -zip -j build/hello.zip build/hello/bootstrap -zip -j build/error.zip build/error/bootstrap - -# Generate a random 8-character ID to avoid collisions with other runs -run_id=$(xxd -l 4 -c 4 -p < /dev/random) - -# Always remove the stack before exiting, no matter what -function remove_stack() { - echo "Removing functions" - serverless remove --stage $run_id -} -trap remove_stack EXIT - -sls --version - -echo "Deploying functions" -sls deploy --stage $run_id - -cd $integration_tests_dir - -input_event_files=$(ls ./input_events) -# Sort event files by name so that snapshots stay consistent -input_event_files=($(for file_name in ${input_event_files[@]}; do echo $file_name; done | sort)) - -echo "Invoking functions" -set +e # Don't exit this script if an invocation fails or there's a diff -for input_event_file in "${input_event_files[@]}"; do - for function_name in "${LAMBDA_HANDLERS[@]}"; do - # Get event name without trailing ".json" so we can build the snapshot file name - input_event_name=$(echo "$input_event_file" | sed "s/.json//") - # Return value snapshot file format is snapshots/return_values/{handler}_{runtime}_{input-event} - snapshot_path="$integration_tests_dir/snapshots/return_values/${function_name}_${input_event_name}.json" - - return_value=$(DD_API_KEY=$DD_API_KEY sls invoke --stage $run_id -f $function_name --path "$integration_tests_dir/input_events/$input_event_file") - sls_invoke_exit_code=$? - if [ $sls_invoke_exit_code -ne 0 ]; then - return_value="Invocation failed" - fi - - if [ ! -f $snapshot_path ]; then - # If the snapshot file doesn't exist yet, we create it - echo "Writing return value to $snapshot_path because no snapshot exists yet" - echo "$return_value" >$snapshot_path - elif [ -n "$UPDATE_SNAPSHOTS" ]; then - # If $UPDATE_SNAPSHOTS is set to true, write the new logs over the current snapshot - echo "Overwriting return value snapshot for $snapshot_path" - echo "$return_value" >$snapshot_path - else - # Compare new return value to snapshot - diff_output=$(echo "$return_value" | diff - $snapshot_path) - if [ $? -eq 1 ]; then - echo "Failed: Return value for $function_name does not match snapshot:" - echo "$diff_output" - mismatch_found=true - else - echo "Ok: Return value for $function_name with $input_event_name event matches snapshot" - fi - fi - done -done -set -e - -echo "Sleeping $LOGS_WAIT_SECONDS seconds to wait for logs to appear in CloudWatch..." -sleep $LOGS_WAIT_SECONDS - -set +e # Don't exit this script if there is a diff or the logs endpoint fails -echo "Fetching logs for invocations and comparing to snapshots" -for function_name in "${LAMBDA_HANDLERS[@]}"; do - function_snapshot_path="./snapshots/logs/$function_name.log" - - # Fetch logs with serverless cli, retrying to avoid AWS account-wide rate limit error - retry_counter=0 - while [ $retry_counter -lt 10 ]; do - raw_logs=$(serverless logs -f $function_name --stage $run_id --startTime $script_utc_start_time) - fetch_logs_exit_code=$? - if [ $fetch_logs_exit_code -eq 1 ]; then - echo "Retrying fetch logs for $function_name..." - retry_counter=$(($retry_counter + 1)) - sleep 10 - continue - fi - break - done - - if [ $retry_counter -eq 9 ]; then - echo "FAILURE: Could not retrieve logs for $function_name" - echo "Error from final attempt to retrieve logs:" - echo $raw_logs - - exit 1 - fi - - # Replace invocation-specific data like timestamps and IDs with XXXX to normalize logs across executions - logs=$( - echo "$raw_logs" | - node parse-json.js | - # Remove serverless cli errors - sed '/Serverless: Recoverable error occurred/d' | - # Remove dd-trace-go logs - sed '/Datadog Tracer/d' | - # Normalize Lambda runtime report logs - perl -p -e 's/(RequestId|TraceId|init|SegmentId|Duration|Memory Used|"e"):( )?[a-z0-9\.\-]+/\1:\2XXXX/g' | - # Normalize DD APM headers and AWS account ID - perl -p -e "s/(Current span ID:|Current trace ID:|account_id:) ?[0-9]+/\1XXXX/g" | - # Strip API key from logged requests - perl -p -e "s/(api_key=|'api_key': ')[a-z0-9\.\-]+/\1XXXX/g" | - # Normalize ISO combined date-time - perl -p -e "s/[0-9]{4}\-[0-9]{2}\-[0-9]{2}(T?)[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+ \(\-?[0-9:]+\))?Z/XXXX-XX-XXTXX:XX:XX.XXXZ/" | - # Normalize log timestamps - perl -p -e "s/[0-9]{4}(\-|\/)[0-9]{2}(\-|\/)[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+( \(\-?[0-9:]+\))?)?/XXXX-XX-XX XX:XX:XX.XXX/" | - # Normalize DD trace ID injection - perl -p -e "s/(dd\.trace_id=)[0-9]+ (dd\.span_id=)[0-9]+/\1XXXX \2XXXX/" | - # Normalize execution ID in logs prefix - perl -p -e $'s/[0-9a-z]+\-[0-9a-z]+\-[0-9a-z]+\-[0-9a-z]+\-[0-9a-z]+\t/XXXX-XXXX-XXXX-XXXX-XXXX\t/' | - # Normalize layer version tag - perl -p -e "s/(dd_lambda_layer:datadog-go)[0-9]+\.[0-9]+\.[0-9]+/\1X\.X\.X/g" | - # Normalize package version tag - perl -p -e "s/(datadog_lambda:v)[0-9]+\.[0-9]+\.[0-9]+/\1X\.X\.X/g" | - # Normalize golang version tag - perl -p -e "s/(go)[0-9]+\.[0-9]+\.[0-9]+/\1X\.X\.X/g" | - # Normalize data in logged traces - perl -p -e 's/"(span_id|apiid|runtime-id|record_ids|parent_id|trace_id|start|duration|tcp\.local\.address|tcp\.local\.port|dns\.address|request_id|function_arn|x-datadog-trace-id|x-datadog-parent-id|datadog_lambda|dd_trace)":\ ("?)[a-zA-Z0-9\.:\-]+("?)/"\1":\2XXXX\3/g' | - # Remove metrics and metas in logged traces (their order is inconsistent) - perl -p -e 's/"(meta|metrics)":{(.*?)}/"\1":{"XXXX": "XXXX"}/g' | - # Strip out run ID (from function name, resource, etc.) - perl -p -e "s/$run_id/XXXX/g" | - # Normalize data in logged metrics - perl -p -e 's/"(points\\\":\[\[)([0-9]+)/\1XXXX/g' | - # Remove INIT_START log - perl -p -e "s/INIT_START.*//g" - ) - - if [ ! -f $function_snapshot_path ]; then - # If no snapshot file exists yet, we create one - echo "Writing logs to $function_snapshot_path because no snapshot exists yet" - echo "$logs" >$function_snapshot_path - elif [ -n "$UPDATE_SNAPSHOTS" ]; then - # If $UPDATE_SNAPSHOTS is set to true write the new logs over the current snapshot - echo "Overwriting log snapshot for $function_snapshot_path" - echo "$logs" >$function_snapshot_path - else - # Compare new logs to snapshots - diff_output=$(echo "$logs" | diff - $function_snapshot_path) - if [ $? -eq 1 ]; then - echo "Failed: Mismatch found between new $function_name logs (first) and snapshot (second):" - echo "$diff_output" - mismatch_found=true - else - echo "Ok: New logs for $function_name match snapshot" - fi - fi -done -set -e - -if [ "$mismatch_found" = true ]; then - echo "FAILURE: A mismatch between new data and a snapshot was found and printed above." - echo "If the change is expected, generate new snapshots by running 'UPDATE_SNAPSHOTS=true DD_API_KEY=XXXX ./run_integration_tests.sh'" - exit 1 -fi - -if [ -n "$UPDATE_SNAPSHOTS" ]; then - echo "SUCCESS: Wrote new snapshots for all functions" - exit 0 -fi - -echo "SUCCESS: No difference found between snapshots and new return values or logs" diff --git a/contrib/aws/datadog-lambda-go/lambdatest/serverless.yml b/contrib/aws/datadog-lambda-go/lambdatest/serverless.yml deleted file mode 100644 index f5a9157d73..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/serverless.yml +++ /dev/null @@ -1,37 +0,0 @@ -# IAM permissions require service name to begin with 'integration-tests' -service: integration-tests-go - -package: - individually: true # <- package each function individually, to prevent file name conflicts - -provider: - name: aws - region: eu-west-1 - tracing: - lambda: true - apiGateway: true - memorySize: 128 - timeout: 30 - environment: - DD_API_KEY: ${env:DD_API_KEY} - DD_LOG_LEVEL: DEBUG - DD_INTEGRATION_TEST: true - DD_ENHANCED_METRICS: true - DD_TRACE_ENABLED: true - deploymentBucket: - name: integration-tests-serververless-deployment-bucket - iam: - # IAM permissions require that all functions are deployed with this role - role: "arn:aws:iam::425362996713:role/serverless-integration-test-lambda-role" - -functions: - hello: - runtime: provided.al2 - handler: bootstrap - package: - artifact: build/hello.zip - error: - runtime: provided.al2 - handler: bootstrap - package: - artifact: build/error.zip diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log deleted file mode 100644 index df2ab2b609..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/error.log +++ /dev/null @@ -1,46 +0,0 @@ - -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Will use the API"} -START -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Merge X-Ray Traces is off, using trace context from Datadog only"} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Could not convert TraceContext to a SpanContext (most likely TraceContext was empty)"} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: sending metric via log forwarder"} -{ - "e": XXXX, - "m": "aws.lambda.enhanced.invocations", - "t": [ - "functionname:integration-tests-go-XXXX-error", - "region:eu-west-1", - "account_id:XXXX", - "memorysize:128", - "cold_start:true", - "datadog_lambda:vX.X.X", - "resource:integration-tests-go-XXXX-error", - "dd_lambda_layer:datadog-goX.X.X" - ], - "v": 1 -} -{ - "traces": [ - [ - {} - ] - ] -} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: sending metric via log forwarder"} -{ - "e": XXXX, - "m": "aws.lambda.enhanced.errors", - "t": [ - "functionname:integration-tests-go-XXXX-error", - "region:eu-west-1", - "account_id:XXXX", - "memorysize:128", - "cold_start:true", - "datadog_lambda:vX.X.X", - "resource:integration-tests-go-XXXX-error", - "dd_lambda_layer:datadog-goX.X.X" - ], - "v": 1 -} -XXXX-XX-XX XX:XX:XX.XXX {"errorMessage":"something went wrong","errorType":"errorString"} -END Duration: XXXX ms (init: XXXX ms) Memory Used: XXXX MB diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log deleted file mode 100644 index 811db7e487..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/logs/hello.log +++ /dev/null @@ -1,45 +0,0 @@ - -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Will use the API"} -START -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Merge X-Ray Traces is off, using trace context from Datadog only"} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Could not convert TraceContext to a SpanContext (most likely TraceContext was empty)"} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: sending metric via log forwarder"} -{ - "e": XXXX, - "m": "aws.lambda.enhanced.invocations", - "t": [ - "functionname:integration-tests-go-XXXX-hello", - "region:eu-west-1", - "account_id:XXXX", - "memorysize:128", - "cold_start:true", - "datadog_lambda:vX.X.X", - "resource:integration-tests-go-XXXX-hello", - "dd_lambda_layer:datadog-goX.X.X" - ], - "v": 1 -} -Current span ID:XXXX -Current trace ID:XXXX -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: adding metric \"hello-go.dog\", with value 1.000000"} -{ - "traces": [ - [ - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {} - ] - ] -} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: posting to url https://api.datadoghq.com/api/v1/distribution_points"} -XXXX-XX-XX XX:XX:XX.XXX {"status":"debug","message":"datadog: Sending payload with body {\"series\":[{\"metric\":\"hello-go.dog\",\"tags\":[\"dd_lambda_layer:datadog-goX.X.X\"],\"type\":\"distribution\",\points\":[[XXXX,[1]]]}]}"} -END Duration: XXXX ms (init: XXXX ms) Memory Used: XXXX MB diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json deleted file mode 100644 index 7147cafa92..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/error_api-gateway-get.json +++ /dev/null @@ -1 +0,0 @@ -Invocation failed diff --git a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json b/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json deleted file mode 100644 index 61a0287540..0000000000 --- a/contrib/aws/datadog-lambda-go/lambdatest/snapshots/return_values/hello_api-gateway-get.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "statusCode": 200, - "headers": null, - "multiValueHeaders": null, - "body": "hello, dog!" -} From 8ad7c088c581c14f262d4494e4967109a5ef4b0a Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 17 Sep 2025 12:20:53 -0400 Subject: [PATCH 10/25] use relative path for testdata. fix extension_test.go. use instrumentation.Version(). cold_start now in string. --- .../internal/extension/extension_test.go | 62 +++++++++---------- .../internal/metrics/listener.go | 4 +- .../internal/metrics/listener_test.go | 6 +- .../internal/trace/context_test.go | 20 +++--- .../internal/trace/listener.go | 6 +- .../internal/trace/listener_test.go | 2 +- .../internal/wrapper/wrap_handler_test.go | 16 ++--- 7 files changed, 57 insertions(+), 59 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go index 9ac6aba767..2509256ba6 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension_test.go @@ -15,8 +15,8 @@ import ( "testing" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" - "github.com/DataDog/dd-trace-go/v2/ddtrace" - ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/DataDog/dd-trace-go/v2/ddtrace/ext" + "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" "github.com/stretchr/testify/assert" ) @@ -201,8 +201,8 @@ func TestExtensionEndInvocation(t *testing.T) { endInvocationUrl: endInvocationUrl, httpClient: &ClientSuccessEndInvoke{}, } - span := ddtracer.StartSpan("aws.lambda") - logOutput := captureLog(func() { em.SendEndInvocationRequest(context.TODO(), span, ddtracer.FinishConfig{}) }) + span := tracer.StartSpan("aws.lambda") + logOutput := captureLog(func() { em.SendEndInvocationRequest(context.TODO(), span, tracer.FinishConfig{}) }) span.Finish() assert.Equal(t, "", logOutput) @@ -213,42 +213,40 @@ func TestExtensionEndInvocationError(t *testing.T) { endInvocationUrl: endInvocationUrl, httpClient: &ClientErrorMock{}, } - span := ddtracer.StartSpan("aws.lambda") - logOutput := captureLog(func() { em.SendEndInvocationRequest(context.TODO(), span, ddtracer.FinishConfig{}) }) + span := tracer.StartSpan("aws.lambda") + logOutput := captureLog(func() { em.SendEndInvocationRequest(context.TODO(), span, tracer.FinishConfig{}) }) span.Finish() assert.Contains(t, logOutput, "could not send end invocation payload to the extension") } -type mockSpanContext struct { - ddtrace.SpanContext -} - -func (m mockSpanContext) TraceID() string { return "123" } -func (m mockSpanContext) TraceIDBytes() [16]byte { return [16]byte{} } -func (m mockSpanContext) TraceIDLower() uint64 { return 123 } -func (m mockSpanContext) SpanID() uint64 { return 456 } -func (m mockSpanContext) SamplingPriority() (int, bool) { return -1, true } -func (m mockSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {} - -type mockSpan struct{ ddtrace.Span } - -func (m mockSpan) Context() ddtrace.SpanContext { return mockSpanContext{} } - func TestExtensionEndInvocationSamplingPriority(t *testing.T) { - headers := http.Header{} - em := &ExtensionManager{httpClient: capturingClient{hdr: headers}} - span := &mockSpan{} + // Start the tracer to ensure proper sampling priority handling + err := tracer.Start() + if err != nil { + t.Fatalf("Failed to start tracer: %v", err) + } + defer tracer.Stop() + + // Create a real span and set its sampling priority to -1 using ManualDrop + span := tracer.StartSpan("test") + defer span.Finish() // When priority in context, use that value + headers1 := http.Header{} + em1 := &ExtensionManager{httpClient: capturingClient{hdr: headers1}} ctx := context.WithValue(context.Background(), DdTraceId, "123") ctx = context.WithValue(ctx, DdSamplingPriority, "2") - em.SendEndInvocationRequest(ctx, span, ddtracer.FinishConfig{}) - assert.Equal(t, "2", headers.Get("X-Datadog-Sampling-Priority")) + em1.SendEndInvocationRequest(ctx, span, tracer.FinishConfig{}) + assert.Equal(t, "2", headers1.Get("X-Datadog-Sampling-Priority")) // When no context, get priority from span - em.SendEndInvocationRequest(context.Background(), span, ddtracer.FinishConfig{}) - assert.Equal(t, "-1", headers.Get("X-Datadog-Sampling-Priority")) + // Set sampling priority to -1 using ManualDrop tag + span.SetTag(ext.ManualDrop, true) + headers2 := http.Header{} + em2 := &ExtensionManager{httpClient: capturingClient{hdr: headers2}} + em2.SendEndInvocationRequest(context.Background(), span, tracer.FinishConfig{}) + assert.Equal(t, "-1", headers2.Get("X-Datadog-Sampling-Priority")) } type capturingClient struct { @@ -265,8 +263,8 @@ func (c capturingClient) Do(req *http.Request) (*http.Response, error) { func TestExtensionEndInvocationErrorHeaders(t *testing.T) { hdr := http.Header{} em := &ExtensionManager{httpClient: capturingClient{hdr: hdr}} - span := ddtracer.StartSpan("aws.lambda") - cfg := ddtracer.FinishConfig{Error: fmt.Errorf("ooooops")} + span := tracer.StartSpan("aws.lambda") + cfg := tracer.FinishConfig{Error: fmt.Errorf("ooooops")} em.SendEndInvocationRequest(context.TODO(), span, cfg) @@ -283,8 +281,8 @@ func TestExtensionEndInvocationErrorHeaders(t *testing.T) { func TestExtensionEndInvocationErrorHeadersNilError(t *testing.T) { hdr := http.Header{} em := &ExtensionManager{httpClient: capturingClient{hdr: hdr}} - span := ddtracer.StartSpan("aws.lambda") - cfg := ddtracer.FinishConfig{Error: nil} + span := tracer.StartSpan("aws.lambda") + cfg := tracer.FinishConfig{Error: nil} em.SendEndInvocationRequest(context.TODO(), span, cfg) diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go index a5d52c6bed..f7a2a96a73 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -17,9 +17,9 @@ import ( "github.com/aws/aws-lambda-go/lambdacontext" "github.com/DataDog/datadog-go/v5/statsd" - "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" + "github.com/DataDog/dd-trace-go/v2/instrumentation" ) type ( @@ -248,7 +248,7 @@ func getEnhancedMetricsTags(ctx context.Context) []string { memorySize := fmt.Sprintf("memorysize:%d", lambdacontext.MemoryLimitInMB) coldStart := fmt.Sprintf("cold_start:%t", isColdStart.(bool)) resource := fmt.Sprintf("resource:%s", lambdacontext.FunctionName) - datadogLambda := fmt.Sprintf("datadog_lambda:v%s", internal.Instr.Version()) + datadogLambda := fmt.Sprintf("datadog_lambda:v%s", instrumentation.Version()) tags := []string{functionName, region, accountId, memorySize, coldStart, datadogLambda} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go index 034cffe21b..f85f33b874 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -19,9 +19,9 @@ import ( "testing" "time" - "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" + "github.com/DataDog/dd-trace-go/v2/instrumentation" "github.com/aws/aws-lambda-go/lambdacontext" "github.com/stretchr/testify/assert" @@ -150,7 +150,7 @@ func TestGetEnhancedMetricsTags(t *testing.T) { } tags := getEnhancedMetricsTags(lambdacontext.NewContext(ctx, lc)) - assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:v" + internal.Instr.Version()}) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:v" + instrumentation.Version()}) } func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { @@ -165,7 +165,7 @@ func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { } tags := getEnhancedMetricsTags((lambdacontext.NewContext(ctx, lc))) - assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:v" + internal.Instr.Version()}) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:v" + instrumentation.Version()}) } func TestGetEnhancedMetricsTagsNoLambdaContext(t *testing.T) { diff --git a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go index 9633fa12b7..fb1ff892ee 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/context_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/context_test.go @@ -68,7 +68,7 @@ func loadRawJSON(t *testing.T, filename string) *json.RawMessage { } func TestGetDatadogTraceContextForTraceMetadataNonProxyEvent(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-with-headers.json") + ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.True(t, ok) @@ -83,7 +83,7 @@ func TestGetDatadogTraceContextForTraceMetadataNonProxyEvent(t *testing.T) { func TestGetDatadogTraceContextForTraceMetadataWithMixedCaseHeaders(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-with-mixed-case-headers.json") + ev := loadRawJSON(t, "../testdata/non-proxy-with-mixed-case-headers.json") headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.True(t, ok) @@ -98,7 +98,7 @@ func TestGetDatadogTraceContextForTraceMetadataWithMixedCaseHeaders(t *testing.T func TestGetDatadogTraceContextForTraceMetadataWithMissingSamplingPriority(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-with-missing-sampling-priority.json") + ev := loadRawJSON(t, "../testdata/non-proxy-with-missing-sampling-priority.json") headers, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.True(t, ok) @@ -113,7 +113,7 @@ func TestGetDatadogTraceContextForTraceMetadataWithMissingSamplingPriority(t *te func TestGetDatadogTraceContextForInvalidData(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/invalid.json") + ev := loadRawJSON(t, "../testdata/invalid.json") _, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.False(t, ok) @@ -121,7 +121,7 @@ func TestGetDatadogTraceContextForInvalidData(t *testing.T) { func TestGetDatadogTraceContextForMissingData(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json") + ev := loadRawJSON(t, "../testdata/non-proxy-no-headers.json") _, ok := getTraceContext(ctx, getHeadersFromEventHeaders(ctx, *ev)) assert.False(t, ok) @@ -173,7 +173,7 @@ func TestGetDatadogTraceContextFromContextObject(t *testing.T) { }, } - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json") + ev := loadRawJSON(t, "../testdata/non-proxy-no-headers.json") for _, test := range testcases { t.Run(test.traceID+test.parentID+test.samplingPriority, func(t *testing.T) { ctx := mockTraceContext(test.traceID, test.parentID, test.samplingPriority) @@ -244,7 +244,7 @@ func TestXrayTraceContextWithSegment(t *testing.T) { func TestContextWithRootTraceContextNoDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json") + ev := loadRawJSON(t, "../testdata/apig-event-no-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, false, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) @@ -255,7 +255,7 @@ func TestContextWithRootTraceContextNoDatadogContext(t *testing.T) { func TestContextWithRootTraceContextWithDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-with-headers.json") + ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, false, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) @@ -270,7 +270,7 @@ func TestContextWithRootTraceContextWithDatadogContext(t *testing.T) { func TestContextWithRootTraceContextMergeXrayTracesNoDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json") + ev := loadRawJSON(t, "../testdata/apig-event-no-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, true, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) @@ -285,7 +285,7 @@ func TestContextWithRootTraceContextMergeXrayTracesNoDatadogContext(t *testing.T func TestContextWithRootTraceContextMergeXrayTracesWithDatadogContext(t *testing.T) { ctx := mockLambdaXRayTraceContext(context.Background(), mockXRayTraceID, mockXRayEntityID, true) - ev := loadRawJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-with-headers.json") + ev := loadRawJSON(t, "../testdata/apig-event-with-headers.json") newCTX, _ := contextWithRootTraceContext(ctx, *ev, true, DefaultTraceExtractor) traceContext, _ := newCTX.Value(traceContextKey).(TraceContext) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener.go b/contrib/aws/datadog-lambda-go/internal/trace/listener.go index 2e152ddae2..b823a9c070 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener.go @@ -12,12 +12,12 @@ import ( "os" "strings" - "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/DataDog/dd-trace-go/v2/ddtrace" ddotel "github.com/DataDog/dd-trace-go/v2/ddtrace/opentelemetry" ddtracer "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer" + "github.com/DataDog/dd-trace-go/v2/instrumentation" "github.com/aws/aws-lambda-go/lambdacontext" "go.opentelemetry.io/otel" ) @@ -161,8 +161,8 @@ func startFunctionExecutionSpan(ctx context.Context, mergeXrayTraces bool, isDdS ddtracer.Tag("request_id", lambdaCtx.AwsRequestID), ddtracer.Tag("resource_names", lambdacontext.FunctionName), ddtracer.Tag("functionname", strings.ToLower(lambdacontext.FunctionName)), - ddtracer.Tag("datadog_lambda", internal.Instr.Version()), - ddtracer.Tag("dd_trace", internal.Instr.Version()), + ddtracer.Tag("datadog_lambda", instrumentation.Version()), + ddtracer.Tag("dd_trace", instrumentation.Version()), } if parentSpanContext != nil { diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go index bea636cc35..4d5de5fd44 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener_test.go @@ -79,7 +79,7 @@ func TestStartFunctionExecutionSpanFromXrayWithMergeEnabled(t *testing.T) { assert.Equal(t, "aws.lambda", finishedSpan.OperationName()) - assert.Equal(t, true, finishedSpan.Tag("cold_start")) + assert.Equal(t, "true", finishedSpan.Tag("cold_start")) // We expect the function ARN to be lowercased, and the version removed assert.Equal(t, "arn:aws:lambda:us-east-1:123456789012:function:myfunction", finishedSpan.Tag("function_arn")) assert.Equal(t, "11", finishedSpan.Tag("function_version")) diff --git a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go index 922c350d6c..687fbf963d 100644 --- a/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go +++ b/contrib/aws/datadog-lambda-go/internal/wrapper/wrap_handler_test.go @@ -152,7 +152,7 @@ func TestWrapHandlerAPIGEvent(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/apig-event-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -168,7 +168,7 @@ func TestWrapHandlerNonProxyEvent(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -184,7 +184,7 @@ func TestWrapHandlerEventArgumentOnly(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -213,7 +213,7 @@ func TestWrapHandlerNoArguments(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) @@ -228,7 +228,7 @@ func TestWrapHandlerInvalidData(t *testing.T) { return 5, nil } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/invalid.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/invalid.json", handler) assert.False(t, called) assert.Error(t, err) @@ -244,7 +244,7 @@ func TestWrapHandlerReturnsError(t *testing.T) { return 5, defaultErr } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.Equal(t, defaultErr, err) @@ -260,7 +260,7 @@ func TestWrapHandlerReturnsErrorOnly(t *testing.T) { return defaultErr } - _, response, err := runHandlerWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/non-proxy-no-headers.json", handler) + _, response, err := runHandlerWithJSON(t, "../testdata/non-proxy-no-headers.json", handler) assert.True(t, called) assert.Equal(t, defaultErr, err) @@ -289,7 +289,7 @@ func TestWrapHandlerInterfaceWithListeners(t *testing.T) { return 5, nil }) - _, response, err := runHandlerInterfaceWithJSON(t, "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/testdata/apig-event-no-headers.json", handler) + _, response, err := runHandlerInterfaceWithJSON(t, "../testdata/apig-event-no-headers.json", handler) assert.True(t, called) assert.NoError(t, err) From 11b1a5fe929498a5099b9c263769fe0a7434b49e Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 17 Sep 2025 12:23:52 -0400 Subject: [PATCH 11/25] go.work.sum update --- go.work.sum | 1 + 1 file changed, 1 insertion(+) diff --git a/go.work.sum b/go.work.sum index 5da1003ad5..9553626972 100644 --- a/go.work.sum +++ b/go.work.sum @@ -1103,6 +1103,7 @@ github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.2 h1:71gafPkX0RyJJqq921QJ+JvV github.com/aws/aws-sdk-go-v2/service/kinesis v1.27.2/go.mod h1:7w4Wsl8JbRrZmi6YHRa0fxvLyY+VoYSVmC7OpdJP/VQ= github.com/aws/aws-sdk-go-v2/service/kinesis v1.33.2 h1:t3Ukha929to7c4SZDeCP3aRQBgn01nhwKxggYOVRMR0= github.com/aws/aws-sdk-go-v2/service/kinesis v1.33.2/go.mod h1:dJngkoVMrq0K7QvRkdRZYM4NUp6cdWa2GBdpm8zoY8U= +github.com/aws/aws-sdk-go-v2/service/route53 v1.6.2 h1:OsggywXCk9iFKdu2Aopg3e1oJITIuyW36hA/B0rqupE= github.com/aws/aws-sdk-go-v2/service/route53 v1.6.2/go.mod h1:ZnAMilx42P7DgIrdjlWCkNIGSBLzeyk6T31uB8oGTwY= github.com/aws/aws-sdk-go-v2/service/s3 v1.32.0/go.mod h1:aSl9/LJltSz1cVusiR/Mu8tvI4Sv/5w/WWrJmmkNii0= github.com/aws/aws-sdk-go-v2/service/sfn v1.19.4/go.mod h1:uWCH4ATwNrkRO40j8Dmy7u/Y1/BVWgCM+YjBNYZeOro= From 7c65e0bb85f0391accbf0f2208e04c155a8cce2c Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 17 Sep 2025 15:05:48 -0400 Subject: [PATCH 12/25] skip instrumentation analytics for lambda; versioning compatibility --- contrib/aws/datadog-lambda-go/ddlambda.go | 1 + instrumentation/instrumentation_test.go | 6 ++++++ 2 files changed, 7 insertions(+) diff --git a/contrib/aws/datadog-lambda-go/ddlambda.go b/contrib/aws/datadog-lambda-go/ddlambda.go index 22d262a59e..14d8cd26d9 100644 --- a/contrib/aws/datadog-lambda-go/ddlambda.go +++ b/contrib/aws/datadog-lambda-go/ddlambda.go @@ -23,6 +23,7 @@ import ( "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/metrics" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/trace" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/wrapper" + _ "github.com/DataDog/dd-trace-go/v2/instrumentation" // for version compatibility ) type ( diff --git a/instrumentation/instrumentation_test.go b/instrumentation/instrumentation_test.go index ec2264e964..b1812b6d9b 100644 --- a/instrumentation/instrumentation_test.go +++ b/instrumentation/instrumentation_test.go @@ -16,6 +16,12 @@ func TestInstrumentation_AnalyticsRate(t *testing.T) { pkgs := GetPackages() for pkg, info := range pkgs { t.Run(string(pkg), func(t *testing.T) { + // Skip packages that don't implement analytics functionality + if pkg == PackageAWSDatadogLambdaGo { + t.Skip("Lambda contrib does not implement analytics functionality") + return + } + instr := Load(pkg) // No env var set, without defaulting to global should return NaN From 91d334eb89f9ccbb1c4068da458c5dcb2b934956 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 17 Sep 2025 15:18:24 -0400 Subject: [PATCH 13/25] update contribs_generated.go --- internal/stacktrace/contribs_generated.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/internal/stacktrace/contribs_generated.go b/internal/stacktrace/contribs_generated.go index e867b0f601..23e707ae32 100644 --- a/internal/stacktrace/contribs_generated.go +++ b/internal/stacktrace/contribs_generated.go @@ -150,6 +150,7 @@ func generatedThirdPartyLibraries() []string { "github.com/Azure/go-ntlmssp", "github.com/AzureAD/microsoft-authentication-library-for-go", "github.com/BurntSushi/toml", + "github.com/DATA-DOG/go-sqlmock", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping", @@ -179,6 +180,7 @@ func generatedThirdPartyLibraries() []string { "github.com/armon/go-radix", "github.com/armon/go-socks5", "github.com/asaskevich/govalidator", + "github.com/aws/aws-lambda-go", "github.com/aws/aws-sdk-go", "github.com/aws/aws-sdk-go-v2", "github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream", @@ -198,6 +200,8 @@ func generatedThirdPartyLibraries() []string { "github.com/aws/aws-sdk-go-v2/service/internal/presigned-url", "github.com/aws/aws-sdk-go-v2/service/internal/s3shared", "github.com/aws/aws-sdk-go-v2/service/kinesis", + "github.com/aws/aws-sdk-go-v2/service/kms", + "github.com/aws/aws-sdk-go-v2/service/route53", "github.com/aws/aws-sdk-go-v2/service/s3", "github.com/aws/aws-sdk-go-v2/service/sfn", "github.com/aws/aws-sdk-go-v2/service/sns", @@ -205,6 +209,7 @@ func generatedThirdPartyLibraries() []string { "github.com/aws/aws-sdk-go-v2/service/sso", "github.com/aws/aws-sdk-go-v2/service/ssooidc", "github.com/aws/aws-sdk-go-v2/service/sts", + "github.com/aws/aws-xray-sdk-go/v2", "github.com/aws/smithy-go", "github.com/beorn7/perks", "github.com/bgentry/speakeasy", @@ -384,6 +389,7 @@ func generatedThirdPartyLibraries() []string { "github.com/graphql-go/handler", "github.com/gregjones/httpcache", "github.com/grpc-ecosystem/go-grpc-middleware", + "github.com/grpc-ecosystem/go-grpc-middleware/v2", "github.com/grpc-ecosystem/go-grpc-prometheus", "github.com/grpc-ecosystem/grpc-gateway", "github.com/grpc-ecosystem/grpc-gateway/v2", @@ -585,6 +591,7 @@ func generatedThirdPartyLibraries() []string { "github.com/shopspring/decimal", "github.com/sirupsen/logrus", "github.com/smartystreets/go-aws-auth", + "github.com/sony/gobreaker", "github.com/sosodev/duration", "github.com/spaolacci/murmur3", "github.com/spf13/afero", @@ -651,6 +658,7 @@ func generatedThirdPartyLibraries() []string { "github.com/xeipuuv/gojsonreference", "github.com/xeipuuv/gojsonschema", "github.com/xrash/smetrics", + "github.com/xyproto/randomstring", "github.com/yosida95/uritemplate/v3", "github.com/youmark/pkcs8", "github.com/yuin/goldmark", @@ -694,6 +702,7 @@ func generatedThirdPartyLibraries() []string { "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp", "go.opentelemetry.io/otel/exporters/prometheus", "go.opentelemetry.io/otel/log", + "go.opentelemetry.io/otel/log/logtest", "go.opentelemetry.io/otel/metric", "go.opentelemetry.io/otel/sdk", "go.opentelemetry.io/otel/sdk/metric", From 56abae6eaed2ea7dd30f85e453377f7a980ff97d Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 17 Sep 2025 15:32:53 -0400 Subject: [PATCH 14/25] update contribs_generated.go in internal/stacktrace --- internal/stacktrace/contribs_generated.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/internal/stacktrace/contribs_generated.go b/internal/stacktrace/contribs_generated.go index 23e707ae32..c8a5888322 100644 --- a/internal/stacktrace/contribs_generated.go +++ b/internal/stacktrace/contribs_generated.go @@ -658,7 +658,6 @@ func generatedThirdPartyLibraries() []string { "github.com/xeipuuv/gojsonreference", "github.com/xeipuuv/gojsonschema", "github.com/xrash/smetrics", - "github.com/xyproto/randomstring", "github.com/yosida95/uritemplate/v3", "github.com/youmark/pkcs8", "github.com/yuin/goldmark", @@ -702,7 +701,6 @@ func generatedThirdPartyLibraries() []string { "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp", "go.opentelemetry.io/otel/exporters/prometheus", "go.opentelemetry.io/otel/log", - "go.opentelemetry.io/otel/log/logtest", "go.opentelemetry.io/otel/metric", "go.opentelemetry.io/otel/sdk", "go.opentelemetry.io/otel/sdk/metric", From 3e930490ab560311dedae2f54509bd4ae2870d58 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Thu, 18 Sep 2025 14:05:38 -0400 Subject: [PATCH 15/25] update contribs_generated.go --- internal/stacktrace/contribs_generated.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/internal/stacktrace/contribs_generated.go b/internal/stacktrace/contribs_generated.go index b7aef33650..23e0e4952a 100644 --- a/internal/stacktrace/contribs_generated.go +++ b/internal/stacktrace/contribs_generated.go @@ -150,7 +150,6 @@ func generatedThirdPartyLibraries() []string { "github.com/Azure/go-ntlmssp", "github.com/AzureAD/microsoft-authentication-library-for-go", "github.com/BurntSushi/toml", - "github.com/DATA-DOG/go-sqlmock", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping", @@ -180,7 +179,6 @@ func generatedThirdPartyLibraries() []string { "github.com/armon/go-radix", "github.com/armon/go-socks5", "github.com/asaskevich/govalidator", - "github.com/aws/aws-lambda-go", "github.com/aws/aws-sdk-go", "github.com/aws/aws-sdk-go-v2", "github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream", @@ -200,8 +198,6 @@ func generatedThirdPartyLibraries() []string { "github.com/aws/aws-sdk-go-v2/service/internal/presigned-url", "github.com/aws/aws-sdk-go-v2/service/internal/s3shared", "github.com/aws/aws-sdk-go-v2/service/kinesis", - "github.com/aws/aws-sdk-go-v2/service/kms", - "github.com/aws/aws-sdk-go-v2/service/route53", "github.com/aws/aws-sdk-go-v2/service/s3", "github.com/aws/aws-sdk-go-v2/service/sfn", "github.com/aws/aws-sdk-go-v2/service/sns", @@ -209,7 +205,6 @@ func generatedThirdPartyLibraries() []string { "github.com/aws/aws-sdk-go-v2/service/sso", "github.com/aws/aws-sdk-go-v2/service/ssooidc", "github.com/aws/aws-sdk-go-v2/service/sts", - "github.com/aws/aws-xray-sdk-go/v2", "github.com/aws/smithy-go", "github.com/beorn7/perks", "github.com/bgentry/speakeasy", @@ -389,7 +384,6 @@ func generatedThirdPartyLibraries() []string { "github.com/graphql-go/handler", "github.com/gregjones/httpcache", "github.com/grpc-ecosystem/go-grpc-middleware", - "github.com/grpc-ecosystem/go-grpc-middleware/v2", "github.com/grpc-ecosystem/go-grpc-prometheus", "github.com/grpc-ecosystem/grpc-gateway", "github.com/grpc-ecosystem/grpc-gateway/v2", @@ -591,7 +585,6 @@ func generatedThirdPartyLibraries() []string { "github.com/shopspring/decimal", "github.com/sirupsen/logrus", "github.com/smartystreets/go-aws-auth", - "github.com/sony/gobreaker", "github.com/sosodev/duration", "github.com/spaolacci/murmur3", "github.com/spf13/afero", From 681e22574fac4393624e075e68a3f80c3126cbdb Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Thu, 18 Sep 2025 14:16:20 -0400 Subject: [PATCH 16/25] update after fix_modules.sh --- contrib/aws/datadog-lambda-go/go.mod | 3 ++- contrib/aws/datadog-lambda-go/go.sum | 6 ++++-- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod index 18050e0b4f..ce364b27bf 100644 --- a/contrib/aws/datadog-lambda-go/go.mod +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -27,7 +27,7 @@ require ( github.com/DataDog/datadog-agent/pkg/util/log v0.67.0 // indirect github.com/DataDog/datadog-agent/pkg/util/scrubber v0.67.0 // indirect github.com/DataDog/datadog-agent/pkg/version v0.67.0 // indirect - github.com/DataDog/go-libddwaf/v4 v4.3.2 // indirect + github.com/DataDog/go-libddwaf/v4 v4.5.0 // indirect github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 // indirect github.com/DataDog/go-sqllexer v0.1.6 // indirect github.com/DataDog/go-tuf v1.1.0-0.5.2 // indirect @@ -94,6 +94,7 @@ require ( go.opentelemetry.io/otel/trace v1.35.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.27.0 // indirect + go.yaml.in/yaml/v3 v3.0.4 // indirect golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect golang.org/x/mod v0.25.0 // indirect golang.org/x/net v0.40.0 // indirect diff --git a/contrib/aws/datadog-lambda-go/go.sum b/contrib/aws/datadog-lambda-go/go.sum index b78bf03702..80b14fabe5 100644 --- a/contrib/aws/datadog-lambda-go/go.sum +++ b/contrib/aws/datadog-lambda-go/go.sum @@ -18,8 +18,8 @@ github.com/DataDog/datadog-agent/pkg/version v0.67.0 h1:TB8H8r+laB1Qdttvvc6XJVyL github.com/DataDog/datadog-agent/pkg/version v0.67.0/go.mod h1:kvAw/WbI7qLAsDI2wHabZfM7Cv2zraD3JA3323GEB+8= github.com/DataDog/datadog-go/v5 v5.6.0 h1:2oCLxjF/4htd55piM75baflj/KoE6VYS7alEUqFvRDw= github.com/DataDog/datadog-go/v5 v5.6.0/go.mod h1:K9kcYBlxkcPP8tvvjZZKs/m1edNAUFzBbdpTUKfCsuw= -github.com/DataDog/go-libddwaf/v4 v4.3.2 h1:YGvW2Of1C4e1yU+p7iibmhN2zEOgi9XEchbhQjBxb/A= -github.com/DataDog/go-libddwaf/v4 v4.3.2/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= +github.com/DataDog/go-libddwaf/v4 v4.5.0 h1:dXD9xL9T02Mqu9AH7imXpGThKAYqO3BmT2QoXbMFxow= +github.com/DataDog/go-libddwaf/v4 v4.5.0/go.mod h1:/AZqP6zw3qGJK5mLrA0PkfK3UQDk1zCI2fUNCt4xftE= github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633 h1:ZRLR9Lbym748e8RznWzmSoK+OfV+8qW6SdNYA4/IqdA= github.com/DataDog/go-runtime-metrics-internal v0.0.4-0.20250721125240-fdf1ef85b633/go.mod h1:YFoTl1xsMzdSRFIu33oCSPS/3+HZAPGpO3oOM96wXCM= github.com/DataDog/go-sqllexer v0.1.6 h1:skEXpWEVCpeZFIiydoIa2f2rf+ymNpjiIMqpW4w3YAk= @@ -268,6 +268,8 @@ go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= From a3cedf2d12dddff7887b66303175d6da54c53537 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Thu, 18 Sep 2025 14:28:50 -0400 Subject: [PATCH 17/25] update contribs_generated.go --- internal/stacktrace/contribs_generated.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/internal/stacktrace/contribs_generated.go b/internal/stacktrace/contribs_generated.go index 23e0e4952a..6e29941eb5 100644 --- a/internal/stacktrace/contribs_generated.go +++ b/internal/stacktrace/contribs_generated.go @@ -150,6 +150,7 @@ func generatedThirdPartyLibraries() []string { "github.com/Azure/go-ntlmssp", "github.com/AzureAD/microsoft-authentication-library-for-go", "github.com/BurntSushi/toml", + "github.com/DATA-DOG/go-sqlmock", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric", "github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping", @@ -179,6 +180,7 @@ func generatedThirdPartyLibraries() []string { "github.com/armon/go-radix", "github.com/armon/go-socks5", "github.com/asaskevich/govalidator", + "github.com/aws/aws-lambda-go", "github.com/aws/aws-sdk-go", "github.com/aws/aws-sdk-go-v2", "github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream", @@ -198,6 +200,8 @@ func generatedThirdPartyLibraries() []string { "github.com/aws/aws-sdk-go-v2/service/internal/presigned-url", "github.com/aws/aws-sdk-go-v2/service/internal/s3shared", "github.com/aws/aws-sdk-go-v2/service/kinesis", + "github.com/aws/aws-sdk-go-v2/service/kms", + "github.com/aws/aws-sdk-go-v2/service/route53", "github.com/aws/aws-sdk-go-v2/service/s3", "github.com/aws/aws-sdk-go-v2/service/sfn", "github.com/aws/aws-sdk-go-v2/service/sns", @@ -205,6 +209,7 @@ func generatedThirdPartyLibraries() []string { "github.com/aws/aws-sdk-go-v2/service/sso", "github.com/aws/aws-sdk-go-v2/service/ssooidc", "github.com/aws/aws-sdk-go-v2/service/sts", + "github.com/aws/aws-xray-sdk-go/v2", "github.com/aws/smithy-go", "github.com/beorn7/perks", "github.com/bgentry/speakeasy", @@ -384,6 +389,7 @@ func generatedThirdPartyLibraries() []string { "github.com/graphql-go/handler", "github.com/gregjones/httpcache", "github.com/grpc-ecosystem/go-grpc-middleware", + "github.com/grpc-ecosystem/go-grpc-middleware/v2", "github.com/grpc-ecosystem/go-grpc-prometheus", "github.com/grpc-ecosystem/grpc-gateway", "github.com/grpc-ecosystem/grpc-gateway/v2", @@ -585,6 +591,7 @@ func generatedThirdPartyLibraries() []string { "github.com/shopspring/decimal", "github.com/sirupsen/logrus", "github.com/smartystreets/go-aws-auth", + "github.com/sony/gobreaker", "github.com/sosodev/duration", "github.com/spaolacci/murmur3", "github.com/spf13/afero", @@ -651,6 +658,7 @@ func generatedThirdPartyLibraries() []string { "github.com/xeipuuv/gojsonreference", "github.com/xeipuuv/gojsonschema", "github.com/xrash/smetrics", + "github.com/xyproto/randomstring", "github.com/yosida95/uritemplate/v3", "github.com/youmark/pkcs8", "github.com/yuin/goldmark", @@ -694,6 +702,7 @@ func generatedThirdPartyLibraries() []string { "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp", "go.opentelemetry.io/otel/exporters/prometheus", "go.opentelemetry.io/otel/log", + "go.opentelemetry.io/otel/log/logtest", "go.opentelemetry.io/otel/metric", "go.opentelemetry.io/otel/sdk", "go.opentelemetry.io/otel/sdk/metric", From 8632e7c308da762d7bc71f9a3a8f2cf04e4f7b8a Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Thu, 18 Sep 2025 14:52:52 -0400 Subject: [PATCH 18/25] update contribs_generated.go --- internal/stacktrace/contribs_generated.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/internal/stacktrace/contribs_generated.go b/internal/stacktrace/contribs_generated.go index 6e29941eb5..b7aef33650 100644 --- a/internal/stacktrace/contribs_generated.go +++ b/internal/stacktrace/contribs_generated.go @@ -658,7 +658,6 @@ func generatedThirdPartyLibraries() []string { "github.com/xeipuuv/gojsonreference", "github.com/xeipuuv/gojsonschema", "github.com/xrash/smetrics", - "github.com/xyproto/randomstring", "github.com/yosida95/uritemplate/v3", "github.com/youmark/pkcs8", "github.com/yuin/goldmark", @@ -702,7 +701,6 @@ func generatedThirdPartyLibraries() []string { "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp", "go.opentelemetry.io/otel/exporters/prometheus", "go.opentelemetry.io/otel/log", - "go.opentelemetry.io/otel/log/logtest", "go.opentelemetry.io/otel/metric", "go.opentelemetry.io/otel/sdk", "go.opentelemetry.io/otel/sdk/metric", From 30b25137f369be006eec9784bcb8381851d0621d Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 24 Sep 2025 00:15:07 -0400 Subject: [PATCH 19/25] remove extra char --- contrib/aws/datadog-lambda-go/internal/metrics/listener.go | 2 +- .../aws/datadog-lambda-go/internal/metrics/listener_test.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go index f7a2a96a73..af7e3cbeb8 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -248,7 +248,7 @@ func getEnhancedMetricsTags(ctx context.Context) []string { memorySize := fmt.Sprintf("memorysize:%d", lambdacontext.MemoryLimitInMB) coldStart := fmt.Sprintf("cold_start:%t", isColdStart.(bool)) resource := fmt.Sprintf("resource:%s", lambdacontext.FunctionName) - datadogLambda := fmt.Sprintf("datadog_lambda:v%s", instrumentation.Version()) + datadogLambda := fmt.Sprintf("datadog_lambda:%s", instrumentation.Version()) tags := []string{functionName, region, accountId, memorySize, coldStart, datadogLambda} diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go index f85f33b874..e5c64a7fc7 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -150,7 +150,7 @@ func TestGetEnhancedMetricsTags(t *testing.T) { } tags := getEnhancedMetricsTags(lambdacontext.NewContext(ctx, lc)) - assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:v" + instrumentation.Version()}) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:Latest", "datadog_lambda:" + instrumentation.Version()}) } func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { @@ -165,7 +165,7 @@ func TestGetEnhancedMetricsTagsWithAlias(t *testing.T) { } tags := getEnhancedMetricsTags((lambdacontext.NewContext(ctx, lc))) - assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:v" + instrumentation.Version()}) + assert.ElementsMatch(t, tags, []string{"functionname:go-lambda-test", "region:us-east-1", "memorysize:256", "cold_start:false", "account_id:123497558138", "resource:go-lambda-test:my-alias", "executedversion:1", "datadog_lambda:" + instrumentation.Version()}) } func TestGetEnhancedMetricsTagsNoLambdaContext(t *testing.T) { From 36fcf2f44c515469ea9abaa7519eb81d34196202 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 24 Sep 2025 00:24:54 -0400 Subject: [PATCH 20/25] add extension.go change https://github.com/DataDog/datadog-lambda-go/commit/c0b16b263710c91df3294d3cf2a894d7a9f2f5c2 --- .../internal/extension/extension.go | 35 ++++++++++++++++--- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension.go b/contrib/aws/datadog-lambda-go/internal/extension/extension.go index 78d689c94f..b1c411a6b1 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension.go @@ -11,6 +11,7 @@ import ( "encoding/base64" "encoding/json" "fmt" + "io" "net/http" "os" "reflect" @@ -94,7 +95,14 @@ func (em *ExtensionManager) checkAgentRunning() { // Tell the extension not to create an execution span if universal instrumentation is disabled if !em.isUniversalInstrumentation { req, _ := http.NewRequest(http.MethodGet, em.helloRoute, nil) - if response, err := em.httpClient.Do(req); err == nil && response.StatusCode == 200 { + response, err := em.httpClient.Do(req) + if response != nil && response.Body != nil { + defer func() { + _, _ = io.Copy(io.Discard, response.Body) + response.Body.Close() + }() + } + if err == nil && response.StatusCode == 200 { logger.Debug("Hit the extension /hello route") } else { logger.Debug("Will use the API since the Serverless Agent was detected but the hello route was unreachable") @@ -107,8 +115,14 @@ func (em *ExtensionManager) checkAgentRunning() { func (em *ExtensionManager) SendStartInvocationRequest(ctx context.Context, eventPayload json.RawMessage) context.Context { body := bytes.NewBuffer(eventPayload) req, _ := http.NewRequest(http.MethodPost, em.startInvocationUrl, body) - - if response, err := em.httpClient.Do(req); err == nil && response.StatusCode == 200 { + response, err := em.httpClient.Do(req) + if response != nil && response.Body != nil { + defer func() { + _, _ = io.Copy(io.Discard, response.Body) + response.Body.Close() + }() + } + if err == nil && response.StatusCode == 200 { // Propagate dd-trace context from the extension response if found in the response headers traceId := response.Header.Get(string(DdTraceId)) if traceId != "" { @@ -172,6 +186,12 @@ func (em *ExtensionManager) SendEndInvocationRequest(ctx context.Context, functi } resp, err := em.httpClient.Do(req) + if resp != nil && resp.Body != nil { + defer func() { + _, _ = io.Copy(io.Discard, resp.Body) + resp.Body.Close() + }() + } if err != nil || resp.StatusCode != 200 { logger.Error(fmt.Errorf("could not send end invocation payload to the extension: %v", err)) } @@ -220,7 +240,14 @@ func (em *ExtensionManager) IsExtensionRunning() bool { func (em *ExtensionManager) Flush() error { req, _ := http.NewRequest(http.MethodGet, em.flushRoute, nil) - if response, err := em.httpClient.Do(req); err != nil { + response, err := em.httpClient.Do(req) + if response != nil && response.Body != nil { + defer func() { + _, _ = io.Copy(io.Discard, response.Body) + response.Body.Close() + }() + } + if err != nil { err := fmt.Errorf("was not able to reach the Agent to flush: %s", err) logger.Error(err) return err From 4c9f2796407986811efd677e945893e8718088d7 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 24 Sep 2025 10:33:32 -0400 Subject: [PATCH 21/25] add metrics listener change https://github.com/DataDog/datadog-lambda-go/commit/aa7da5eb32fe27cbb45266a10d30be6bc3a6eb71#diff-a9d3a18163f34237573eab1fef6025e5f0b3fe30694d7f6e3b00cd85c69d3134 --- .../internal/metrics/listener.go | 16 +++++++++++--- .../internal/metrics/listener_test.go | 21 +++++++++++++++++++ 2 files changed, 34 insertions(+), 3 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go index af7e3cbeb8..eaaefe3bd1 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener.go @@ -58,6 +58,12 @@ type ( } ) +var ( + // runtimeTag is the metrics tag representing the go runtime version. Use + // this rather than calling getRuntimeTag directly. + runtimeTag = getRuntimeTag(runtime.Version()) +) + // MakeListener initializes a new metrics lambda listener func MakeListener(config Config, extensionManager *extension.ExtensionManager) Listener { @@ -170,7 +176,7 @@ func (l *Listener) HandlerFinished(ctx context.Context, err error) { func (l *Listener) AddDistributionMetric(metric string, value float64, timestamp time.Time, forceLogForwarder bool, tags ...string) { // We add our own runtime tag to the metric for version tracking - tags = append(tags, getRuntimeTag()) + tags = append(tags, runtimeTag) if l.isAgentRunning { err := l.statsdClient.Distribution(metric, value, tags, 1) @@ -214,8 +220,12 @@ func (l *Listener) AddDistributionMetric(metric string, value float64, timestamp l.processor.AddMetric(&m) } -func getRuntimeTag() string { - v := runtime.Version() +// getRuntimeTag returns the runtime tag to be used when creating distribution +// metrics. It should not be called directly, instead use the global +// runtimeTag var. +func getRuntimeTag(v string) string { + v = strings.ReplaceAll(v, " ", "-") + v = strings.ReplaceAll(v, ",", "-") return fmt.Sprintf("dd_lambda_layer:datadog-%s", v) } diff --git a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go index e5c64a7fc7..924e89f4f3 100644 --- a/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go +++ b/contrib/aws/datadog-lambda-go/internal/metrics/listener_test.go @@ -202,6 +202,7 @@ func TestSubmitEnhancedMetrics(t *testing.T) { assert.False(t, called) expected := "{\"m\":\"aws.lambda.enhanced.invocations\",\"v\":1," assert.True(t, strings.Contains(output, expected)) + assert.True(t, strings.Contains(output, "dd_lambda_layer:datadog-go1.")) } func TestDoNotSubmitEnhancedMetrics(t *testing.T) { @@ -287,3 +288,23 @@ func TestListenerHandlerFinishedFlushes(t *testing.T) { }) } } + +func TestGetRuntimeTag(t *testing.T) { + testcases := []struct { + runtimeVersion string + expect string + }{ + {"", "dd_lambda_layer:datadog-"}, + {"go1.25.1", "dd_lambda_layer:datadog-go1.25.1"}, + // runtime.Version() will include any values from the GOEXPERIMENT env var + {"go1.25.1 X:jsonv2", "dd_lambda_layer:datadog-go1.25.1-X:jsonv2"}, + {"go1.25.1 X:fieldtrace,jsonv2", "dd_lambda_layer:datadog-go1.25.1-X:fieldtrace-jsonv2"}, + } + + for _, tc := range testcases { + t.Run(tc.runtimeVersion, func(t *testing.T) { + actual := getRuntimeTag(tc.runtimeVersion) + assert.Equal(t, actual, tc.expect) + }) + } +} From b270629f68660b9fdb6ab4154ec9117f48e7fc3e Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 24 Sep 2025 12:15:19 -0400 Subject: [PATCH 22/25] should use TraceIDLower in SendEndInvocationRequest --- contrib/aws/datadog-lambda-go/internal/extension/extension.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/contrib/aws/datadog-lambda-go/internal/extension/extension.go b/contrib/aws/datadog-lambda-go/internal/extension/extension.go index b1c411a6b1..12312f2d1e 100644 --- a/contrib/aws/datadog-lambda-go/internal/extension/extension.go +++ b/contrib/aws/datadog-lambda-go/internal/extension/extension.go @@ -176,7 +176,7 @@ func (em *ExtensionManager) SendEndInvocationRequest(ctx context.Context, functi } } else { spanContext := functionExecutionSpan.Context() - req.Header.Set(string(DdTraceId), fmt.Sprint(spanContext.TraceID())) + req.Header.Set(string(DdTraceId), fmt.Sprint(spanContext.TraceIDLower())) req.Header.Set(string(DdSpanId), fmt.Sprint(spanContext.SpanID())) // Try to get sampling priority From a74f8e1b8933302a331cdfb1618f8efb46e9ed6d Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Wed, 24 Sep 2025 14:27:03 -0400 Subject: [PATCH 23/25] update after running fix_modules.sh --- contrib/aws/datadog-lambda-go/go.mod | 2 ++ contrib/aws/datadog-lambda-go/go.sum | 5 +++++ 2 files changed, 7 insertions(+) diff --git a/contrib/aws/datadog-lambda-go/go.mod b/contrib/aws/datadog-lambda-go/go.mod index ce364b27bf..780be38934 100644 --- a/contrib/aws/datadog-lambda-go/go.mod +++ b/contrib/aws/datadog-lambda-go/go.mod @@ -62,7 +62,9 @@ require ( github.com/hashicorp/go-version v1.7.0 // indirect github.com/json-iterator/go v1.1.12 // indirect github.com/klauspost/compress v1.18.0 // indirect + github.com/klauspost/cpuid/v2 v2.2.3 // indirect github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect + github.com/minio/simdjson-go v0.4.5 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect github.com/outcaste-io/ristretto v0.2.3 // indirect diff --git a/contrib/aws/datadog-lambda-go/go.sum b/contrib/aws/datadog-lambda-go/go.sum index 80b14fabe5..90b129fd87 100644 --- a/contrib/aws/datadog-lambda-go/go.sum +++ b/contrib/aws/datadog-lambda-go/go.sum @@ -129,12 +129,16 @@ github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU= +github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 h1:7UMa6KCCMjZEMDtTVdcGu0B1GmmC7QJKiCCjyTAWQy0= github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683/go.mod h1:ilwx/Dta8jXAgpFYFvSWEMwxmbWXyiUHkd5FwyKhb5k= +github.com/minio/simdjson-go v0.4.5 h1:r4IQwjRGmWCQ2VeMc7fGiilu1z5du0gJ/I/FsKwgo5A= +github.com/minio/simdjson-go v0.4.5/go.mod h1:eoNz0DcLQRyEDeaPr4Ru6JpjlZPzbA0IodxVJk8lO8E= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= @@ -304,6 +308,7 @@ golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220627191245-f75cf1eec38b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= From 9d07173de4a758ead42e3fdb636256d6a31aa425 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Thu, 25 Sep 2025 11:27:27 -0400 Subject: [PATCH 24/25] use the constants in packages.go --- contrib/aws/datadog-lambda-go/internal/trace/listener.go | 5 +++-- instrumentation/packages.go | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/contrib/aws/datadog-lambda-go/internal/trace/listener.go b/contrib/aws/datadog-lambda-go/internal/trace/listener.go index b823a9c070..be224412dc 100644 --- a/contrib/aws/datadog-lambda-go/internal/trace/listener.go +++ b/contrib/aws/datadog-lambda-go/internal/trace/listener.go @@ -12,6 +12,7 @@ import ( "os" "strings" + "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/extension" "github.com/DataDog/dd-trace-go/contrib/aws/datadog-lambda-go/v2/internal/logger" "github.com/DataDog/dd-trace-go/v2/ddtrace" @@ -79,7 +80,7 @@ func (l *Listener) HandlerStarted(ctx context.Context, msg json.RawMessage) cont if !tracerInitialized { serviceName := os.Getenv("DD_SERVICE") if serviceName == "" { - serviceName = "aws.lambda" + serviceName = internal.Instr.ServiceName(instrumentation.ComponentDefault, instrumentation.OperationContext{}) } extensionNotRunning := !l.extensionManager.IsExtensionRunning() opts := append([]ddtracer.StartOption{ @@ -172,7 +173,7 @@ func startFunctionExecutionSpan(ctx context.Context, mergeXrayTraces bool, isDdS } span := ddtracer.StartSpan( - "aws.lambda", // This operation name will be replaced with the value of the service tag by the Forwarder + internal.Instr.OperationName(instrumentation.ComponentDefault, instrumentation.OperationContext{}), // This operation name will be replaced with the value of the service tag by the Forwarder spanOptions..., ) diff --git a/instrumentation/packages.go b/instrumentation/packages.go index 23b3bbbd9a..7539c84bbe 100644 --- a/instrumentation/packages.go +++ b/instrumentation/packages.go @@ -176,8 +176,8 @@ var packages = map[Package]PackageInfo{ ComponentDefault: { useDDServiceV0: false, buildServiceNameV0: staticName("aws.lambda"), - buildOpNameV0: staticName("aws.lambda.invoke"), - buildOpNameV1: staticName("aws.lambda.invoke"), + buildOpNameV0: staticName("aws.lambda"), + buildOpNameV1: staticName("aws.lambda"), }, }, }, From 93022f82ff72ef4c77e24c830e03e4f912ad09c0 Mon Sep 17 00:00:00 2001 From: Joey Zhao <5253430+joeyzhao2018@users.noreply.github.com> Date: Fri, 26 Sep 2025 10:29:35 -0400 Subject: [PATCH 25/25] update CODEOWNERS --- CODEOWNERS | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CODEOWNERS b/CODEOWNERS index 197fe3eabd..f183faf04e 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -62,6 +62,9 @@ /internal/orchestrion @DataDog/apm-orchestrion /**/orchestrion.yml @DataDog/apm-orchestrion +# Serverless +/contrib/aws/datadog-lambda-go @DataDog/apm-serverless @DataDog/serverless-aws + # no owner: changes to these files will not automatically ping any particular # team and can be reviewed by anybody with the appropriate permissions. This is # meant to avoid pinging all of @DataDog/dd-trace-go-guild for every PR that