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