def test_try_set_again(self):
self.assertTrue(trace.tracer_provider())
# Try setting after the tracer_provider has already been created:
with self.assertRaises(RuntimeError) as einfo:
trace.set_preferred_tracer_provider_implementation(
get_opentelemetry_implementation)
self.assertIn("already loaded", str(einfo.exception))
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 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)
def do_test_get_envvar(self, envvar_suffix: str) -> None:
global DUMMY_TRACER_PROVIDER # pylint:disable=global-statement
# Test is not runnable with this!
self.assertFalse(sys.flags.ignore_environment)
envname = "OPENTELEMETRY_PYTHON_IMPLEMENTATION_" + envvar_suffix
os.environ[envname] = __name__
try:
tracer_provider = trace.tracer_provider()
self.assertIs(tracer_provider, DUMMY_TRACER_PROVIDER)
finally:
DUMMY_TRACER_PROVIDER = None
del os.environ[envname]
self.assertIs(type(tracer_provider), DummyTracerProvider)
# 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 BatchExportSpanProcessor and add the exporter to it
span_processor = BatchExportSpanProcessor(jaeger_exporter)
# add to the tracer factory
trace.tracer_provider().add_span_processor(span_processor)
# create some spans for testing
with tracer.start_as_current_span("foo") as foo:
time.sleep(0.1)
foo.set_attribute("my_atribbute", True)
foo.add_event("event in foo", {"name": "foo1"})
with tracer.start_as_current_span("bar",
links=[trace.Link(foo.get_context())
]) as bar:
time.sleep(0.2)
bar.set_attribute("speed", 100.0)
with tracer.start_as_current_span("baz") as baz:
time.sleep(0.3)
baz.set_attribute("name", "mauricio")
from opentelemetry.sdk.trace.export import (
BatchExportSpanProcessor,
ConsoleSpanExporter,
)
if os.getenv("EXPORTER") == "jaeger":
from opentelemetry.ext.jaeger import JaegerSpanExporter
exporter = JaegerSpanExporter(
service_name="http-client",
agent_host_name="localhost",
agent_port=6831,
)
else:
exporter = ConsoleSpanExporter()
# The preferred tracer implementation must be set, as the opentelemetry-api
# defines the interface with a no-op implementation.
trace.set_preferred_tracer_provider_implementation(lambda T: TracerProvider())
tracer_provider = trace.tracer_provider()
# SpanExporter receives the spans and send them to the target location.
span_processor = BatchExportSpanProcessor(exporter)
tracer_provider.add_span_processor(span_processor)
# 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.
http_requests.enable(tracer_provider)
response = requests.get(url="http://127.0.0.1:5000/")
def do_test_preferred_impl(self, setter: Callable[[Any], Any]) -> None:
setter(get_opentelemetry_implementation)
tracer_provider = trace.tracer_provider()
self.assertIs(tracer_provider, DUMMY_TRACER_PROVIDER)
def test_preferred_impl(self):
trace.set_preferred_tracer_provider_implementation(
get_opentelemetry_implementation)
tracer_provider = trace.tracer_provider()
self.assertIs(tracer_provider, DUMMY_TRACER_PROVIDER)
def test_get_default(self):
tracer_provider = trace.tracer_provider()
self.assertIs(type(tracer_provider), trace.DefaultTracerProvider)
exporter = JaegerSpanExporter(
service_name="http-server",
agent_host_name="localhost",
agent_port=6831,
)
else:
exporter = ConsoleSpanExporter()
# The preferred tracer implementation must be set, as the opentelemetry-api
# defines the interface with a no-op implementation.
trace.set_preferred_tracer_provider_implementation(lambda T: TracerProvider())
tracer = trace.get_tracer(__name__)
# SpanExporter receives the spans and send them to the target location.
span_processor = BatchExportSpanProcessor(exporter)
trace.tracer_provider().add_span_processor(span_processor)
# 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.
http_requests.enable(trace.tracer_provider())
app = flask.Flask(__name__)
app.wsgi_app = OpenTelemetryMiddleware(app.wsgi_app)
@app.route("/")
def hello():
with tracer.start_as_current_span("parent"):
requests.get("https://www.wikipedia.org/wiki/Rabbit")
return "hello"
def setUp(self):
"""Create an OpenTelemetry tracer and a shim before every test case."""
self.shim = opentracingshim.create_tracer(trace.tracer_provider())