def test_custom_tracer_provider(self): provider = TracerProvider( resource=Resource.create( { "service.name": "test", "deployment.environment": "env", "service.version": "1234", }, ), ) provider.add_span_processor( export.SimpleSpanProcessor(self.memory_exporter) ) SQLAlchemyInstrumentor().instrument(tracer_provider=provider) from sqlalchemy import create_engine # pylint: disable-all engine = create_engine("sqlite:///:memory:") cnx = engine.connect() cnx.execute("SELECT 1 + 1;").fetchall() spans = self.memory_exporter.get_finished_spans() self.assertEqual(len(spans), 2) self.assertEqual(spans[0].resource.attributes["service.name"], "test") self.assertEqual( spans[0].resource.attributes["deployment.environment"], "env" ) self.assertEqual( spans[0].resource.attributes["service.version"], "1234" )
def setup_instrumentation(app): settings: TracingSettings = _get_settings() _TRACE_PROVIDER = TracerProvider( resource=Resource.create({"service.name": settings.jaeger_service}) ) trace.set_tracer_provider(_TRACE_PROVIDER) if settings.jaeger_hostname: # pragma: no cover _JAEGER_EXPORTER = JaegerExporter( agent_host_name=settings.jaeger_hostname, agent_port=settings.jaeger_port, ) _TRACE_PROVIDER.add_span_processor(BatchSpanProcessor(_JAEGER_EXPORTER)) AioHttpClientInstrumentor().instrument() RequestsInstrumentor().instrument() # Register logging middleware app.middleware("http")(_log_requests_middleware) app.middleware("http")(_bind_logger_tracecontext_middleware) FastAPIInstrumentor.instrument_app(app) return app
def __init__(self, test_mode: bool): if SodaTelemetry.__instance is not None: raise Exception("This class is a singleton!") else: SodaTelemetry.__instance = self self.__send = self.soda_config.send_anonymous_usage_stats or test_mode if self.__send: logger.info("Setting up usage telemetry.") self.__provider = TracerProvider( resource=Resource.create( { 'os.architecture': platform.architecture(), 'python.version': platform.python_version(), 'python.implementation': platform.python_implementation(), ResourceAttributes.OS_TYPE: platform.system(), ResourceAttributes.OS_VERSION: platform.version(), 'platform': platform.platform(), ResourceAttributes.SERVICE_VERSION: SODA_SQL_VERSION, ResourceAttributes.SERVICE_NAME: 'soda', ResourceAttributes.SERVICE_NAMESPACE: 'soda-sql', } ) ) if test_mode: self.__setup_for_test() else: self.__setup() else: logger.info("Skipping usage telemetry setup.")
def test_mixed_mode(self): """Test that span parent-child relationship is kept between OpenTelemetry and the OpenTracing shim""" span_shim = self.shim.start_span("TestSpan16") with self.shim.scope_manager.activate(span_shim, finish_on_close=True): with (TracerProvider().get_tracer(__name__).start_as_current_span( "abc")) as opentelemetry_span: self.assertIs( span_shim.unwrap().context, opentelemetry_span.parent, ) with (TracerProvider().get_tracer(__name__).start_as_current_span( "abc")) as opentelemetry_span: with self.shim.start_active_span("TestSpan17") as scope: self.assertIs( scope.span.unwrap().parent, opentelemetry_span.context, )
def _configure_tracing(options: _Options) -> TracerProvider: provider = TracerProvider(resource=options.resource) set_global_response_propagator(options.response_propagator) # type: ignore trace.set_tracer_provider(provider) for factory in options.span_exporter_factories: provider.add_span_processor(BatchSpanProcessor(factory(options))) return provider
class OpenTelemetryBase(unittest.TestCase): def setUp(self): if HAS_OPENTELEMETRY_INSTALLED: self.original_tracer_provider = trace_api.get_tracer_provider() self.tracer_provider = TracerProvider() self.memory_exporter = InMemorySpanExporter() span_processor = export.SimpleExportSpanProcessor( self.memory_exporter) self.tracer_provider.add_span_processor(span_processor) trace_api.set_tracer_provider(self.tracer_provider) def tearDown(self): if HAS_OPENTELEMETRY_INSTALLED: trace_api.set_tracer_provider(self.original_tracer_provider) def assertNoSpans(self): if HAS_OPENTELEMETRY_INSTALLED: span_list = self.memory_exporter.get_finished_spans() self.assertEqual(len(span_list), 0) def assertSpanAttributes(self, name, status=StatusCanonicalCode.OK, attributes=None, span=None): if HAS_OPENTELEMETRY_INSTALLED: if not span: span_list = self.memory_exporter.get_finished_spans() self.assertEqual(len(span_list), 1) span = span_list[0] self.assertEqual(span.name, name) self.assertEqual(span.status.canonical_code, status) self.assertEqual(dict(span.attributes), attributes)
def setup(): reload_module(opentelemetry_tracing) tracer_provider = TracerProvider() memory_exporter = InMemorySpanExporter() span_processor = SimpleExportSpanProcessor(memory_exporter) tracer_provider.add_span_processor(span_processor) trace.set_tracer_provider(tracer_provider) yield memory_exporter
def setUp(self): if HAS_OPENTELEMETRY_INSTALLED: self.original_tracer_provider = trace_api.get_tracer_provider() self.tracer_provider = TracerProvider() self.memory_exporter = InMemorySpanExporter() span_processor = export.SimpleExportSpanProcessor( self.memory_exporter) self.tracer_provider.add_span_processor(span_processor) trace_api.set_tracer_provider(self.tracer_provider)
def init(tracefile: Optional[IO[str]] = None) -> None: tracer_provider = TracerProvider() if tracefile is not None: tracer_provider.add_span_processor( SimpleExportSpanProcessor( ConsoleSpanExporter(out=tracefile, formatter=single_line_json) ) ) trace.set_tracer_provider(tracer_provider)
def test_tracer_provider_override_warning(self): """trace.set_tracer_provider should throw a warning when overridden""" trace.set_tracer_provider(TracerProvider()) with self.assertLogs(level=WARNING) as test: trace.set_tracer_provider(TracerProvider()) self.assertEqual( test.output, [("WARNING:opentelemetry.trace:Overriding current " "TracerProvider")], )
def configure_tracing(configuration: dict): # OTLP Exporter configuration if configuration['exporter'] == 'otlp': service_name = {'service.name': configuration['service_name']} resource = Resource(service_name) trace.set_tracer_provider(TracerProvider(resource=resource)) exporter = OTLPSpanExporter( endpoint=configuration['exporter_endpoint'], insecure=configuration['exporter_insecure']) trace.get_tracer(__name__) span_processor = BatchExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) # Jaeger HTTP Exporter configuration elif configuration['exporter'] == 'jaeger_http': exporter = JaegerSpanExporter( service_name=configuration['service_name'], collector_endpoint=configuration['exporter_endpoint'], ) trace.set_tracer_provider(TracerProvider()) trace.get_tracer(__name__) span_processor = BatchExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) # Jaeger Thrifth Compact Exporter configuration elif configuration['exporter'] == 'jaeger_thrift': exporter = JaegerSpanExporter( service_name=configuration['service_name'], agent_host_name=configuration['exporter_host'], agent_port=configuration['exporter_port'], ) trace.set_tracer_provider(TracerProvider()) trace.get_tracer(__name__) span_processor = BatchExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) # Zipkin Exporter configuration elif configuration['exporter'] == 'zipkin': exporter = ZipkinSpanExporter( service_name=configuration['service_name'], url=configuration['exporter_endpoint']) trace.set_tracer_provider(TracerProvider()) trace.get_tracer(__name__) span_processor = BatchExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) # Console Exporter configuration elif configuration['exporter'] == 'console': trace.set_tracer_provider(TracerProvider()) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(ConsoleSpanExporter())) else: raise ValueError( 'Only Otlp, Jaeger Thrift/HTTP and Zipkin exporters are supported. ' 'Please check your configuration.')
def setUp(self): tracer_provider = TracerProvider() self.exporter = OTLPSpanExporter(insecure=True) tracer_provider.add_span_processor( SimpleExportSpanProcessor(self.exporter) ) self.tracer = tracer_provider.get_tracer(__name__) self.server = server(ThreadPoolExecutor(max_workers=10)) self.server.add_insecure_port("[::]:55680") 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() Configuration._reset() # pylint: disable=protected-access
def init_tracing(): global initialized if initialized: return initialized = True provider = TracerProvider() trace.set_tracer_provider(provider) provider.add_span_processor(BatchExportSpanProcessor(ConsoleSpanExporter())) auto_instrument()
def _init_tracing(exporters: Sequence[SpanExporter], id_generator: IdGenerator): # if env var OTEL_RESOURCE_ATTRIBUTES is given, it will read the service_name # from the env variable else defaults to "unknown_service" provider = TracerProvider(id_generator=id_generator(), ) trace.set_tracer_provider(provider) for _, exporter_class in exporters.items(): exporter_args = {} provider.add_span_processor( BatchSpanProcessor(exporter_class(**exporter_args)))
def tracer_provider(memory_exporter): original_tracer_provider = trace_api.get_tracer_provider() tracer_provider = TracerProvider() span_processor = export.SimpleSpanProcessor(memory_exporter) tracer_provider.add_span_processor(span_processor) trace_api.set_tracer_provider(tracer_provider) yield tracer_provider trace_api.set_tracer_provider(original_tracer_provider)
def _configure_tracing(options: Options) -> None: provider = TracerProvider(resource=Resource.create( attributes={ "service.name": options.service_name, "telemetry.auto.version": __version__, })) propagate.set_global_textmap(B3Format()) if options.response_propagation: set_global_response_propagator( ServerTimingResponsePropagator()) # type: ignore trace.set_tracer_provider(provider) exporter = _new_jaeger_exporter(options) provider.add_span_processor(BatchSpanProcessor(exporter))
def setUp(self): tracer_provider = TracerProvider() self.exporter = OTLPSpanExporter() tracer_provider.add_span_processor( SimpleExportSpanProcessor(self.exporter) ) self.tracer = tracer_provider.get_tracer(__name__) self.server = server(ThreadPoolExecutor(max_workers=10)) self.server.add_insecure_port("[::]:55678") 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": SpanKind.INTERNAL, } ) ], ) self.span.start() self.span.end()
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_provider_implementation( lambda _: TracerProvider()) # 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_provider()) instrument_app(flask_app)
def test_constructor_by_environment_variables(self): """Test using Environment Variables.""" # pylint: disable=protected-access service = "my-opentelemetry-jaeger" collector_endpoint = "localhost:14250" env_patch = mock.patch.dict( "os.environ", { OTEL_EXPORTER_JAEGER_ENDPOINT: collector_endpoint, OTEL_EXPORTER_JAEGER_CERTIFICATE: os.path.dirname(__file__) + "/certs/cred.cert", OTEL_RESOURCE_ATTRIBUTES: "service.name=my-opentelemetry-jaeger", }, ) env_patch.start() provider = TracerProvider(resource=Resource.create({})) trace_api.set_tracer_provider(provider) exporter = JaegerExporter() self.assertEqual(exporter.service_name, service) self.assertIsNotNone(exporter._collector_grpc_client) self.assertEqual(exporter.collector_endpoint, collector_endpoint) self.assertIsNotNone(exporter.credentials) env_patch.stop()
def init_tracing(): """ Add tracing to a Flask app. This is a bit different to the OpenTelemetry Python examples because Vercel does some forking and it needs to be handled without knowing which app runner is being used. To be used with Flask's before_first_request. """ if not tracing_inited_holder.inited: otlp_exporter = OTLPSpanExporter( endpoint="https://api.honeycomb.io:443", insecure=False, credentials=ssl_channel_credentials(), headers=( ("x-honeycomb-team", current_app.config["HONEYCOMB_WRITE_KEY"]), ("x-honeycomb-dataset", "Walter Ego"), ), ) trace.set_tracer_provider(TracerProvider()) tracing_inited_holder.processor = BatchSpanProcessor(otlp_exporter) trace.get_tracer_provider().add_span_processor( tracing_inited_holder.processor) tracing_inited_holder.inited = True
def test_export_service_name(self): trace_api.set_tracer_provider( TracerProvider( resource=Resource.create({SERVICE_NAME: "testServiceName"}))) mock_client = mock.MagicMock() mock_export = mock.MagicMock() mock_client.Export = mock_export host_name = "testHostName" collector_exporter = OpenCensusSpanExporter(client=mock_client, host_name=host_name) self.assertEqual(collector_exporter.node.service_info.name, "testServiceName") trace_id = 0x6E0C63257DE34C926F9EFCD03927272E span_id = 0x34BF92DEEFC58C92 span_context = trace_api.SpanContext( trace_id, span_id, is_remote=False, trace_flags=TraceFlags(TraceFlags.SAMPLED), ) resource = Resource.create({SERVICE_NAME: "test"}) otel_spans = [ trace._Span( name="test1", context=span_context, kind=trace_api.SpanKind.CLIENT, resource=resource, ) ] result_status = collector_exporter.export(otel_spans) self.assertEqual(SpanExportResult.SUCCESS, result_status) self.assertEqual(collector_exporter.node.service_info.name, "test")
def get_tracer_with_processor(span_processor_class): span_processor = span_processor_class(OTLPSpanExporter()) tracer = TracerProvider( active_span_processor=span_processor, sampler=sampling.DEFAULT_ON, ).get_tracer("pipeline_benchmark_tracer") return tracer
def main(): model_name = "my-model" model_version = "v1" client = sczpy.SCZClient(server_url) trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-device", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter)) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(sczpy.SCZSpanExporter(client))) tracer = trace.get_tracer(__name__) while True: with tracer.start_as_current_span("inference") as inference: inference.set_attribute('device', 'my-device') inference.add_event( 'inference', { "confidence": random.randint(80, 101), "model_name": model_name, "model_version": model_version, "file_ref": "dummy_data.txt" }) time.sleep(3)
def test_export(self): """Test that agent and/or collector are invoked""" trace_api.set_tracer_provider( TracerProvider( resource=Resource.create({SERVICE_NAME: "text_export"}))) exporter = jaeger_exporter.JaegerExporter(agent_host_name="localhost", agent_port=6318) # just agent is configured now agent_client_mock = mock.Mock(spec=jaeger_exporter.AgentClientUDP) # pylint: disable=protected-access exporter._agent_client = agent_client_mock exporter.export((self._test_span, )) self.assertEqual(agent_client_mock.emit.call_count, 1) # add also a collector and test that both are called collector_mock = mock.Mock(spec=jaeger_exporter.Collector) # pylint: disable=protected-access exporter._collector = collector_mock exporter.export((self._test_span, )) self.assertEqual(agent_client_mock.emit.call_count, 1) self.assertEqual(collector_mock.submit.call_count, 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 setUpClass(cls): global _MEMORY_EXPORTER # pylint:disable=global-statement trace_api.set_tracer_provider(TracerProvider()) tracer_provider = trace_api.get_tracer_provider() _MEMORY_EXPORTER = InMemorySpanExporter() span_processor = export.SimpleSpanProcessor(_MEMORY_EXPORTER) tracer_provider.add_span_processor(span_processor)
def init_tracing(service_name): if Config.TRACE_EXPORTER is None: return elif Config.TRACE_EXPORTER == 'jaeger': exporter = JaegerSpanExporter( service_name=service_name, agent_host_name=Config.JAEGER_HOST, agent_port=6831, ) elif Config.TRACE_EXPORTER == 'honeycomb': exporter = HoneycombSpanExporter( service_name=service_name, writekey=Config.HONEYCOMB_API_KEY, dataset=Config.HONEYCOMB_DATASET, ) else: raise ValueError( f"TRACE_EXPORTER {Config.TRACE_EXPORTER} is not valid") trace.set_tracer_provider(TracerProvider()) span_processor = BatchExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) # This isn't great but oh well global tracer tracer = trace.get_tracer(service_name)
def initialize_tracer(project_id): trace.set_tracer_provider(TracerProvider()) cloud_trace_exporter = CloudTraceSpanExporter(project_id) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(cloud_trace_exporter)) opentelemetry_tracer = trace.get_tracer(__name__) return opentelemetry_tracer
def setUp(self): super().setUp() trace.set_tracer_provider(TracerProvider()) self.tracer = trace.get_tracer(__name__) self.span_processor = self.get_span_processor() trace.get_tracer_provider().add_span_processor(self.span_processor)
def setUpClass(cls): global _MEMORY_EXPORTER # pylint:disable=global-statement trace_api.set_preferred_tracer_provider_implementation( lambda T: TracerProvider()) tracer_provider = trace_api.tracer_provider() _MEMORY_EXPORTER = InMemorySpanExporter() span_processor = export.SimpleExportSpanProcessor(_MEMORY_EXPORTER) tracer_provider.add_span_processor(span_processor)