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,
