def test_request_hook(self): request_hook_service_attribute_name = "request_hook.service_name" request_hook_operation_attribute_name = "request_hook.operation_name" request_hook_api_params_attribute_name = "request_hook.api_params" def request_hook(span, service_name, operation_name, api_params): hook_attributes = { request_hook_service_attribute_name: service_name, request_hook_operation_attribute_name: operation_name, request_hook_api_params_attribute_name: json.dumps(api_params), } span.set_attributes(hook_attributes) BotocoreInstrumentor().uninstrument() BotocoreInstrumentor().instrument(request_hook=request_hook) s3 = self._make_client("s3") params = { "Bucket": "mybucket", "CreateBucketConfiguration": {"LocationConstraint": "us-west-2"}, } s3.create_bucket(**params) self.assert_span( "S3", "CreateBucket", attributes={ request_hook_service_attribute_name: "s3", request_hook_operation_attribute_name: "CreateBucket", request_hook_api_params_attribute_name: json.dumps(params), }, )
def test_response_hook(self): response_hook_service_attribute_name = "request_hook.service_name" response_hook_operation_attribute_name = "response_hook.operation_name" response_hook_result_attribute_name = "response_hook.result" def response_hook(span, service_name, operation_name, result): hook_attributes = { response_hook_service_attribute_name: service_name, response_hook_operation_attribute_name: operation_name, response_hook_result_attribute_name: len(result["Buckets"]), } span.set_attributes(hook_attributes) BotocoreInstrumentor().uninstrument() BotocoreInstrumentor().instrument(response_hook=response_hook) s3 = self._make_client("s3") s3.list_buckets() self.assert_span( "S3", "ListBuckets", attributes={ response_hook_service_attribute_name: "s3", response_hook_operation_attribute_name: "ListBuckets", response_hook_result_attribute_name: 0, }, )
def test_double_patch(self): sqs = self._make_client("sqs") BotocoreInstrumentor().instrument() BotocoreInstrumentor().instrument() sqs.list_queues() self.assert_span( "SQS", "ListQueues", request_id=_REQUEST_ID_REGEX_MATCH )
def test_double_patch(self): sqs = self.session.create_client("sqs", region_name="us-east-1") BotocoreInstrumentor().instrument() BotocoreInstrumentor().instrument() sqs.list_queues() spans = self.memory_exporter.get_finished_spans() assert spans self.assertEqual(len(spans), 1)
def _enable_otel(self): from opentelemetry import trace from opentelemetry.propagate import set_global_textmap from opentelemetry.sdk.resources import Resource from opentelemetry.sdk.trace import TracerProvider from opentelemetry.exporter.datadog import DatadogSpanExporter, DatadogExportSpanProcessor from opentelemetry.exporter.datadog.propagator import DatadogFormat from opentelemetry.instrumentation.grpc import GrpcInstrumentorClient r = Resource({ 'app.version': __version__, 'app.framework': ':'.join((self._name, __version__)), 'net.hostname': socket.gethostname(), 'service.name': self._name, 'service.version': __version__, }) trace.set_tracer_provider(TracerProvider(resource = r)) self.tracer = trace.get_tracer_provider() self.exporter = DatadogSpanExporter( service = self._name, agent_url = 'http://localhost:8126', version = __version__, env = 'dev', ) self.tracer.add_span_processor(DatadogExportSpanProcessor(self.exporter)) set_global_textmap(DatadogFormat()) # setup client instrumentation GrpcInstrumentorClient().instrument(tracer = self.tracer) BotocoreInstrumentor().instrument(tracer_provider = self.tracer) BotoInstrumentor().instrument(tracer_provider = self.tracer)
def setUp(self): super().setUp() BotocoreInstrumentor().instrument() self.session = botocore.session.get_session() self.session.set_credentials(access_key="access-key", secret_key="secret-key")
def test_unpatch(self): kinesis = self._make_client("kinesis") BotocoreInstrumentor().uninstrument() kinesis.list_streams() self.assertEqual(0, len(self.memory_exporter.get_finished_spans()))
def test_unpatch(self): kinesis = self.session.create_client("kinesis", region_name="us-east-1") BotocoreInstrumentor().uninstrument() kinesis.list_streams() spans = self.memory_exporter.get_finished_spans() assert not spans, spans
def setUp(self): super().setUp() BotocoreInstrumentor().instrument() session = botocore.session.get_session() session.set_credentials(access_key="access-key", secret_key="secret-key") self.client = session.create_client("dynamodb", region_name="us-west-2") self.default_table_name = "test_table"
def setUp(self): super().setUp() BotocoreInstrumentor().instrument() session = botocore.session.get_session() session.set_credentials( access_key="access-key", secret_key="secret-key" ) self.region = "us-west-2" self.client = session.create_client("lambda", region_name=self.region) self.iam_client = session.create_client("iam", region_name=self.region)
def test_uninstrument_does_not_inject_headers(self): headers = {} previous_propagator = get_global_textmap() try: set_global_textmap(MockTextMapPropagator()) def intercept_headers(**kwargs): headers.update(kwargs["request"].headers) ec2 = self._make_client("ec2") BotocoreInstrumentor().uninstrument() ec2.meta.events.register_first("before-send.ec2.DescribeInstances", intercept_headers) with self.tracer_provider.get_tracer("test").start_span("parent"): ec2.describe_instances() self.assertNotIn(MockTextMapPropagator.TRACE_ID_KEY, headers) self.assertNotIn(MockTextMapPropagator.SPAN_ID_KEY, headers) finally: set_global_textmap(previous_propagator)
def __init__(self, app, service='atlas-api', sqlalchemy_engine=None, datadog_agent=None, span_callback=None, ignored_paths: List[str] = None, sql_service=None): self.app = app trace.set_tracer_provider(TracerProvider()) self.tracer = trace.get_tracer(__name__) if datadog_agent: from ddtrace.internal.writer import AgentWriter from opentelemetry.exporter.datadog import DatadogExportSpanProcessor, \ DatadogSpanExporter exporter = DatadogSpanExporter(agent_url=datadog_agent, service=service) exporter._agent_writer = AgentWriter(datadog_agent) span_processor = DatadogExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) AtlasFastAPIInstrumentor.instrument_app(app, span_callback=span_callback, ignored_paths=ignored_paths) RequestsInstrumentor().instrument() BotocoreInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) BotoInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) RedisInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) if sqlalchemy_engine: sqlalch_service_name = service if not sql_service else sql_service SQLAlchemyInstrumentor().instrument(engine=sqlalchemy_engine, service=sqlalch_service_name)
def tearDown(self): super().tearDown() BotocoreInstrumentor().uninstrument()
) # === otlp exporter, collector from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter otlp_exporter = OTLPSpanExporter(endpoint="localhost:55680") span_processor = SimpleExportSpanProcessor(otlp_exporter) trace.get_tracer_provider().add_span_processor(span_processor) # === xray daemon exporter, xray daemon # from opentelemetry.exporter.xraydaemon import XrayDaemonSpanExporter # xrayDaemonSpanExporter = XrayDaemonSpanExporter() # trace.get_tracer_provider().add_span_processor( # SimpleExportSpanProcessor(xrayDaemonSpanExporter) # ) tracer = trace.get_tracer(__name__) # Customer's lambda function def main(): s3 = boto3.resource('s3') for bucket in s3.buckets.all(): print(bucket.name) return "200 OK" # Manual enable otel instrumentation BotocoreInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) main()
# Propagators can be set using environment variable: OTEL_PROPAGATORS = xray propagate.set_global_textmap(AwsXRayPropagator()) # Setup Tracer # OTLP Exporter is configured through environment variables: # - OTEL_EXPORTER_OTLP_ENDPOINT # - OTEL_EXPORTER_OTLP_CERTIFICATE otlp_exporter = OTLPSpanExporter() span_processor = BatchSpanProcessor(otlp_exporter) trace.set_tracer_provider( TracerProvider( active_span_processor=span_processor, id_generator=AwsXRayIdGenerator(), # resource=get_aggregated_resources( # [ # AwsEc2ResourceDetector(), # ] # ), )) # Instrument Packages BotocoreInstrumentor().instrument() FlaskInstrumentor().instrument_app(app) RequestsInstrumentor().instrument() if __name__ == "__main__": app.run(**get_flask_app_run_args())