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