def test_constructor_default(self): """Test the default values assigned by constructor.""" service_name = "my-service-name" agent_host_name = "localhost" agent_port = 6831 exporter = jaeger_exporter.JaegerSpanExporter(service_name) self.assertEqual(exporter.service_name, service_name) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.collector_endpoint, None) self.assertEqual(exporter.username, None) self.assertEqual(exporter.password, None) self.assertTrue(exporter.collector is None) self.assertTrue(exporter.agent_client is not None)
def test_constructor_by_environment_variables(self): """Test the constructor using Environment Variables.""" service = "my-opentelemetry-jaeger" agent_host_name = "opentelemetry.io" agent_port = "6831" collector_endpoint = "https://opentelemetry.io:15875" username = "******" password = "******" auth = (username, password) environ_patcher = mock.patch.dict( "os.environ", { "OTEL_EXPORTER_JAEGER_AGENT_HOST": agent_host_name, "OTEL_EXPORTER_JAEGER_AGENT_PORT": agent_port, "OTEL_EXPORTER_JAEGER_ENDPOINT": collector_endpoint, "OTEL_EXPORTER_JAEGER_USER": username, "OTEL_EXPORTER_JAEGER_PASSWORD": password, }, ) environ_patcher.start() exporter = jaeger_exporter.JaegerSpanExporter(service_name=service) self.assertEqual(exporter.service_name, service) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.agent_port, int(agent_port)) self.assertTrue(exporter.collector is not None) self.assertEqual(exporter.collector_endpoint, collector_endpoint) self.assertEqual(exporter.collector.auth, auth) # property should not construct new object collector = exporter.collector self.assertEqual(exporter.collector, collector) # property should construct new object # pylint: disable=protected-access exporter._collector = None exporter.username = None exporter.password = None self.assertNotEqual(exporter.collector, collector) self.assertTrue(exporter.collector.auth is None) environ_patcher.stop() Configuration._reset()
def test_constructor_default(self): # pylint: disable=protected-access """Test the default values assigned by constructor.""" service_name = "my-service-name" agent_host_name = "localhost" agent_port = 6831 exporter = jaeger_exporter.JaegerSpanExporter(service_name) self.assertEqual(exporter.service_name, service_name) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.collector_endpoint, None) self.assertEqual(exporter.username, None) self.assertEqual(exporter.password, None) self.assertTrue(exporter._collector_http_client is None) self.assertTrue(exporter._agent_client is not None) self.assertIsNone(exporter._max_tag_value_length)
def test_constructor_explicit(self): """Test the constructor passing all the options.""" service = "my-opentelemetry-jaeger" collector_host_name = "opentelemetry.io" collector_port = 15875 collector_endpoint = "/myapi/traces?format=jaeger.thrift" collector_protocol = "https" agent_port = 14268 agent_host_name = "opentelemetry.io" username = "******" password = "******" auth = (username, password) exporter = jaeger_exporter.JaegerSpanExporter( service_name=service, collector_host_name=collector_host_name, collector_port=collector_port, collector_endpoint=collector_endpoint, collector_protocol="https", agent_host_name=agent_host_name, agent_port=agent_port, username=username, password=password, ) self.assertEqual(exporter.service_name, service) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.collector_host_name, collector_host_name) self.assertEqual(exporter.collector_port, collector_port) self.assertEqual(exporter.collector_protocol, collector_protocol) self.assertTrue(exporter.collector is not None) self.assertEqual(exporter.collector.auth, auth) # property should not construct new object collector = exporter.collector self.assertEqual(exporter.collector, collector) # property should construct new object # pylint: disable=protected-access exporter._collector = None exporter.username = None exporter.password = None self.assertNotEqual(exporter.collector, collector) self.assertTrue(exporter.collector.auth is None)
def test_constructor_default(self): """Test the default values assigned by constructor.""" service_name = "my-service-name" host_name = "localhost" thrift_port = None agent_port = 6831 collector_endpoint = "/api/traces?format=jaeger.thrift" exporter = jaeger_exporter.JaegerSpanExporter(service_name) self.assertEqual(exporter.service_name, service_name) self.assertEqual(exporter.collector_host_name, None) self.assertEqual(exporter.agent_host_name, host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.collector_port, thrift_port) self.assertEqual(exporter.collector_endpoint, collector_endpoint) self.assertEqual(exporter.username, None) self.assertEqual(exporter.password, None) self.assertTrue(exporter.collector is None) self.assertTrue(exporter.agent_client is not None)
def test_export(self): """Test that agent and/or collector are invoked""" exporter = jaeger_exporter.JaegerSpanExporter( "test_export", 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 init(conf): trace.set_tracer_provider(TracerProvider()) # https://opentelemetry-python.readthedocs.io/en/stable/exporter/jaeger/jaeger.html # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name=conf['service_name'], # configure agent agent_host_name=conf['agent_host_name'], agent_port=conf['agent_port'], # optional: configure also collector # collector_host_name='localhost', # collector_port=14268, # collector_endpoint='/api/traces?format=jaeger.thrift', # collector_protocol='http', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor)
def __init__( self, type: Text = None, service_name: Text = "rasa", agent_host_name: Text = "localhost", agent_port: int = 6831, ): self.type = type if self.type == "open_telemetry": trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name=service_name, agent_host_name=agent_host_name, agent_port=agent_port, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter) ) # self.tracer = trace.get_tracer(__name__) self.tracer = trace.get_tracer(__name__) logger.debug(f"Tracer - exit init, name: {__name__}") elif self.type == "jaeger": config = Config( config={ # usually read from some yaml config "sampler": { "type": "const", "param": 1, }, "logging": True, }, service_name=service_name, validate=True, ) # this call also sets opentracing.tracer self.tracer = config.initialize_tracer()
def test_constructor_explicit(self): # pylint: disable=protected-access """Test the constructor passing all the options.""" service = "my-opentelemetry-jaeger" collector_endpoint = "https://opentelemetry.io:15875" agent_port = 14268 agent_host_name = "opentelemetry.io" username = "******" password = "******" auth = (username, password) exporter = jaeger_exporter.JaegerSpanExporter( service_name=service, agent_host_name=agent_host_name, agent_port=agent_port, collector_endpoint=collector_endpoint, username=username, password=password, max_tag_value_length=42, ) self.assertEqual(exporter.service_name, service) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertTrue(exporter._collector_http_client is not None) self.assertEqual(exporter._collector_http_client.auth, auth) # property should not construct new object collector = exporter._collector_http_client self.assertEqual(exporter._collector_http_client, collector) # property should construct new object exporter._collector = None exporter.username = None exporter.password = None self.assertNotEqual(exporter._collector_http_client, collector) self.assertTrue(exporter._collector_http_client.auth is None) self.assertEqual(exporter._max_tag_value_length, 42)
def set_up(service_name: str): """Instantiate and configure the span exporter. The exporter is select and configured through environment variables. Parameters ---------- service_name : str The name under which the data is exported. """ if tracing_settings.TRACING_EXPORTER.lower() == "jaeger": from opentelemetry.sdk.trace.export import BatchExportSpanProcessor jaeger_exporter = jaeger.JaegerSpanExporter( service_name=service_name, agent_host_name=tracing_settings.JAEGER_AGENT_HOST_NAME, agent_port=tracing_settings.JAEGER_AGENT_PORT, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter)) elif tracing_settings.TRACING_EXPORTER.lower() == "console": from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor, ConsoleSpanExporter trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(ConsoleSpanExporter())) elif tracing_settings.TRACING_EXPORTER == "gcp": from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter from opentelemetry.tools.cloud_trace_propagator import CloudTraceFormatPropagator from opentelemetry.sdk.trace.export import BatchExportSpanProcessor from opentelemetry.propagators import set_global_textmap cloud_trace_exporter = CloudTraceSpanExporter() trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(cloud_trace_exporter)) set_global_textmap(CloudTraceFormatPropagator())
from opentelemetry import trace from opentelemetry.exporter import jaeger from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchSpanProcessor trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-helloworld-service", # configure agent agent_host_name="localhost", agent_port=6831, # optional: configure also collector # collector_host_name="localhost", # collector_port=14268, # collector_endpoint="/api/traces?format=jaeger.thrift", # username=xxxx, # optional # password=xxxx, # optional ) # Create a JaegerSpanExporter to send spans with gRPC # If there is no encryption or authentication set `insecure` to True # If server has authentication with SSL/TLS you can set the # parameter credentials=ChannelCredentials(...) or the environment variable # `EXPORTER_JAEGER_CERTIFICATE` with file containing creds. # jaeger_exporter = jaeger.JaegerSpanExporter( # service_name="my-helloworld-service", # collector_endpoint="localhost:14250",
import mysql.connector from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.exporter import jaeger from opentelemetry.sdk.trace.export import BatchExportSpanProcessor ######################### configure exporters ################################## # Set preferred tracer implementation trace.set_tracer_provider(TracerProvider()) # configure exporter to Jaeger jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-server", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter) ) ############################# application code ################################# app = flask.Flask(__name__) mydb = mysql.connector.connect( user=MYSQL_USER, password=MYSQL_PASSWORD, host=MYSQL_HOST, port=MYSQL_PORT,
from validators import AddPointValidator from opentelemetry import trace from opentelemetry.exporter import jaeger from opentelemetry.instrumentation.flask import FlaskInstrumentor from opentelemetry.instrumentation.psycopg2 import Psycopg2Instrumentor from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchExportSpanProcessor trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="point_service", agent_host_name="jaeger", agent_port=6831, ) span_processor = BatchExportSpanProcessor(jaeger_exporter) trace.get_tracer_provider().add_span_processor(span_processor) app = Flask("point_app") FlaskInstrumentor().instrument_app(app) Psycopg2Instrumentor().instrument(tracer_provider=trace.get_tracer_provider()) postgres_con = psycopg2.connect( database="postgres", user="******", host="db", port="5432",
from opentelemetry import trace from opentelemetry.exporter import jaeger from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchExportSpanProcessor from opentelemetry.instrumentation.flask import FlaskInstrumentor from flask import Flask from flask import request import requests import time trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name='orch-service', agent_host_name='localhost', agent_port=6831, ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor) app = Flask(__name__) FlaskInstrumentor().instrument_app(app) def get_information_from_k8s(): with tracer.start_as_current_span('k8s-information'): requests.get('http://www.google.com')
from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor from sklearn.datasets import load_iris from opentelemetry_sklearn.instrumentation.sklearn import SklearnInstrumentor from .sklearn_model import sklearn_model logging.basicConfig(level=logging.DEBUG) trace.set_tracer_provider(TracerProvider()) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(ConsoleSpanExporter())) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="fastapi-sklearn", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter)) app = fastapi.FastAPI() X, y = load_iris(return_X_y=True) SklearnInstrumentor().instrument_estimator(sklearn_model) @app.get("/predict") async def predict(): rows = X.shape[0]
from opentelemetry import trace # implementing jaeger from opentelemetry.exporter import jaeger from opentelemetry.sdk.trace.export import BatchExportSpanProcessor trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name='test', # configure agent agent_host_name='localhost', agent_port=6831, # optional: configure also collector # collector_host_name='localhost', # collector_port=14268, # collector_endpoint='/api/traces?format=jaeger.thrift', # collector_protocol='http', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor) DjangoInstrumentor().instrument() RequestsInstrumentor().instrument()