# Regular open telemetry usage from here, see https://github.com/open-telemetry/opentelemetry-python
# for details
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
# azure monitor trace exporter to send telemetry to appinsights
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# Simple console exporter
exporter = ConsoleSpanExporter()
span_processor = SimpleSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# Example with Servicebus SDKs
from azure.servicebus import ServiceBusClient, ServiceBusMessage
connstr = os.environ['SERVICE_BUS_CONN_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']
with tracer.start_as_current_span(name="MyApplication2"):
with ServiceBusClient.from_connection_string(connstr) as client:
with client.get_queue_sender("new_queue") as sender:
#Sending a single message
single_message = ServiceBusMessage("Single message")
sender.send_messages(single_message)
# continually receives new messages until it doesn't receive any new messages for 5 (max_wait_time) seconds.
import os
import time
from opentelemetry import trace
from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
from opentelemetry.instrumentation.psycopg2 import Psycopg2Instrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import (BatchSpanProcessor,
ConsoleSpanExporter,
SimpleSpanProcessor)
# Set up OpenTelemetry tracing
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(ConsoleSpanExporter()))
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(CloudTraceSpanExporter(), schedule_delay_millis=5000))
# Trace postgres queries as well
Psycopg2Instrumentor().instrument()
import psycopg2
from google.cloud.sqlcommenter.psycopg2.extension import CommenterCursorFactory
tracer = trace.get_tracer(__name__)
def main():
cursor_factory = CommenterCursorFactory(
with_db_driver=True,
with_dbapi_level=True,
"payment",
"service.instance.id":
str(id(app)),
"telemetry.sdk.name":
"opentelemetry",
"telemetry.sdk.language":
"python",
"telemetry.sdk.version":
pkg_resources.get_distribution("opentelemetry-sdk").version,
"host.hostname":
socket.gethostname(),
})))
tracerProvider = trace.get_tracer_provider()
tracer = tracerProvider.get_tracer(__name__)
tracerProvider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
otlp_exporter = OTLPSpanExporter(endpoint="{}:55680".format(OTLP),
insecure=True)
tracerProvider.add_span_processor(SimpleSpanProcessor(otlp_exporter))
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument(tracer_provider=tracerProvider)
retry_strategy = Retry(total=2,
status_forcelist=[401, 401.1, 429, 503],
method_whitelist=[
"HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS",
"TRACE"
])
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from opentelemetry import trace
from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
trace.set_tracer_provider(TracerProvider())
cloud_trace_exporter = CloudTraceSpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(cloud_trace_exporter))
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("foo"):
print("Hello world!")
from opentelemetry.sdk.trace import TracerProvider, sampling
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
TEST_DURATION_SECONDS = 15
SPANS_PER_SECOND = 10_000
class MockTraceServiceStub(object):
def __init__(self, channel):
self.Export = lambda *args, **kwargs: None
old_stub = OTLPSpanExporter._stub
OTLPSpanExporter._stub = MockTraceServiceStub
simple_span_processor = SimpleSpanProcessor(OTLPSpanExporter())
tracer = TracerProvider(
active_span_processor=simple_span_processor,
sampler=sampling.DEFAULT_ON,
).get_tracer("resource_usage_tracer")
starttime = time.time()
for _ in range(TEST_DURATION_SECONDS):
for _ in range(SPANS_PER_SECOND):
span = tracer.start_span("benchmarkedSpan")
span.end()
time_to_finish_spans = time.time() - starttime
time.sleep(1.0 - time_to_finish_spans if time_to_finish_spans < 1.0 else 0)
OTLPSpanExporter._stub = old_stub
{
"service.name": "inventory",
"service.instance.id": str(id(app)),
"telemetry.sdk.name": "opentelemetry",
"telemetry.sdk.language": "python",
"telemetry.sdk.version": pkg_resources.get_distribution("opentelemetry-sdk").version,
"host.hostname": socket.gethostname(),
}
)
)
)
tracerProvider = trace.get_tracer_provider()
tracer = tracerProvider.get_tracer(__name__)
tracerProvider.add_span_processor(
SimpleSpanProcessor(ConsoleSpanExporter())
)
otlp_exporter = OTLPSpanExporter(endpoint="{}:55680".format(OTLP), insecure=True)
tracerProvider.add_span_processor(
SimpleSpanProcessor(otlp_exporter)
)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument(tracer_provider=tracerProvider)
@app.errorhandler(Error)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
status=health_pb2.HealthCheckResponse.UNIMPLEMENTED)
if __name__ == "__main__":
logger.info("initializing recommendationservice")
# OpenTelemetry Tracing
# TracerProvider provides global state and access to tracers.
trace.set_tracer_provider(TracerProvider())
# Export traces to Google Cloud Trace
# When running on GCP, the exporter handles authentication
# using automatically default application credentials.
# When running locally, credentials may need to be set explicitly.
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(CloudTraceSpanExporter())
)
propagate.set_global_textmap(CloudTraceFormatPropagator())
port = os.environ.get('PORT', "8080")
catalog_addr = os.environ.get('PRODUCT_CATALOG_SERVICE_ADDR', '')
if catalog_addr == "":
raise Exception(
'PRODUCT_CATALOG_SERVICE_ADDR environment variable not set')
logger.info("product catalog address: " + catalog_addr)
# Create the gRPC client channel to ProductCatalog (server).
channel = grpc.insecure_channel(catalog_addr)
# OpenTelemetry client interceptor passes trace contexts to the server.
channel = intercept_channel(
assert sql1SpanAsObject['attributes'][
'db.statement'] == "INSERT INTO hypertrace_data (col1, col2) VALUES (123, 'abcdefghijklmnopqrstuvwxyz')"
memoryExporter.clear()
return response
except:
logger.error(
'An error occurred validating span data: exception=%s, stacktrace=%s',
sys.exc_info()[0], traceback.format_exc())
raise sys.exc_info()[0]
agent = None
if ENABLE_INSTRUMENTATION == True:
#
# Code snippet here represents the current initialization logic
#
logger.info('Initializing agent.')
agent = Agent()
agent.instrument(server)
#
# End initialization logic for Python Agent
#
# Setup In-Memory Span Exporter
logger.info('Agent initialized.')
logger.info('Adding in-memory span exporter.')
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
agent.register_processor(simpleExportSpanProcessor)
logger.info('Added in-memoy span exporter')
def setUp(self):
tracer_provider = TracerProvider()
self.exporter = OTLPSpanExporter(insecure=True)
tracer_provider.add_span_processor(SimpleSpanProcessor(self.exporter))
self.tracer = tracer_provider.get_tracer(__name__)
self.server = server(ThreadPoolExecutor(max_workers=10))
self.server.add_insecure_port("[::]:4317")
self.server.start()
event_mock = Mock(
**{
"timestamp": 1591240820506462784,
"attributes": BoundedAttributes(
attributes={"a": 1, "b": False}
),
}
)
type(event_mock).name = PropertyMock(return_value="a")
self.span = _Span(
"a",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 1), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
attributes=BoundedAttributes(attributes={"a": 1, "b": True}),
events=[event_mock],
links=[
Mock(
**{
"context.trace_id": 1,
"context.span_id": 2,
"attributes": BoundedAttributes(
attributes={"a": 1, "b": False}
),
"kind": OTLPSpan.SpanKind.SPAN_KIND_INTERNAL, # pylint: disable=no-member
}
)
],
instrumentation_info=InstrumentationInfo(
name="name", version="version"
),
)
self.span2 = _Span(
"b",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 2), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
instrumentation_info=InstrumentationInfo(
name="name", version="version"
),
)
self.span3 = _Span(
"c",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 1), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
instrumentation_info=InstrumentationInfo(
name="name2", version="version2"
),
)
self.span.start()
self.span.end()
self.span2.start()
self.span2.end()
self.span3.start()
self.span3.end()
from opentelemetry.exporter.jaeger import JaegerSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.shim import opentracing_shim
# Configure the tracer using the default implementation
trace.set_tracer_provider(TracerProvider())
tracer_provider = trace.get_tracer_provider()
# Configure the tracer to export traces to Jaeger
jaeger_exporter = JaegerSpanExporter(
service_name="OpenTracing Shim Example",
agent_host_name="localhost",
agent_port=6831,
)
span_processor = SimpleSpanProcessor(jaeger_exporter)
tracer_provider.add_span_processor(span_processor)
# Create an OpenTracing shim. This implements the OpenTracing tracer API, but
# forwards calls to the underlying OpenTelemetry tracer.
opentracing_tracer = opentracing_shim.create_tracer(tracer_provider)
# Our example caching library expects an OpenTracing-compliant tracer.
redis_cache = RedisCache(opentracing_tracer)
# Appication code uses an OpenTelemetry Tracer as usual.
tracer = trace.get_tracer(__name__)
@redis_cache
def fib(number):
from opentelemetry.sdk.resources import Resource
class MockLambdaContext:
pass
lambdaContext = MockLambdaContext()
lambdaContext.invoked_function_arn = "arn://mock-lambda-function-arn"
lambdaContext.aws_request_id = "mock_aws_request_id"
# TODO: does not work, need upstream fix
resource = Resource.create().merge(AwsLambdaResourceDetector().detect())
trace.set_tracer_provider(TracerProvider(resource=resource, ))
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(ConsoleSpanExporter()), )
in_memory_exporter = InMemorySpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(in_memory_exporter))
def test_lambda_instrument():
in_memory_exporter.clear()
lambda_handler("mock", lambdaContext)
spans = in_memory_exporter.get_finished_spans()
assert len(spans) == 1
span = spans[0]
assert span.name == "mock_lambda.handler"
# instrumentation_key="uuid of the instrumentation key (see your Azure Monitor account)"
# )
# Regular open telemetry usage from here, see https://github.com/open-telemetry/opentelemetry-python
# for details
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# Simple console exporter
exporter = ConsoleSpanExporter()
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(exporter))
from azure.eventhub import EventHubProducerClient, EventData
import os
FULLY_QUALIFIED_NAMESPACE = os.environ['EVENT_HUB_HOSTNAME']
EVENTHUB_NAME = os.environ['EVENT_HUB_NAME']
credential = os.environ['EVENTHUB_CONN_STR']
def on_event(context, event):
print(context.partition_id, ":", event)
with tracer.start_as_current_span(name="MyApplication"):
def __setup_for_test(self):
"""Set up Open Telemetry processors and exporters for usage in tests.
"""
self.__provider.add_span_processor(SimpleSpanProcessor(MemorySpanExporter.get_instance()))
trace.set_tracer_provider(self.__provider)
def configure_exporter(exporter):
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(exporter))
propagate.set_global_textmap(CloudTraceFormatPropagator())
# )
# Regular open telemetry usage from here, see https://github.com/open-telemetry/opentelemetry-python
# for details
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# Simple console exporter
exporter = ConsoleSpanExporter()
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(exporter)
)
# Example with Eventgrid SDKs
import os
from azure.eventgrid import EventGridPublisherClient, CloudEvent
from azure.core.credentials import AzureKeyCredential
hostname = os.environ['CLOUD_TOPIC_HOSTNAME']
key = AzureKeyCredential(os.environ['CLOUD_ACCESS_KEY'])
cloud_event = CloudEvent(
source = 'demo',
type = 'sdk.demo',
data = {'test': 'hello'},
extensions = {'test': 'maybe'}
)