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())