def fixture_span_processor(): exporter = RichConsoleSpanExporter() span_processor = BatchSpanProcessor(exporter) yield span_processor span_processor.shutdown()
def __setup(self): """Set up Open Telemetry processors and exporters for normal use. """ local_debug_mode = self.soda_config.get_value('tracing_local_debug_mode') if local_debug_mode or logger.getEffectiveLevel() == logging.DEBUG: self.__provider.add_span_processor(BatchSpanProcessor(SodaConsoleSpanExporter())) if not local_debug_mode: otlp_exporter = SodaOTLPSpanExporter(endpoint=self.ENDPOINT) otlp_processor = BatchSpanProcessor(otlp_exporter) self.__provider.add_span_processor(otlp_processor) trace.set_tracer_provider(self.__provider)
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 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 _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
def tracer_provider( tracer_type: str = Provide[config.tracing.type], sample_rate: t.Optional[float] = Provide[config.tracing.sample_rate], zipkin_server_url: t.Optional[str] = Provide[ config.tracing.zipkin.url], jaeger_server_address: t.Optional[str] = Provide[ config.tracing.jaeger.address], jaeger_server_port: t.Optional[int] = Provide[ config.tracing.jaeger.port], ): from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor from ..utils.telemetry import ParentBasedTraceIdRatio if sample_rate is None: sample_rate = 0.0 provider = TracerProvider( sampler=ParentBasedTraceIdRatio(sample_rate), # resource: Resource = Resource.create({}), # shutdown_on_exit: bool = True, # active_span_processor: Union[ # SynchronousMultiSpanProcessor, ConcurrentMultiSpanProcessor # ] = None, # id_generator: IdGenerator = None, ) if tracer_type == "zipkin" and zipkin_server_url is not None: from opentelemetry.exporter.zipkin.json import ZipkinExporter exporter = ZipkinExporter(endpoint=zipkin_server_url, ) provider.add_span_processor(BatchSpanProcessor(exporter)) return provider elif (tracer_type == "jaeger" and jaeger_server_address is not None and jaeger_server_port is not None): from opentelemetry.exporter.jaeger.thrift import JaegerExporter exporter = JaegerExporter( agent_host_name=jaeger_server_address, agent_port=jaeger_server_port, ) provider.add_span_processor(BatchSpanProcessor(exporter)) return provider else: return provider
def init_tracing(): resource = Resource.create(attributes={"service.name": "api-service"}) trace.set_tracer_provider(TracerProvider(resource=resource)) # This uses insecure connection for the purpose of example. Please see the # OTLP Exporter documentation for other options. span_processor = BatchSpanProcessor( OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)) trace.get_tracer_provider().add_span_processor(span_processor)
def Start(service_name: str, caller_name: str = __name__): """ Start Activate telemetry Parameters: service_name called_name (use __name__ in caller) """ try: if Telemetry.tracer is None: if hasattr( settings, "TELEMETRY") is False or settings.TELEMETRY is False: return TracerTriage() trace.set_tracer_provider( TracerProvider( resource=Resource.create({SERVICE_NAME: "Climato"}))) tracer = trace.get_tracer(__name__) collector_endpoint = "localhost:14250" if hasattr(settings, "JAEGER_COLLECTOR") is True: collector_endpoint = settings.JAEGER_COLLECTOR collector_insecure = True if hasattr(settings, "JAEGER_INSECURE") is True: collector_insecure = settings.JAEGER_INSECURE jaeger_exporter = grpc.JaegerExporter( collector_endpoint=collector_endpoint, insecure=collector_insecure) # create a BatchSpanProcessor and add the exporter to it span_processor = BatchSpanProcessor(jaeger_exporter) # add to the tracer factory trace.get_tracer_provider().add_span_processor(span_processor) Telemetry.tracer = tracer return TracerTriage(Telemetry.tracer) except Exception as e: if e.__dict__.__len__() == 0 or "done" not in e.__dict__: exception_type, exception_object, exception_traceback = sys.exc_info( ) exception_info = e.__repr__() filename = exception_traceback.tb_frame.f_code.co_filename module = exception_traceback.tb_frame.f_code.co_name line_number = exception_traceback.tb_lineno e.info = { "i": str(exception_info), "f": filename, "n": module, "l": line_number, } e.done = True raise e
def init_exporter(self) -> None: """Initialize exporter""" reporter_type = self._config.agent_config.reporting.trace_reporter_type exporter = self._init_exporter(reporter_type) if exporter is None: logger.warning("Unable to initialize exporter") return span_processor = BatchSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor)
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 post_fork(server, worker): server.log.info("Worker spawned (pid: %s)", worker.pid) resource = Resource.create(attributes={"service.name": "api-service"}) trace.set_tracer_provider(TracerProvider(resource=resource)) # This uses insecure connection for the purpose of example. Please see the # OTLP Exporter documentation for other options. span_processor = BatchSpanProcessor( OTLPSpanExporter(endpoint="localhost:4317", insecure=True)) trace.get_tracer_provider().add_span_processor(span_processor)
def post_fork(server, worker): server.log.info("Worker spawned (pid: %s)", worker.pid) resource = Resource.create(attributes={"service.name": "job-server"}) trace.set_tracer_provider(TracerProvider(resource=resource)) span_processor = BatchSpanProcessor( OTLPSpanExporter(endpoint="https://api.honeycomb.io")) trace.get_tracer_provider().add_span_processor(span_processor) from opentelemetry.instrumentation.auto_instrumentation import ( # noqa: F401 sitecustomize, )
def init_otel(): global tracer, session_name, service_name, insecure LOGGER.debug('Init Otel : {}'.format(service_name)) trace.set_tracer_provider( TracerProvider(resource=Resource.create({SERVICE_NAME: service_name}), )) otel_exporter = OTLPSpanExporter(insecure=insecure) trace.get_tracer_provider().add_span_processor( BatchSpanProcessor(otel_exporter)) tracer = trace.get_tracer(session_name)
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 collect(conf, conn, date_from=None, date_to=None, query=None): trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer_provider().get_tracer(__name__) trace.get_tracer_provider().add_span_processor( BatchSpanProcessor(OTLPSpanExporter())) process = CrawlerProcess(conf['SCRAPY_SETTINGS']) process.crawl(Spider, conf=conf, conn=conn, date_from=date_from, date_to=date_to, query=query) process.start()
def __init__(self, env: Env) -> None: self.optional_variables = [ ("OPENTELEMETRY_ENABLED", env.bool), ("OTEL_TRACES_EXPORTER", env.str), ] self.configure(env) if not self.OPENTELEMETRY_ENABLED or self.OTEL_TRACES_EXPORTER == "none": raise PluginMissingConfiguration("Opentelemetry not enabled") if not HAS_OPENTELEMETRY: raise PluginMissingConfiguration("Extra packages for opentelemetry missing") pipeline_resource = Resource.create( { "pipeline.ci": str(settings.active_ci), "pipeline.commit_sha": settings.GIT_COMMIT_SHA, "pipeline.commit_ref_name": settings.GIT_COMMIT_REF_NAME, "pipeline.environment": settings.ENVIRONMENT_SLUG, "pipeline.id": settings.JOB_PIPELINE_ID, "pipeline.job_id": settings.JOB_ID, "pipeline.job_name": settings.JOB_NAME, "pipeline.pr_id": settings.PR_ID, "pipeline.project_id": settings.PROJECT_ID, "service.name": "kolga", # "service.version": "settings.KOLGA_VERSION", }, ) tracer_provider = TracerProvider(resource=pipeline_resource) span_processor = BatchSpanProcessor(self._get_exporter()) tracer_provider.add_span_processor(span_processor) trace.set_tracer_provider(tracer_provider) tracer = trace.get_tracer(__name__) self.context_detach_tokens: List[str] = [] self.lifecycle_key = context.create_key("kolga_lifecycle") self.known_exceptions: Set[int] = set() self.tracer = tracer # FIXME: We would like to get sub-traces from buildkit but at the time of writing it # segfaults when OTEL is detected: https://github.com/docker/buildx/pull/925. for key in os.environ: if key.startswith("OTEL_"): del os.environ[key]
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 _get_tracer(jaeger_endpoint: str, service_name: str) -> trace.Tracer: set_global_textmap(B3MultiFormat()) RequestsInstrumentor().instrument() trace.set_tracer_provider( TracerProvider( resource=Resource.create({SERVICE_NAME: service_name}) ) ) jaeger_exporter = JaegerExporter( collector_endpoint=jaeger_endpoint + '?format=jaeger.thrift', ) span_processor = BatchSpanProcessor(jaeger_exporter) trace.get_tracer_provider().add_span_processor(span_processor) return trace.get_tracer(__name__)
def _init_tracing(exporters: Sequence[SpanExporter], id_generator: IdGenerator): service_name = _get_service_name() provider = TracerProvider( resource=Resource.create({"service.name": service_name}), id_generator=id_generator(), ) trace.set_tracer_provider(provider) for exporter_name, exporter_class in exporters.items(): exporter_args = {} if exporter_name not in [ EXPORTER_OTLP, EXPORTER_OTLP_SPAN, ]: exporter_args["service_name"] = service_name provider.add_span_processor( BatchSpanProcessor(exporter_class(**exporter_args)))
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)
def _tracer_setup() -> Iterator[Tracer]: """\ Context manager with common setup for tracing endpoints Yields a tracer (from a fresh SDK with new exporter) then finally flushes spans created during the test after. """ tracer_provider = TracerProvider( sampler=ALWAYS_ON, active_span_processor=BatchSpanProcessor( CloudTraceSpanExporter(project_id=os.environ.get("PROJECT_ID")) ), ) tracer = tracer_provider.get_tracer(INSTRUMENTING_MODULE_NAME) try: yield tracer finally: tracer_provider.shutdown()
def generate_distributed_traces(self, otel_service_name, ansible_playbook, tasks_data, status, traceparent): """ generate distributed traces from the collected TaskData and HostData """ tasks = [] parent_start_time = None for task_uuid, task in tasks_data.items(): if parent_start_time is None: parent_start_time = task.start tasks.append(task) trace.set_tracer_provider( TracerProvider( resource=Resource.create({SERVICE_NAME: otel_service_name}))) processor = BatchSpanProcessor(OTLPSpanExporter()) trace.get_tracer_provider().add_span_processor(processor) tracer = trace.get_tracer(__name__) with tracer.start_as_current_span( ansible_playbook, context=self.traceparent_context(traceparent), start_time=parent_start_time, kind=SpanKind.SERVER) as parent: parent.set_status(status) # Populate trace metadata attributes if self.ansible_version is not None: parent.set_attribute("ansible.version", self.ansible_version) parent.set_attribute("ansible.session", self.session) parent.set_attribute("ansible.host.name", self.host) if self.ip_address is not None: parent.set_attribute("ansible.host.ip", self.ip_address) parent.set_attribute("ansible.host.user", self.user) for task in tasks: for host_uuid, host_data in task.host_data.items(): with tracer.start_as_current_span( task.name, start_time=task.start, end_on_exit=False) as span: self.update_span_data(task, host_data, span)
def _init_tracing( exporters: Dict[str, Type[SpanExporter]], id_generator: IdGenerator, auto_instrumentation_version: Optional[str] = None, ): # if env var OTEL_RESOURCE_ATTRIBUTES is given, it will read the service_name # from the env variable else defaults to "unknown_service" auto_resource = {} # populate version if using auto-instrumentation if auto_instrumentation_version: auto_resource[ResourceAttributes. TELEMETRY_AUTO_VERSION] = auto_instrumentation_version provider = TracerProvider( id_generator=id_generator(), resource=Resource.create(auto_resource), ) trace.set_tracer_provider(provider) for _, exporter_class in exporters.items(): exporter_args = {} provider.add_span_processor( BatchSpanProcessor(exporter_class(**exporter_args)))
def common_setup() -> Iterator[tuple[str, Tracer]]: """\ Context manager with common setup for test endpoints It extracts the test-id header, creates a tracer, and finally flushes spans created during the test """ if TEST_ID not in request.headers: raise Exception(f"{TEST_ID} header is required") test_id = request.headers[TEST_ID] tracer_provider = TracerProvider( sampler=ALWAYS_ON, active_span_processor=BatchSpanProcessor( CloudTraceSpanExporter(project_id=os.environ.get("PROJECT_ID"))), ) tracer = tracer_provider.get_tracer(INSTRUMENTING_MODULE_NAME) try: yield test_id, tracer finally: tracer_provider.shutdown()
# defines the interface with a no-op implementation. # It must be done before instrumenting any library. trace.set_tracer_provider( TracerProvider( resource=Resource.create({SERVICE_NAME: "my-server"}) ) ) # configure exporter to Jaeger jaeger_exporter = thrift.JaegerExporter( agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchSpanProcessor(jaeger_exporter) ) # Enable instrumentation for Flask and MySQL libraries FlaskInstrumentor().instrument() MySQLInstrumentor().instrument() tracer = trace.get_tracer(__name__) ############################# application code ################################# app = flask.Flask(__name__) mydb = mysql.connector.connect( user=MYSQL_USER, password=MYSQL_PASSWORD, host=MYSQL_HOST,
# 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.opencensus.trace_exporter import ( OpenCensusSpanExporter, ) from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor exporter = OpenCensusSpanExporter( service_name="basic-service", endpoint="localhost:55678" ) trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) span_processor = BatchSpanProcessor(exporter) trace.get_tracer_provider().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("Hello world from OpenTelemetry Python!")
from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor from opentelemetry.sdk.resources import Resource from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter # Pass in the service we're creating into the tracer provider trace.set_tracer_provider( TracerProvider(resource=Resource.create( {"service.name": "python-app"}) ) ) # Create a BatchSpanProcessor and add the exporter to it # Add to the tracer trace.get_tracer_provider().add_span_processor( BatchSpanProcessor(OTLPSpanExporter( endpoint="https://otlp.nr-data.net:4317") ) ) tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("foo"): with tracer.start_as_current_span("bar"): with tracer.start_as_current_span("baz"): print("Hello world from OpenTelemetry Python!")
import requests from opentelemetry import trace from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter from opentelemetry.instrumentation.requests import RequestsInstrumentor from opentelemetry.propagate import set_global_textmap from opentelemetry.propagators.cloud_trace_propagator import ( CloudTraceFormatPropagator, ) from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor set_global_textmap(CloudTraceFormatPropagator()) tracer_provider = TracerProvider() cloud_trace_exporter = CloudTraceSpanExporter() tracer_provider.add_span_processor( # BatchSpanProcessor buffers spans and sends them in batches in a # background thread. The default parameters are sensible, but can be # tweaked to optimize your performance BatchSpanProcessor(cloud_trace_exporter) ) trace.set_tracer_provider(tracer_provider) tracer = trace.get_tracer(__name__) RequestsInstrumentor().instrument() res = requests.get("http://localhost:6000") print(res.text)
from requests import get from opentelemetry import trace from opentelemetry.propagate import inject from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ( BatchSpanProcessor, ConsoleSpanExporter, ) trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer_provider().get_tracer(__name__) trace.get_tracer_provider().add_span_processor( BatchSpanProcessor(ConsoleSpanExporter()) ) assert len(argv) == 2 with tracer.start_as_current_span("client"): with tracer.start_as_current_span("client-server"): headers = {} inject(headers) requested = get( "http://localhost:8082/server_request", params={"param": argv[1]}, headers=headers, )
import time from opentelemetry import trace from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter from opentelemetry.instrumentation.psycopg2 import Psycopg2Instrumentor from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import (BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor) # Set up OpenTelemetry tracing trace.set_tracer_provider(TracerProvider()) trace.get_tracer_provider().add_span_processor( SimpleSpanProcessor(ConsoleSpanExporter())) trace.get_tracer_provider().add_span_processor( BatchSpanProcessor(CloudTraceSpanExporter(), schedule_delay_millis=5000)) # Trace postgres queries as well Psycopg2Instrumentor().instrument() import psycopg2 from google.cloud.sqlcommenter.psycopg2.extension import CommenterCursorFactory tracer = trace.get_tracer(__name__) def main(): cursor_factory = CommenterCursorFactory( with_db_driver=True, with_dbapi_level=True, with_dbapi_threadsafety=True,