AWS CDK Reference

Appearance

v2.274.0

Experimental

@aws-cdk/aws-applicationsignals-alpha is an experimental (alpha) package: its API may change in any release, without a major version bump.

TraceExporting Class ​

OpenTelemetry trace exporter and sampling configurations.

Contains constants for trace endpoints, sampling strategies, and propagation formats.

Stability
Experimental
Source
lib/enablement/constants.ts

Example ​

ts
import { Construct } from 'constructs';
import * as appsignals from '@aws-cdk/aws-applicationsignals-alpha';
import * as cdk from 'aws-cdk-lib';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import { PrivateDnsNamespace } from 'aws-cdk-lib/aws-servicediscovery';

class MyStack extends cdk.Stack {
  public constructor(scope?: Construct, id?: string, props: cdk.StackProps = {}) {
    super(scope, id, props);

    const vpc = new ec2.Vpc(this, 'TestVpc', {});
    const cluster = new ecs.Cluster(this, 'TestCluster', { vpc });
    const dnsNamespace = new PrivateDnsNamespace(this, 'Namespace', {
      vpc,
      name: 'local',
    });
    const securityGroup = new ec2.SecurityGroup(this, 'ECSSG', { vpc });
    securityGroup.addIngressRule(securityGroup, ec2.Port.tcpRange(0, 65535));

    // Define Task Definition for CloudWatch agent (Replica)
    const cwAgentTaskDefinition = new ecs.FargateTaskDefinition(this, 'CloudWatchAgentTaskDefinition', {});

    new appsignals.CloudWatchAgentIntegration(this, 'CloudWatchAgentIntegration', {
      taskDefinition: cwAgentTaskDefinition,
      containerName: 'ecs-cwagent',
      enableLogging: false,
      cpu: 128,
      memoryLimitMiB: 64,
      portMappings: [
        {
          name: 'cwagent-4316',
          containerPort: 4316,
          hostPort: 4316,
        },
        {
          name: 'cwagent-2000',
          containerPort: 2000,
          hostPort: 2000,
        },
      ],
    });

    // Create the CloudWatch Agent replica service with service connect
    new ecs.FargateService(this, 'CloudWatchAgentService', {
      cluster: cluster,
      taskDefinition: cwAgentTaskDefinition,
      securityGroups: [securityGroup],
      serviceConnectConfiguration: {
        namespace: dnsNamespace.namespaceArn,
        services: [
          {
            portMappingName: 'cwagent-4316',
            dnsName: 'cwagent-4316-http',
            port: 4316,
          },
          {
            portMappingName: 'cwagent-2000',
            dnsName: 'cwagent-2000-http',
            port: 2000,
          },
        ],
      },
      desiredCount: 1,
    });

    // Define Task Definition for user application
    const sampleAppTaskDefinition = new ecs.FargateTaskDefinition(this, 'SampleAppTaskDefinition', {});

    sampleAppTaskDefinition.addContainer('app', {
      image: ecs.ContainerImage.fromRegistry('test/sample-app'),
      cpu: 0,
      memoryLimitMiB: 512,
    });

    // Overwrite environment variables to connect to the CloudWatch Agent service just created
    new appsignals.ApplicationSignalsIntegration(this, 'ApplicationSignalsIntegration', {
      taskDefinition: sampleAppTaskDefinition,
      instrumentation: {
        sdkVersion: appsignals.PythonInstrumentationVersion.V0_8_0,
      },
      serviceName: 'sample-app',
      overrideEnvironments: [
        {
          name: appsignals.CommonExporting.OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT,
          value: 'http://cwagent-4316-http:4316/v1/metrics',
        },
        {
          name: appsignals.TraceExporting.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
          value: 'http://cwagent-4316-http:4316/v1/traces',
        },
        {
          name: appsignals.TraceExporting.OTEL_TRACES_SAMPLER_ARG,
          value: 'endpoint=http://cwagent-2000-http:2000',
        },
      ],
    });

    // Create ECS Service with service connect configuration
    new ecs.FargateService(this, 'MySampleApp', {
      cluster: cluster,
      taskDefinition: sampleAppTaskDefinition,
      serviceConnectConfiguration: {
        namespace: dnsNamespace.namespaceArn,
      },
      desiredCount: 1,
    });
  }
}
python
from constructs import Construct
import aws_cdk.aws_applicationsignals_alpha as appsignals
import aws_cdk as cdk
import aws_cdk.aws_ec2 as ec2
import aws_cdk.aws_ecs as ecs
from aws_cdk.aws_servicediscovery import PrivateDnsNamespace

class MyStack(cdk.Stack):
    def __init__(self, scope=None, id=None, *, description=None, env=None, stackName=None, tags=None, notificationArns=None, synthesizer=None, terminationProtection=None, analyticsReporting=None, crossRegionReferences=None, permissionsBoundary=None, suppressTemplateIndentation=None, propertyInjectors=None):
        super().__init__(scope, id, description=description, env=env, stackName=stackName, tags=tags, notificationArns=notificationArns, synthesizer=synthesizer, terminationProtection=terminationProtection, analyticsReporting=analyticsReporting, crossRegionReferences=crossRegionReferences, permissionsBoundary=permissionsBoundary, suppressTemplateIndentation=suppressTemplateIndentation, propertyInjectors=propertyInjectors)

        vpc = ec2.Vpc(self, "TestVpc")
        cluster = ecs.Cluster(self, "TestCluster", vpc=vpc)
        dns_namespace = PrivateDnsNamespace(self, "Namespace",
            vpc=vpc,
            name="local"
        )
        security_group = ec2.SecurityGroup(self, "ECSSG", vpc=vpc)
        security_group.add_ingress_rule(security_group, ec2.Port.tcp_range(0, 65535))

        # Define Task Definition for CloudWatch agent (Replica)
        cw_agent_task_definition = ecs.FargateTaskDefinition(self, "CloudWatchAgentTaskDefinition")

        appsignals.CloudWatchAgentIntegration(self, "CloudWatchAgentIntegration",
            task_definition=cw_agent_task_definition,
            container_name="ecs-cwagent",
            enable_logging=False,
            cpu=128,
            memory_limit_mi_b=64,
            port_mappings=[ecs.PortMapping(
                name="cwagent-4316",
                container_port=4316,
                host_port=4316
            ), ecs.PortMapping(
                name="cwagent-2000",
                container_port=2000,
                host_port=2000
            )
            ]
        )

        # Create the CloudWatch Agent replica service with service connect
        ecs.FargateService(self, "CloudWatchAgentService",
            cluster=cluster,
            task_definition=cw_agent_task_definition,
            security_groups=[security_group],
            service_connect_configuration=ecs.ServiceConnectProps(
                namespace=dns_namespace.namespace_arn,
                services=[ecs.ServiceConnectService(
                    port_mapping_name="cwagent-4316",
                    dns_name="cwagent-4316-http",
                    port=4316
                ), ecs.ServiceConnectService(
                    port_mapping_name="cwagent-2000",
                    dns_name="cwagent-2000-http",
                    port=2000
                )
                ]
            ),
            desired_count=1
        )

        # Define Task Definition for user application
        sample_app_task_definition = ecs.FargateTaskDefinition(self, "SampleAppTaskDefinition")

        sample_app_task_definition.add_container("app",
            image=ecs.ContainerImage.from_registry("test/sample-app"),
            cpu=0,
            memory_limit_mi_b=512
        )

        # Overwrite environment variables to connect to the CloudWatch Agent service just created
        appsignals.ApplicationSignalsIntegration(self, "ApplicationSignalsIntegration",
            task_definition=sample_app_task_definition,
            instrumentation=appsignals.InstrumentationProps(
                sdk_version=appsignals.PythonInstrumentationVersion.V0_8_0
            ),
            service_name="sample-app",
            override_environments=[appsignals.EnvironmentExtension(
                name=appsignals.CommonExporting.OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT,
                value="http://cwagent-4316-http:4316/v1/metrics"
            ), appsignals.EnvironmentExtension(
                name=appsignals.TraceExporting.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
                value="http://cwagent-4316-http:4316/v1/traces"
            ), appsignals.EnvironmentExtension(
                name=appsignals.TraceExporting.OTEL_TRACES_SAMPLER_ARG,
                value="endpoint=http://cwagent-2000-http:2000"
            )
            ]
        )

        # Create ECS Service with service connect configuration
        ecs.FargateService(self, "MySampleApp",
            cluster=cluster,
            task_definition=sample_app_task_definition,
            service_connect_configuration=ecs.ServiceConnectProps(
                namespace=dns_namespace.namespace_arn
            ),
            desired_count=1
        )
java
import software.constructs.Construct;
import software.amazon.awscdk.services.applicationsignals.alpha.*;
import software.amazon.awscdk.*;
import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.servicediscovery.PrivateDnsNamespace;

public class MyStack extends Stack {
    public MyStack() {
        this(null);
    }

    public MyStack(Construct scope) {
        this(scope, null);
    }

    public MyStack(Construct scope, String id) {
        this(scope, id, StackProps.builder().build());
    }

    public MyStack(Construct scope, String id, StackProps props) {
        super(scope, id, props);

        Vpc vpc = Vpc.Builder.create(this, "TestVpc").build();
        Cluster cluster = Cluster.Builder.create(this, "TestCluster").vpc(vpc).build();
        PrivateDnsNamespace dnsNamespace = PrivateDnsNamespace.Builder.create(this, "Namespace")
                .vpc(vpc)
                .name("local")
                .build();
        SecurityGroup securityGroup = SecurityGroup.Builder.create(this, "ECSSG").vpc(vpc).build();
        securityGroup.addIngressRule(securityGroup, Port.tcpRange(0, 65535));

        // Define Task Definition for CloudWatch agent (Replica)
        FargateTaskDefinition cwAgentTaskDefinition = FargateTaskDefinition.Builder.create(this, "CloudWatchAgentTaskDefinition").build();

        CloudWatchAgentIntegration.Builder.create(this, "CloudWatchAgentIntegration")
                .taskDefinition(cwAgentTaskDefinition)
                .containerName("ecs-cwagent")
                .enableLogging(false)
                .cpu(128)
                .memoryLimitMiB(64)
                .portMappings(List.of(PortMapping.builder()
                        .name("cwagent-4316")
                        .containerPort(4316)
                        .hostPort(4316)
                        .build(), PortMapping.builder()
                        .name("cwagent-2000")
                        .containerPort(2000)
                        .hostPort(2000)
                        .build()))
                .build();

        // Create the CloudWatch Agent replica service with service connect
        // Create the CloudWatch Agent replica service with service connect
        FargateService.Builder.create(this, "CloudWatchAgentService")
                .cluster(cluster)
                .taskDefinition(cwAgentTaskDefinition)
                .securityGroups(List.of(securityGroup))
                .serviceConnectConfiguration(ServiceConnectProps.builder()
                        .namespace(dnsNamespace.getNamespaceArn())
                        .services(List.of(ServiceConnectService.builder()
                                .portMappingName("cwagent-4316")
                                .dnsName("cwagent-4316-http")
                                .port(4316)
                                .build(), ServiceConnectService.builder()
                                .portMappingName("cwagent-2000")
                                .dnsName("cwagent-2000-http")
                                .port(2000)
                                .build()))
                        .build())
                .desiredCount(1)
                .build();

        // Define Task Definition for user application
        FargateTaskDefinition sampleAppTaskDefinition = FargateTaskDefinition.Builder.create(this, "SampleAppTaskDefinition").build();

        sampleAppTaskDefinition.addContainer("app", ContainerDefinitionOptions.builder()
                .image(ContainerImage.fromRegistry("test/sample-app"))
                .cpu(0)
                .memoryLimitMiB(512)
                .build());

        // Overwrite environment variables to connect to the CloudWatch Agent service just created
        // Overwrite environment variables to connect to the CloudWatch Agent service just created
        ApplicationSignalsIntegration.Builder.create(this, "ApplicationSignalsIntegration")
                .taskDefinition(sampleAppTaskDefinition)
                .instrumentation(InstrumentationProps.builder()
                        .sdkVersion(PythonInstrumentationVersion.V0_8_0)
                        .build())
                .serviceName("sample-app")
                .overrideEnvironments(List.of(EnvironmentExtension.builder()
                        .name(CommonExporting.OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT)
                        .value("http://cwagent-4316-http:4316/v1/metrics")
                        .build(), EnvironmentExtension.builder()
                        .name(TraceExporting.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT)
                        .value("http://cwagent-4316-http:4316/v1/traces")
                        .build(), EnvironmentExtension.builder()
                        .name(TraceExporting.OTEL_TRACES_SAMPLER_ARG)
                        .value("endpoint=http://cwagent-2000-http:2000")
                        .build()))
                .build();

        // Create ECS Service with service connect configuration
        // Create ECS Service with service connect configuration
        FargateService.Builder.create(this, "MySampleApp")
                .cluster(cluster)
                .taskDefinition(sampleAppTaskDefinition)
                .serviceConnectConfiguration(ServiceConnectProps.builder()
                        .namespace(dnsNamespace.getNamespaceArn())
                        .build())
                .desiredCount(1)
                .build();
    }
}
csharp
// Install: dotnet add package Amazon.CDK.AWS.ApplicationSignals.Alpha
using Constructs;
using Amazon.CDK.AWS.ApplicationSignals.Alpha;
using Amazon.CDK;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ServiceDiscovery;

class MyStack : Stack
{
    public MyStack(Construct? scope=null, string? id=null, StackProps props=new StackProps { }) : base(scope, id, props)
    {

        var vpc = new Vpc(this, "TestVpc", new VpcProps { });
        var cluster = new Cluster(this, "TestCluster", new ClusterProps { Vpc = vpc });
        var dnsNamespace = new PrivateDnsNamespace(this, "Namespace", new PrivateDnsNamespaceProps {
            Vpc = vpc,
            Name = "local"
        });
        var securityGroup = new SecurityGroup(this, "ECSSG", new SecurityGroupProps { Vpc = vpc });
        securityGroup.AddIngressRule(securityGroup, Port.TcpRange(0, 65535));

        // Define Task Definition for CloudWatch agent (Replica)
        var cwAgentTaskDefinition = new FargateTaskDefinition(this, "CloudWatchAgentTaskDefinition", new FargateTaskDefinitionProps { });

        new CloudWatchAgentIntegration(this, "CloudWatchAgentIntegration", new CloudWatchAgentIntegrationProps {
            TaskDefinition = cwAgentTaskDefinition,
            ContainerName = "ecs-cwagent",
            EnableLogging = false,
            Cpu = 128,
            MemoryLimitMiB = 64,
            PortMappings = new [] { new PortMapping {
                Name = "cwagent-4316",
                ContainerPort = 4316,
                HostPort = 4316
            }, new PortMapping {
                Name = "cwagent-2000",
                ContainerPort = 2000,
                HostPort = 2000
            } }
        });

        // Create the CloudWatch Agent replica service with service connect
        // Create the CloudWatch Agent replica service with service connect
        new FargateService(this, "CloudWatchAgentService", new FargateServiceProps {
            Cluster = cluster,
            TaskDefinition = cwAgentTaskDefinition,
            SecurityGroups = new [] { securityGroup },
            ServiceConnectConfiguration = new ServiceConnectProps {
                Namespace = dnsNamespace.NamespaceArn,
                Services = new [] { new ServiceConnectService {
                    PortMappingName = "cwagent-4316",
                    DnsName = "cwagent-4316-http",
                    Port = 4316
                }, new ServiceConnectService {
                    PortMappingName = "cwagent-2000",
                    DnsName = "cwagent-2000-http",
                    Port = 2000
                } }
            },
            DesiredCount = 1
        });

        // Define Task Definition for user application
        var sampleAppTaskDefinition = new FargateTaskDefinition(this, "SampleAppTaskDefinition", new FargateTaskDefinitionProps { });

        sampleAppTaskDefinition.AddContainer("app", new ContainerDefinitionOptions {
            Image = ContainerImage.FromRegistry("test/sample-app"),
            Cpu = 0,
            MemoryLimitMiB = 512
        });

        // Overwrite environment variables to connect to the CloudWatch Agent service just created
        // Overwrite environment variables to connect to the CloudWatch Agent service just created
        new ApplicationSignalsIntegration(this, "ApplicationSignalsIntegration", new ApplicationSignalsIntegrationProps {
            TaskDefinition = sampleAppTaskDefinition,
            Instrumentation = new InstrumentationProps {
                SdkVersion = PythonInstrumentationVersion.V0_8_0
            },
            ServiceName = "sample-app",
            OverrideEnvironments = new [] { new EnvironmentExtension {
                Name = CommonExporting.OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT,
                Value = "http://cwagent-4316-http:4316/v1/metrics"
            }, new EnvironmentExtension {
                Name = TraceExporting.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
                Value = "http://cwagent-4316-http:4316/v1/traces"
            }, new EnvironmentExtension {
                Name = TraceExporting.OTEL_TRACES_SAMPLER_ARG,
                Value = "endpoint=http://cwagent-2000-http:2000"
            } }
        });

        // Create ECS Service with service connect configuration
        // Create ECS Service with service connect configuration
        new FargateService(this, "MySampleApp", new FargateServiceProps {
            Cluster = cluster,
            TaskDefinition = sampleAppTaskDefinition,
            ServiceConnectConfiguration = new ServiceConnectProps {
                Namespace = dnsNamespace.NamespaceArn
            },
            DesiredCount = 1
        });
    }
}
go
// Install: go get github.com/aws/aws-cdk-go/awscdkapplicationsignalsalpha/v2
import "github.com/aws/constructs-go/constructs"
import "github.com/aws/aws-cdk-go/awscdkapplicationsignalsalpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

type myStack struct {
	Stack
}

func newMyStack(scope Construct, id *string, props StackProps) *myStack {
	if props == nil {
		props = &StackProps{
		}
	}
	this := &myStack{}
	cdk.NewStack_Override(this, scope, id, props)

	vpc := ec2.NewVpc(this, jsii.String("TestVpc"), &VpcProps{
	})
	cluster := ecs.NewCluster(this, jsii.String("TestCluster"), &ClusterProps{
		Vpc: Vpc,
	})
	dnsNamespace := awscdk.NewPrivateDnsNamespace(this, jsii.String("Namespace"), &PrivateDnsNamespaceProps{
		Vpc: Vpc,
		Name: jsii.String("local"),
	})
	securityGroup := ec2.NewSecurityGroup(this, jsii.String("ECSSG"), &SecurityGroupProps{
		Vpc: Vpc,
	})
	securityGroup.AddIngressRule(securityGroup, ec2.Port_TcpRange(jsii.Number(0), jsii.Number(65535)))

	// Define Task Definition for CloudWatch agent (Replica)
	cwAgentTaskDefinition := ecs.NewFargateTaskDefinition(this, jsii.String("CloudWatchAgentTaskDefinition"), &FargateTaskDefinitionProps{
	})

	appsignals.NewCloudWatchAgentIntegration(this, jsii.String("CloudWatchAgentIntegration"), &CloudWatchAgentIntegrationProps{
		TaskDefinition: cwAgentTaskDefinition,
		ContainerName: jsii.String("ecs-cwagent"),
		EnableLogging: jsii.Boolean(false),
		Cpu: jsii.Number(128),
		MemoryLimitMiB: jsii.Number(64),
		PortMappings: []PortMapping{
			&PortMapping{
				Name: jsii.String("cwagent-4316"),
				ContainerPort: jsii.Number(4316),
				HostPort: jsii.Number(4316),
			},
			&PortMapping{
				Name: jsii.String("cwagent-2000"),
				ContainerPort: jsii.Number(2000),
				HostPort: jsii.Number(2000),
			},
		},
	})

	// Create the CloudWatch Agent replica service with service connect
	// Create the CloudWatch Agent replica service with service connect
	ecs.NewFargateService(this, jsii.String("CloudWatchAgentService"), &FargateServiceProps{
		Cluster: cluster,
		TaskDefinition: cwAgentTaskDefinition,
		SecurityGroups: []ISecurityGroup{
			securityGroup,
		},
		ServiceConnectConfiguration: &ServiceConnectProps{
			Namespace: dnsNamespace.NamespaceArn,
			Services: []ServiceConnectService{
				&ServiceConnectService{
					PortMappingName: jsii.String("cwagent-4316"),
					DnsName: jsii.String("cwagent-4316-http"),
					Port: jsii.Number(4316),
				},
				&ServiceConnectService{
					PortMappingName: jsii.String("cwagent-2000"),
					DnsName: jsii.String("cwagent-2000-http"),
					Port: jsii.Number(2000),
				},
			},
		},
		DesiredCount: jsii.Number(1),
	})

	// Define Task Definition for user application
	sampleAppTaskDefinition := ecs.NewFargateTaskDefinition(this, jsii.String("SampleAppTaskDefinition"), &FargateTaskDefinitionProps{
	})

	sampleAppTaskDefinition.AddContainer(jsii.String("app"), &ContainerDefinitionOptions{
		Image: ecs.ContainerImage_FromRegistry(jsii.String("test/sample-app")),
		Cpu: jsii.Number(0),
		MemoryLimitMiB: jsii.Number(512),
	})

	// Overwrite environment variables to connect to the CloudWatch Agent service just created
	// Overwrite environment variables to connect to the CloudWatch Agent service just created
	appsignals.NewApplicationSignalsIntegration(this, jsii.String("ApplicationSignalsIntegration"), &ApplicationSignalsIntegrationProps{
		TaskDefinition: sampleAppTaskDefinition,
		Instrumentation: &InstrumentationProps{
			SdkVersion: appsignals.PythonInstrumentationVersion_V0_8_0(),
		},
		ServiceName: jsii.String("sample-app"),
		OverrideEnvironments: []EnvironmentExtension{
			&EnvironmentExtension{
				Name: appsignals.CommonExporting_OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT(),
				Value: jsii.String("http://cwagent-4316-http:4316/v1/metrics"),
			},
			&EnvironmentExtension{
				Name: appsignals.TraceExporting_OTEL_EXPORTER_OTLP_TRACES_ENDPOINT(),
				Value: jsii.String("http://cwagent-4316-http:4316/v1/traces"),
			},
			&EnvironmentExtension{
				Name: appsignals.TraceExporting_OTEL_TRACES_SAMPLER_ARG(),
				Value: jsii.String("endpoint=http://cwagent-2000-http:2000"),
			},
		},
	})

	// Create ECS Service with service connect configuration
	// Create ECS Service with service connect configuration
	ecs.NewFargateService(this, jsii.String("MySampleApp"), &FargateServiceProps{
		Cluster: cluster,
		TaskDefinition: sampleAppTaskDefinition,
		ServiceConnectConfiguration: &ServiceConnectProps{
			Namespace: dnsNamespace.*NamespaceArn,
		},
		DesiredCount: jsii.Number(1),
	})
	return this
}

Initializer ​

ts
new TraceExporting()
python
TraceExporting()
java
new TraceExporting()
csharp
new TraceExporting()
go
NewTraceExporting()

Properties ​

OTEL_EXPORTER_OTLP_TRACES_ENDPOINTstringotel_exporter_otlp_traces_endpointstrOTEL_EXPORTER_OTLP_TRACES_ENDPOINTStringOTEL_EXPORTER_OTLP_TRACES_ENDPOINTstringOTEL_EXPORTER_OTLP_TRACES_ENDPOINT*stringrequiredstatic#
Endpoint configuration for OTLP traces.
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_LOCAL_CWAstringotel_exporter_otlp_traces_endpoint_local_cwastrOTEL_EXPORTER_OTLP_TRACES_ENDPOINT_LOCAL_CWAStringOTEL_EXPORTER_OTLP_TRACES_ENDPOINT_LOCAL_CWAstringOTEL_EXPORTER_OTLP_TRACES_ENDPOINT_LOCAL_CWA*stringrequiredstatic#
Local CloudWatch Agent endpoint for traces.
OTEL_PROPAGATORSstringotel_propagatorsstrOTEL_PROPAGATORSStringOTEL_PROPAGATORSstringOTEL_PROPAGATORS*stringrequiredstatic#
Configuration for trace context propagation.
OTEL_PROPAGATORS_APPLICATION_SIGNALSstringotel_propagators_application_signalsstrOTEL_PROPAGATORS_APPLICATION_SIGNALSStringOTEL_PROPAGATORS_APPLICATION_SIGNALSstringOTEL_PROPAGATORS_APPLICATION_SIGNALS*stringrequiredstatic#
Supported propagation formats for Application Signals.
OTEL_TRACES_SAMPLERstringotel_traces_samplerstrOTEL_TRACES_SAMPLERStringOTEL_TRACES_SAMPLERstringOTEL_TRACES_SAMPLER*stringrequiredstatic#
Sampling configuration for traces.
OTEL_TRACES_SAMPLER_ALWAYS_OFFstringotel_traces_sampler_always_offstrOTEL_TRACES_SAMPLER_ALWAYS_OFFStringOTEL_TRACES_SAMPLER_ALWAYS_OFFstringOTEL_TRACES_SAMPLER_ALWAYS_OFF*stringrequiredstatic#
Sample no traces.
OTEL_TRACES_SAMPLER_ALWAYS_ONstringotel_traces_sampler_always_onstrOTEL_TRACES_SAMPLER_ALWAYS_ONStringOTEL_TRACES_SAMPLER_ALWAYS_ONstringOTEL_TRACES_SAMPLER_ALWAYS_ON*stringrequiredstatic#
Sample all traces.
OTEL_TRACES_SAMPLER_ARGstringotel_traces_sampler_argstrOTEL_TRACES_SAMPLER_ARGStringOTEL_TRACES_SAMPLER_ARGstringOTEL_TRACES_SAMPLER_ARG*stringrequiredstatic#
Arguments for trace sampler configuration.
OTEL_TRACES_SAMPLER_ARG_LOCAL_CWAstringotel_traces_sampler_arg_local_cwastrOTEL_TRACES_SAMPLER_ARG_LOCAL_CWAStringOTEL_TRACES_SAMPLER_ARG_LOCAL_CWAstringOTEL_TRACES_SAMPLER_ARG_LOCAL_CWA*stringrequiredstatic#
Local CloudWatch Agent endpoint for sampler.
OTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_OFFstringotel_traces_sampler_parent_based_always_offstrOTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_OFFStringOTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_OFFstringOTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_OFF*stringrequiredstatic#
Parent-based always off sampling.
OTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_ONstringotel_traces_sampler_parent_based_always_onstrOTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_ONStringOTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_ONstringOTEL_TRACES_SAMPLER_PARENT_BASED_ALWAYS_ON*stringrequiredstatic#
Parent-based always on sampling.
OTEL_TRACES_SAMPLER_PARENT_BASED_TRACEID_RATIOstringotel_traces_sampler_parent_based_traceid_ratiostrOTEL_TRACES_SAMPLER_PARENT_BASED_TRACEID_RATIOStringOTEL_TRACES_SAMPLER_PARENT_BASED_TRACEID_RATIOstringOTEL_TRACES_SAMPLER_PARENT_BASED_TRACEID_RATIO*stringrequiredstatic#
Parent-based trace ID ratio sampling.
OTEL_TRACES_SAMPLER_TRACEID_RATIOstringotel_traces_sampler_traceid_ratiostrOTEL_TRACES_SAMPLER_TRACEID_RATIOStringOTEL_TRACES_SAMPLER_TRACEID_RATIOstringOTEL_TRACES_SAMPLER_TRACEID_RATIO*stringrequiredstatic#
Trace ID ratio based sampling.
OTEL_TRACES_SAMPLER_XRAYstringotel_traces_sampler_xraystrOTEL_TRACES_SAMPLER_XRAYStringOTEL_TRACES_SAMPLER_XRAYstringOTEL_TRACES_SAMPLER_XRAY*stringrequiredstatic#
X-Ray sampling strategy.