def get_otel_tracer():
set_global_textmap(CompositeHTTPPropagator([B3Format()]))
span_exporter = get_otlp_exporter()
trace.get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(span_exporter))
return trace.get_tracer(__name__)
def serve():
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter()))
propagators.set_global_textmap(B3Format())
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
interceptors=[server_interceptor()])
add_ImageServiceServicer_to_server(ImageServer(), server)
server.add_insecure_port("[::]:50051")
server.start()
server.wait_for_termination()
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 serve():
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter())
)
propagators.set_global_textmap(B3Format())
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), interceptors=[server_interceptor()])
add_ProductInfoServicer_to_server(ProductInfoServer(), server)
server.add_insecure_port("[::]:50050")
server.start()
proxy = MyProxy(ProductInfoServer)
try:
proxy.start()
server.wait_for_termination()
except KeyboardInterrupt:
print("terminating")
proxy.stop()
print("Goodbye")
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.sdk.trace.export import (ConsoleSpanExporter,
SimpleSpanProcessor,
BatchSpanProcessor)
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
# propagator
from opentelemetry.propagate import set_global_textmap
from opentelemetry.propagators.b3 import B3Format
load_dotenv() # take environment variables from .env
# Set global propagator
set_global_textmap(B3Format())
# set trace provider as default one
trace.set_tracer_provider(
TracerProvider(
resource=Resource.create({SERVICE_NAME: "my-helloworld-service"})))
# jaeger exporter
jaeger_exporter = JaegerExporter(
agent_host_name="localhost",
agent_port=6831,
)
# add exporter to trace
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(jaeger_exporter)
def configure_opentelemetry(
access_token: str = _LS_ACCESS_TOKEN,
span_exporter_endpoint: str = _OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
service_name: str = _LS_SERVICE_NAME,
service_version: str = _LS_SERVICE_VERSION,
propagators: str = _OTEL_PROPAGATORS,
resource_attributes: str = _OTEL_RESOURCE_ATTRIBUTES,
log_level: str = _OTEL_LOG_LEVEL,
span_exporter_insecure: bool = _OTEL_EXPORTER_OTLP_TRACES_INSECURE,
_auto_instrumented: bool = False,
):
# pylint: disable=too-many-locals
# pylint: disable=too-many-statements
"""
Configures OpenTelemetry with Lightstep environment variables
This function works as a configuration layer that allows the Lightstep end
user to use current environment variables seamlessly with OpenTelemetry. In
this way, it is not needed to make any configuration changes to the
environment before using OpenTelemetry. The configuration can be done via
environment variables (prefixed with `LS`) or via arguments passed to this
function. Each argument has a 1:1 correspondence with an environment
variable, their description follows:
Arguments:
access_token (str): LS_ACCESS_TOKEN, the access token used to
authenticate with the Lightstep satellite. This configuration value
is mandatory.
span_exporter_endpoint (str): OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, the URL of the Lightstep
satellite where the spans are to be exported. Defaults to
`ingest.lightstep.com:443`.
service_name (str): LS_SERVICE_NAME, the name of the service that is
used along with the access token to send spans to the Lighstep
satellite. This configuration value is mandatory.
service_version (str): LS_SERVICE_VERSION, the version of the service
used to sernd spans to the Lightstep satellite. Defaults to `None`.
propagators (str): OTEL_PROPAGATORS, a list of propagators to be used.
The list is specified as a comma-separated string of values, for
example: `a,b,c,d,e,f`. Defaults to `b3`.
resource_attributes (str): OTEL_RESOURCE_ATTRIBUTES, a dictionary of
key value pairs used to instantiate the resouce of the tracer
provider. The dictionary is specified as a string of
comma-separated `key=value` pairs. For example: `a=1,b=2,c=3`.
Defaults to
`telemetry.sdk.language=python,telemetry.sdk.version=X` where `X`
is the version of this package.
log_level (str): OTEL_LOG_LEVEL, one of:
- `NOTSET` (0)
- `DEBUG` (10)
- `INFO` (20)
- `WARNING` (30)
- `ERROR` (40)
- `CRITICAL` (50)
Defaults to `logging.ERROR`.
span_exporter_insecure (bool):
OTEL_EXPORTER_OTLP_TRACES_INSECURE, a boolean value that indicates if
an insecure channel is to be used to send spans to the satellite.
Defaults to `False`.
"""
log_levels = {
"NOTSET": NOTSET,
"DEBUG": DEBUG,
"INFO": INFO,
"WARNING": WARNING,
"ERROR": ERROR,
"CRITICAL": CRITICAL,
}
# No environment variable is passed here as the first argument since what
# is intended here is just to parse the value of the already obtained value
# of the environment variables OTEL_PROPAGATORS and
# OTEL_RESOURCE_ATTRIBUTES into a list and a dictionary. This is not done
# at the attribute declaration to avoid having mutable objects as default
# arguments.
propagators = _env.list("", propagators)
resource_attributes = _env.dict("", resource_attributes)
log_level = log_level.upper()
if log_level not in log_levels.keys():
message = (
"Invalid configuration: invalid log_level value."
"It must be one of {}.".format(", ".join(log_levels.keys()))
)
_logger.error(message)
raise InvalidConfigurationError(message)
log_level = log_levels[log_level]
basicConfig(level=log_level)
_logger.debug("configuration")
if not _validate_service_name(service_name):
message = (
"Invalid configuration: service name missing. "
"Set environment variable LS_SERVICE_NAME"
)
if not _auto_instrumented:
message += (
" or call configure_opentelemetry with service_name defined"
)
_logger.error(message)
raise InvalidConfigurationError(message)
resource_attributes["service.name"] = service_name
logged_attributes = {
"access_token": access_token,
"span_exporter_endpoint": span_exporter_endpoint,
"service_name": service_name,
"propagators": propagators,
"resource_attributes": resource_attributes,
"log_level": getLevelName(log_level),
"span_exporter_insecure": span_exporter_insecure,
}
if service_version is not None:
resource_attributes["service.version"] = service_version
logged_attributes["service_version"] = service_version
for key, value in logged_attributes.items():
_logger.debug("%s: %s", key, value)
if access_token is None:
if (
span_exporter_endpoint
== _DEFAULT_OTEL_EXPORTER_OTLP_TRACES_ENDPOINT
):
message = (
"Invalid configuration: token missing. "
"Must be set to send data to {}. "
"Set environment variable LS_ACCESS_TOKEN"
).format(_OTEL_EXPORTER_OTLP_TRACES_ENDPOINT)
if not _auto_instrumented:
message += " or call configure_opentelemetry with access_token defined"
_logger.error(message)
raise InvalidConfigurationError(message)
if access_token is not None and not _validate_token(access_token):
message = (
"Invalid configuration: invalid token. "
"Token must be a 32, 84 or 104 character long string."
)
_logger.error(message)
raise InvalidConfigurationError(message)
_logger.debug("configuring propagation")
# FIXME use entry points (instead of a dictionary) to locate propagator
# classes
set_global_textmap(
CompositeHTTPPropagator(
[
{
"b3": B3Format(),
"baggage": BaggagePropagator(),
"tracecontext": TraceContextTextMapPropagator(),
}[propagator]
for propagator in propagators
]
)
)
headers = None
if access_token != "":
headers = (("lightstep-access-token", access_token),)
_logger.debug("configuring tracing")
credentials = _common_configuration(
set_tracer_provider,
TracerProvider,
"OTEL_PYTHON_TRACER_PROVIDER",
span_exporter_insecure,
)
get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(
LightstepOTLPSpanExporter(
endpoint=span_exporter_endpoint,
credentials=credentials,
headers=headers,
)
)
)
if _ATTRIBUTE_HOST_NAME not in resource_attributes.keys() or not (
resource_attributes[_ATTRIBUTE_HOST_NAME]
):
no_hostname_message = (
"set it with the environment variable OTEL_RESOURCE_ATTRIBUTES or "
'with the resource_attributes argument. Use "host.name" as key '
"in both cases."
)
try:
hostname = gethostname()
if not hostname:
_logger.warning("Hostname is empty, %s", no_hostname_message)
else:
resource_attributes[_ATTRIBUTE_HOST_NAME] = hostname
# pylint: disable=broad-except
except Exception:
_logger.exception(
"Unable to get hostname, %s", no_hostname_message
)
get_tracer_provider().resource = Resource(resource_attributes)
if log_level <= DEBUG:
get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(ConsoleSpanExporter())
)
from __future__ import print_function
from flask_bootstrap import Bootstrap
from flask import Flask, request, session, render_template, redirect, url_for
from flask import _request_ctx_stack as stack
import simplejson as json
import requests
import sys
from json2html import *
import logging
import requests
import os
import asyncio
from opentelemetry import propagators
from opentelemetry.propagators.b3 import B3Format
propagators.set_global_textmap(B3Format())
# These two lines enable debugging at httplib level (requests->urllib3->http.client)
# You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.
# The only thing missing will be the response.body which is not logged.
try:
import http.client as http_client
except ImportError:
# Python 2
import httplib as http_client
http_client.HTTPConnection.debuglevel = 1
app = Flask(__name__)
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
def wrapper(*args, **kwargs):
message_attributes = kwargs.get('MessageAttributes', {})
B3Format().inject(_message_attribute_setter, message_attributes)
kwargs['MessageAttributes'] = message_attributes
return func(*args, **kwargs)