def setup_tracing() -> None:
# Sets the tracer_provider. This is only allowed once per execution
# context and will log a warning if attempted multiple times.
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(
OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)))
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(ConsoleSpanExporter()))
def configure_inmemory_span_exporter(agent):
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
agent.register_processor(simpleExportSpanProcessor)
return memoryExporter
def __init__(self):
tracer_provider = trace.TracerProvider()
oteltracer = tracer_provider.get_tracer(__name__)
super().__init__(oteltracer)
exporter = InMemorySpanExporter()
span_processor = SimpleSpanProcessor(exporter)
tracer_provider.add_span_processor(span_processor)
self.exporter = exporter
def set_console_span_processor(self) -> None:
'''Register the console span processor for debugging purposes.'''
logger.debug('Entering AgentInit.setConsoleSpanProcessor().')
console_span_exporter = ConsoleSpanExporter(
service_name=self._config.agent_config.service_name)
simple_export_span_processor = SimpleSpanProcessor(
console_span_exporter)
trace.get_tracer_provider().add_span_processor(
simple_export_span_processor)
def initialize_tracer(project_id):
trace.set_tracer_provider(TracerProvider())
cloud_trace_exporter = CloudTraceSpanExporter(project_id)
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(cloud_trace_exporter))
propagate.set_global_textmap(CloudTraceFormatPropagator())
opentelemetry_tracer = trace.get_tracer(__name__)
return opentelemetry_tracer
def use_test_ot_exporter():
global _TEST_OT_PROVIDER_INITIALIZED
if _TEST_OT_PROVIDER_INITIALIZED:
return
provider = trace.get_tracer_provider()
if not hasattr(provider, "add_span_processor"):
return
provider.add_span_processor(SimpleSpanProcessor(get_test_ot_exporter()))
_TEST_OT_PROVIDER_INITIALIZED = True
def setup_tracing() -> None:
"""Stand-in for a user-provided `setup_tracing` hook."""
os.makedirs("/tmp/spans", exist_ok=True)
# Sets the tracer_provider. This is only allowed once per execution
# context and will log a warning if attempted multiple times.
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(
ConsoleSpanExporter(
out=open(f"{spans_dir}{os.getpid()}.txt", "w"),
formatter=lambda span: span.to_json(indent=None) + os.linesep,
)))
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": OrderedDict([("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=OrderedDict([("a", 1), ("b", True)]),
events=[event_mock],
links=[
Mock(
**{
"context.trace_id": 1,
"context.span_id": 2,
"attributes": OrderedDict([("a", 1), ("b", False)]),
"kind": OTLPSpan.SpanKind.SPAN_KIND_INTERNAL, # pylint: disable=no-member
})
],
instrumentation_info=InstrumentationInfo(name="name",
version="version"),
)
self.span.start()
self.span.end()
def setup_jaeger_tracer(env, service, host, port, additional={}):
resource = Resource(attributes={
'service.name': service,
'env': env,
'dd.service': service,
**additional
})
trace.set_tracer_provider(TracerProvider(resource=resource))
trace.get_tracer_provider().get_tracer(__name__)
jaeger_exporter = JaegerExporter(
agent_host_name=host,
agent_port=port,
)
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(jaeger_exporter))
def test_run():
logger = setup_custom_logger(__name__)
agent = Agent()
agent.instrument(None)
# 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-memory span exporter')
logger.info('Running test calls.')
try:
session = botocore.session.get_session()
session.set_credentials(access_key="access-key",
secret_key="secret-key")
region = "us-west-2"
client = session.create_client("lambda", region_name=region)
iam_client = session.create_client("iam", region_name=region)
arn = _create_role_and_get_arn(iam_client)
result = _create_lambda_function('some_function',
return_headers_lambda_str(), client,
arn)
memoryExporter.clear()
response = client.invoke(
Payload=json.dumps({}),
FunctionName=result['FunctionArn'],
InvocationType="RequestResponse",
)
spans = memoryExporter.get_finished_spans()
invoke_span = spans[-1]
assert invoke_span.attributes['faas.invoked_name'] == 'some_function'
assert invoke_span.attributes['http.status_code'] == 200
assert invoke_span.attributes['rpc.service'] == 'Lambda'
memoryExporter.clear()
return 0
except:
logger.error(
'Failed to test boto instrumentation wrapper: exception=%s, stacktrace=%s',
sys.exc_info()[0], traceback.format_exc())
raise sys.exc_info()[0]
def init_otel():
"""Init the OpenTelemetry settings"""
global tracer, session_name, service_name, insecure, otel_exporter
LOGGER.debug("Init Otel : {}".format(service_name))
trace.set_tracer_provider(
TracerProvider(resource=Resource.create({SERVICE_NAME:
service_name}), ))
if in_memory_span_exporter:
otel_exporter = InMemorySpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(otel_exporter))
otel_exporter.clear()
else:
otel_exporter = OTLPSpanExporter()
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(otel_exporter))
tracer = trace.get_tracer(session_name)
def init_otel():
"""Init the OpenTelemetry settings"""
global tracer, session_name, service_name, insecure, otel_exporter, errors_counter, failed_counter, skipped_counter, total_counter, controller # noqa: E501
LOGGER.debug("Init Otel : {}".format(service_name))
trace.set_tracer_provider(
TracerProvider(resource=Resource.create({SERVICE_NAME:
service_name}), ))
if in_memory_span_exporter:
otel_exporter = InMemorySpanExporter()
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(otel_exporter))
# metrics_exporter = ConsoleMetricsExporter()
else:
otel_exporter = OTLPSpanExporter()
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(otel_exporter))
# metrics_exporter = CollectorMetricsExporter()
tracer = trace.get_tracer(session_name)
# 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.
def configure_exporter(exporter):
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(exporter))
propagate.set_global_textmap(CloudTraceFormatPropagator())
# 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!")
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)
"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"
])
import mysql.connector
from flask import Flask
import requests
from opentelemetry import trace
from opentelemetry.instrumentation.flask import FlaskInstrumentor, get_default_span_name
from opentelemetry.sdk.trace import TracerProvider, export
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor, ConsoleSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.instrumentation.requests import RequestsInstrumentor
server = Flask(__name__)
FlaskInstrumentor().instrument_app(server)
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
tracerProvider = TracerProvider(
resource=Resource.create({
'service.name': 'otel-python-agent',
'service.instance.id': os.getpid(),
}))
#consoleExporter = ConsoleSpanExporter()
#simpleExportSpanProcessor2 = SimpleSpanProcessor(consoleExporter)
trace.set_tracer_provider(tracerProvider)
trace.get_tracer_provider().add_span_processor(simpleExportSpanProcessor)
#trace.get_tracer_provider().add_span_processor(simpleExportSpanProcessor2)
requestsInstrumentor = RequestsInstrumentor()
requestsInstrumentor.instrument()
from opentelemetry.sdk.trace.export import (
ConsoleSpanExporter,
SimpleSpanProcessor,
)
# FIXME This could likely be avoided by integrating this script into the
# standard test running mechanisms.
# Integrations are the glue that binds the OpenTelemetry API and the
# frameworks and libraries that are used together, automatically creating
# Spans and propagating context as appropriate.
trace.set_tracer_provider(TracerProvider())
RequestsInstrumentor().instrument()
# SpanExporter receives the spans and send them to the target location.
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)
app = flask.Flask(__name__)
app.wsgi_app = OpenTelemetryMiddleware(app.wsgi_app)
@app.route("/verify-tracecontext", methods=["POST"])
def verify_tracecontext():
"""Upon reception of some payload, sends a request back to the designated
url.
This route is designed to be testable with the w3c tracecontext server /
client test.
"""
for action in flask.request.json:
from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
from opentelemetry.instrumentation.grpc import client_interceptor
from opentelemetry.propagators.cloud_trace_propagator import CloudTraceFormatPropagator
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
import demo_pb2
import demo_pb2_grpc
from logger import get_json_logger
logger = get_json_logger("emailservice-client")
try:
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(CloudTraceSpanExporter()))
propagate.set_global_textmap(CloudTraceFormatPropagator())
tracer_interceptor = client_interceptor(trace.get_tracer_provider())
except Exception as e:
raise Exception("{}".format(e))
def send_confirmation_email(email, order):
channel = grpc.insecure_channel("0.0.0.0:8080")
channel = grpc.intercept_channel(channel, tracer_interceptor)
stub = demo_pb2_grpc.EmailServiceStub(channel)
try:
response = stub.SendOrderConfirmation(
demo_pb2.SendOrderConfirmationRequest(email=email, order=order))
logger.info("Request sent. response: {}".format(response))
except grpc.RpcError as err:
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"
{
"service.name": "database",
"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)
)
DB_NAME = 'APM'
HOST = os.getenv("MYSQL_HOST") if os.getenv("MYSQL_HOST") is not None else "localhost"
PORT = int(os.getenv("MYSQL_PORT")) if os.getenv("MYSQL_PORT") is not None else 3306
TABLES = {}
TABLES['Inventory_Items'] = (
"CREATE TABLE `Inventory_Items` ("
" `ItemId` varchar(16) NOT NULL,"
" `TotalQty` int(11) NOT NULL,"
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):
# 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, EventHubConsumerClient
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(partition_context, event):
# Put your code here.
# If the operation is i/o intensive, multi-thread will have better performance.
print("Received event from partition: {}.".format(
partition_context.partition_id))
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
# 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 flask import Flask, request
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import (
ConsoleSpanExporter,
SimpleSpanProcessor,
)
app = Flask(__name__)
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(ConsoleSpanExporter()))
@app.route("/server_request")
def server_request():
print(request.args.get("param"))
return "served"
if __name__ == "__main__":
app.run(port=8082)
# )
# 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'}
)