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'} )