def tracer():
exporter = ConsoleSpanExporter()
span_processor = SimpleExportSpanProcessor(exporter)
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
span_processor = SimpleExportSpanProcessor(exporter)
trace.tracer_source().add_span_processor(span_processor)
return trace.get_tracer(__name__)
def _grpc():
"""Start discount gRPC server."""
logging.basicConfig(level=logging.INFO)
engine = create_engine(settings.DATABASE_URL)
Session = sessionmaker(bind=engine)
connection = engine.connect()
session = Session(bind=connection)
exporter = ConsoleSpanExporter()
if settings.TRACER_ENDPOINT_HOST and settings.TRACER_ENDPOINT_PORT:
exporter = JaegerSpanExporter(
service_name="promotion-grpc",
agent_host_name=settings.TRACER_ENDPOINT_HOST,
agent_port=settings.TRACER_ENDPOINT_PORT,
)
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
tracer = trace.get_tracer(__name__)
## span_processor = BatchExportSpanProcessor(exporter)
span_processor = SimpleExportSpanProcessor(exporter)
trace.tracer_source().add_span_processor(span_processor)
tracer = trace.get_tracer(__name__)
user_store = UserDataStore(session, tracer)
user_case = UserUseCase(user_store, tracer)
order_store = OrderDataStore(session, tracer)
order_case = OrderUseCase(order_store, tracer)
balance_client = BalanceClient(settings.BALANCE_TOKEN)
balance_case = BalanceUseCase(order_case, balance_client, tracer)
holiday_store = HolidayDataStore(settings.BLACK_FRIDAY_DATE, tracer)
holiday_case = HolidayUseCase(holiday_store, tracer)
authentication_case = AuthenticationUseCase(user_case, tracer)
case = PromotionUseCase(discounts=[holiday_case, user_case], tracer=tracer)
servicer = PromotionServicer(case, user_case, order_case, balance_case,
authentication_case, tracer)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
service.add_PromotionAPIServicer_to_server(servicer, server)
logger.info("Listenning on port 50051.")
server.add_insecure_port("[::]:50051")
server.start()
server.wait_for_termination()
def setup_tracer(service_name):
jaeger_exporter = jaeger.JaegerSpanExporter(
service_name=service_name,
# configure agent
agent_host_name='jaeger',
agent_port=6831,
)
span_processor = BatchExportSpanProcessor(jaeger_exporter)
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
trace.tracer_source().add_span_processor(span_processor)
postgres_tracer = trace.tracer_source().get_tracer('postgres')
trace_integration(postgres_tracer)
def test_try_set_again(self):
self.assertTrue(trace.tracer_source())
# Try setting after the tracer_source has already been created:
with self.assertRaises(RuntimeError) as einfo:
trace.set_preferred_tracer_source_implementation(
get_opentelemetry_implementation)
self.assertIn("already loaded", str(einfo.exception))
def configure_opentelemetry(flask_app: flask.Flask):
"""Configure a flask application to use OpenTelemetry.
This activates the specific components:
* sets tracer to the SDK's Tracer
* enables requests integration on the Tracer
* uses a WSGI middleware to enable configuration
TODO:
* processors?
* exporters?
"""
# Start by configuring all objects required to ensure
# a complete end to end workflow.
# The preferred implementation of these objects must be set,
# as the opentelemetry-api defines the interface with a no-op
# implementation.
trace.set_preferred_tracer_source_implementation(lambda _: TracerSource())
# Next, we need to configure how the values that are used by
# traces and metrics are propagated (such as what specific headers
# carry this value).
# 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.
opentelemetry.ext.http_requests.enable(trace.tracer_source())
instrument_app(flask_app)
def setUpClass(cls):
global _MEMORY_EXPORTER # pylint:disable=global-statement
trace_api.set_preferred_tracer_source_implementation(
lambda T: TracerSource())
tracer_source = trace_api.tracer_source()
_MEMORY_EXPORTER = InMemorySpanExporter()
span_processor = export.SimpleExportSpanProcessor(_MEMORY_EXPORTER)
tracer_source.add_span_processor(span_processor)
def hello():
# emit a trace that measures how long the
# sleep takes
version = pkg_resources.get_distribution(
"opentelemetry-example-app").version
tracer = trace.tracer_source().get_tracer(__name__, version)
with tracer.start_as_current_span("example-request"):
requests.get("http://www.example.com")
return "hello"
def do_test_get_envvar(self, envvar_suffix: str) -> None:
global DUMMY_TRACER_SOURCE # pylint:disable=global-statement
# Test is not runnable with this!
self.assertFalse(sys.flags.ignore_environment)
envname = "OPENTELEMETRY_PYTHON_IMPLEMENTATION_" + envvar_suffix
os.environ[envname] = __name__
try:
tracer_source = trace.tracer_source()
self.assertIs(tracer_source, DUMMY_TRACER_SOURCE)
finally:
DUMMY_TRACER_SOURCE = None
del os.environ[envname]
self.assertIs(type(tracer_source), DummyTracerSource)
def _before_flask_request():
environ = flask_request.environ
span_name = flask_request.endpoint or otel_wsgi.get_default_span_name(
environ)
parent_span = propagators.extract(otel_wsgi.get_header_from_environ,
environ)
tracer = trace.tracer_source().get_tracer(__name__, __version__)
attributes = otel_wsgi.collect_request_attributes(environ)
if flask_request.url_rule:
# For 404 that result from no route found, etc, we don't have a url_rule.
attributes["http.route"] = flask_request.url_rule.rule
span = tracer.start_span(
span_name,
parent_span,
kind=trace.SpanKind.SERVER,
attributes=attributes,
start_time=environ.get(_ENVIRON_STARTTIME_KEY),
)
activation = tracer.use_span(span, end_on_exit=True)
activation.__enter__()
environ[_ENVIRON_ACTIVATION_KEY] = activation
environ[_ENVIRON_SPAN_KEY] = span
from opentelemetry import trace
from opentelemetry.ext import jaeger
# from opentelemetry.context import Context
from opentelemetry.sdk.trace import TracerSource
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
trace.tracer_source().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter())
)
tracer = trace.tracer_source().get_tracer(__name__)
# create a JaegerSpanExporter
jaeger_exporter = jaeger.JaegerSpanExporter(
service_name='zoogle',
# configure agent
agent_host_name='jaeger',
agent_port=6831,
# optional: configure also collector
collector_host_name='jaeger',
collector_port=14268,
collector_endpoint='/api/traces?format=jaeger.thrift',
# username=xxxx, # optional
# password=xxxx, # optional
)
# Create a BatchExportSpanProcessor and add the exporter to it
span_processor = BatchExportSpanProcessor(jaeger_exporter)
def test_get_default(self):
tracer_source = trace.tracer_source()
self.assertIs(type(tracer_source), trace.TracerSource)
)
if os.getenv("EXPORTER") == "jaeger":
from opentelemetry.ext.jaeger import JaegerSpanExporter
exporter = JaegerSpanExporter(
service_name="basic-service",
agent_host_name="localhost",
agent_port=6831,
)
else:
exporter = ConsoleSpanExporter()
# The preferred tracer implementation must be set, as the opentelemetry-api
# defines the interface with a no-op implementation.
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
# We tell OpenTelemetry who it is that is creating spans. In this case, we have
# no real name (no setup.py), so we make one up. If we had a version, we would
# also specify it here.
tracer = trace.tracer_source().get_tracer(__name__)
# SpanExporter receives the spans and send them to the target location.
span_processor = BatchExportSpanProcessor(exporter)
trace.tracer_source().add_span_processor(span_processor)
with tracer.start_as_current_span("foo"):
with tracer.start_as_current_span("bar"):
with tracer.start_as_current_span("baz"):
print(Context)
from opentelemetry.ext import http_requests
from opentelemetry.ext.wsgi import OpenTelemetryMiddleware
from opentelemetry.sdk.trace import TracerSource
from opentelemetry.sdk.trace.export import (
ConsoleSpanExporter,
SimpleExportSpanProcessor,
)
# The preferred tracer implementation must be set, as the opentelemetry-api
# defines the interface with a no-op implementation.
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
# 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.
http_requests.enable(trace.tracer_source())
# SpanExporter receives the spans and send them to the target location.
span_processor = SimpleExportSpanProcessor(ConsoleSpanExporter())
trace.tracer_source().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 /
def __init__(self, wsgi):
self.wsgi = wsgi
self.tracer = trace.tracer_source().get_tracer(__name__, __version__)
from opentelemetry.sdk.trace.export import (
BatchExportSpanProcessor,
ConsoleSpanExporter,
)
if os.getenv("EXPORTER") == "jaeger":
from opentelemetry.ext.jaeger import JaegerSpanExporter
exporter = JaegerSpanExporter(
service_name="http-client",
agent_host_name="localhost",
agent_port=6831,
)
else:
exporter = ConsoleSpanExporter()
# The preferred tracer implementation must be set, as the opentelemetry-api
# defines the interface with a no-op implementation.
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
tracer_source = trace.tracer_source()
# SpanExporter receives the spans and send them to the target location.
span_processor = BatchExportSpanProcessor(exporter)
tracer_source.add_span_processor(span_processor)
# 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.
http_requests.enable(tracer_source)
response = requests.get(url="http://127.0.0.1:5000/")
def test_preferred_impl(self):
trace.set_preferred_tracer_source_implementation(
get_opentelemetry_implementation
)
tracer_source = trace.tracer_source()
self.assertIs(tracer_source, DUMMY_TRACER_SOURCE)
def do_test_preferred_impl(self, setter: Callable[[Any], Any]) -> None:
setter(get_opentelemetry_implementation)
tracer_source = trace.tracer_source()
self.assertIs(tracer_source, DUMMY_TRACER_SOURCE)
def setUp(self):
"""Create an OpenTelemetry tracer and a shim before every test case."""
self.shim = opentracingshim.create_tracer(trace.tracer_source())
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import requests
from azure_monitor import AzureMonitorSpanExporter
from opentelemetry import trace
from opentelemetry.ext import http_requests
from opentelemetry.sdk.trace import TracerSource
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
tracer = trace.tracer_source().get_tracer(__name__)
http_requests.enable(trace.tracer_source())
span_processor = BatchExportSpanProcessor(
AzureMonitorSpanExporter(instrumentation_key="<INSTRUMENTATION KEY HERE>"))
trace.tracer_source().add_span_processor(span_processor)
response = requests.get(url="http://127.0.0.1:8080/")
span_processor.shutdown()
#!/usr/bin/env python
from opentelemetry import trace
from opentelemetry.ext import opentracing_shim
from opentelemetry.ext.jaeger import JaegerSpanExporter
from opentelemetry.sdk.trace import TracerSource
from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor
from rediscache import RedisCache
# Configure the tracer using the default implementation
trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
tracer_source = trace.tracer_source()
# 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 = SimpleExportSpanProcessor(jaeger_exporter)
tracer_source.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_source)
# Our example caching library expects an OpenTracing-compliant tracer.
redis_cache = RedisCache(opentracing_tracer)
# Appication code uses an OpenTelemetry Tracer as usual.
tracer = trace.tracer_source().get_tracer(__name__)
