def test_export_service_name(self):
trace_api.set_tracer_provider(
TracerProvider(
resource=Resource.create({SERVICE_NAME: "testServiceName"})))
mock_client = mock.MagicMock()
mock_export = mock.MagicMock()
mock_client.Export = mock_export
host_name = "testHostName"
collector_exporter = OpenCensusSpanExporter(client=mock_client,
host_name=host_name)
self.assertEqual(collector_exporter.node.service_info.name,
"testServiceName")
trace_id = 0x6E0C63257DE34C926F9EFCD03927272E
span_id = 0x34BF92DEEFC58C92
span_context = trace_api.SpanContext(
trace_id,
span_id,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
)
resource = Resource.create({SERVICE_NAME: "test"})
otel_spans = [
trace._Span(
name="test1",
context=span_context,
kind=trace_api.SpanKind.CLIENT,
resource=resource,
)
]
result_status = collector_exporter.export(otel_spans)
self.assertEqual(SpanExportResult.SUCCESS, result_status)
self.assertEqual(collector_exporter.node.service_info.name, "test")
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 __init__(self, test_mode: bool):
if SodaTelemetry.__instance is not None:
raise Exception("This class is a singleton!")
else:
SodaTelemetry.__instance = self
self.__send = self.soda_config.send_anonymous_usage_stats or test_mode
if self.__send:
logger.info("Setting up usage telemetry.")
self.__provider = TracerProvider(
resource=Resource.create(
{
'os.architecture': platform.architecture(),
'python.version': platform.python_version(),
'python.implementation': platform.python_implementation(),
ResourceAttributes.OS_TYPE: platform.system(),
ResourceAttributes.OS_VERSION: platform.version(),
'platform': platform.platform(),
ResourceAttributes.SERVICE_VERSION: SODA_SQL_VERSION,
ResourceAttributes.SERVICE_NAME: 'soda',
ResourceAttributes.SERVICE_NAMESPACE: 'soda-sql',
}
)
)
if test_mode:
self.__setup_for_test()
else:
self.__setup()
else:
logger.info("Skipping usage telemetry setup.")
def test_constructor_by_environment_variables(self):
"""Test using Environment Variables."""
# pylint: disable=protected-access
service = "my-opentelemetry-jaeger"
collector_endpoint = "localhost:14250"
env_patch = mock.patch.dict(
"os.environ",
{
OTEL_EXPORTER_JAEGER_ENDPOINT: collector_endpoint,
OTEL_EXPORTER_JAEGER_CERTIFICATE:
os.path.dirname(__file__) + "/certs/cred.cert",
OTEL_RESOURCE_ATTRIBUTES:
"service.name=my-opentelemetry-jaeger",
},
)
env_patch.start()
provider = TracerProvider(resource=Resource.create({}))
trace_api.set_tracer_provider(provider)
exporter = JaegerExporter()
self.assertEqual(exporter.service_name, service)
self.assertIsNotNone(exporter._collector_grpc_client)
self.assertEqual(exporter.collector_endpoint, collector_endpoint)
self.assertIsNotNone(exporter.credentials)
env_patch.stop()
def __init__(self,
stateful=True,
resource: Resource = Resource.create({}),
shutdown_on_exit: bool = True):
super().__init__(stateful, resource, shutdown_on_exit)
self._meters: Dict[str, Meter] = {}
self._exporter_intervals = dict()
def __init__(
self,
name: str = None,
context: trace_api.SpanContext = None,
parent: Optional[trace_api.SpanContext] = None,
resource: Resource = Resource.create({}),
attributes: types.Attributes = None,
events: Sequence[Event] = (),
links: Sequence[trace_api.Link] = (),
kind: trace_api.SpanKind = trace_api.SpanKind.INTERNAL,
instrumentation_info: InstrumentationInfo = None,
status: Status = Status(StatusCode.UNSET),
start_time: Optional[int] = None,
end_time: Optional[int] = None,
) -> None:
self._name = name
self._context = context
self._kind = kind
self._instrumentation_info = instrumentation_info
self._parent = parent
self._start_time = start_time
self._end_time = end_time
self._attributes = attributes
self._events = events
self._links = links
self._resource = resource
self._status = status
def test_custom_tracer_provider(self):
provider = TracerProvider(
resource=Resource.create(
{
"service.name": "test",
"deployment.environment": "env",
"service.version": "1234",
},
),
)
provider.add_span_processor(
export.SimpleSpanProcessor(self.memory_exporter)
)
SQLAlchemyInstrumentor().instrument(tracer_provider=provider)
from sqlalchemy import create_engine # pylint: disable-all
engine = create_engine("sqlite:///:memory:")
cnx = engine.connect()
cnx.execute("SELECT 1 + 1;").fetchall()
spans = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans), 2)
self.assertEqual(spans[0].resource.attributes["service.name"], "test")
self.assertEqual(
spans[0].resource.attributes["deployment.environment"], "env"
)
self.assertEqual(
spans[0].resource.attributes["service.version"], "1234"
)
def __init__(
self,
sampler: sampling.Sampler = _TRACE_SAMPLER,
resource: Resource = Resource.create({}),
shutdown_on_exit: bool = True,
active_span_processor: Union[
SynchronousMultiSpanProcessor, ConcurrentMultiSpanProcessor
] = None,
id_generator: IdGenerator = None,
span_limits: SpanLimits = None,
):
self._active_span_processor = (
active_span_processor or SynchronousMultiSpanProcessor()
)
if id_generator is None:
self.id_generator = RandomIdGenerator()
else:
self.id_generator = id_generator
self._resource = resource
self.sampler = sampler
self._span_limits = span_limits or SpanLimits()
self._atexit_handler = None
if shutdown_on_exit:
self._atexit_handler = atexit.register(self.shutdown)
def __init__(
self,
name: str,
context: trace_api.SpanContext,
parent: Optional[trace_api.SpanContext] = None,
sampler: Optional[sampling.Sampler] = None,
trace_config: None = None, # TODO
resource: Resource = Resource.create({}),
attributes: types.Attributes = None,
events: Sequence[Event] = None,
links: Sequence[trace_api.Link] = (),
kind: trace_api.SpanKind = trace_api.SpanKind.INTERNAL,
span_processor: SpanProcessor = SpanProcessor(),
instrumentation_info: InstrumentationInfo = None,
record_exception: bool = True,
set_status_on_exception: bool = True,
limits=_UnsetLimits,
) -> None:
super().__init__(
name=name,
context=context,
parent=parent,
kind=kind,
resource=resource,
instrumentation_info=instrumentation_info,
)
self._sampler = sampler
self._trace_config = trace_config
self._record_exception = record_exception
self._set_status_on_exception = set_status_on_exception
self._span_processor = span_processor
self._limits = limits
self._lock = threading.Lock()
self._attributes = BoundedAttributes(
self._limits.max_span_attributes,
attributes,
immutable=False,
max_value_len=self._limits.max_span_attribute_length,
)
self._events = self._new_events()
if events:
for event in events:
event._attributes = BoundedAttributes(
self._limits.max_event_attributes,
event.attributes,
max_value_len=self._limits.max_attribute_length,
)
self._events.append(event)
if links is None:
self._links = self._new_links()
else:
for link in links:
link._attributes = BoundedAttributes(
self._limits.max_link_attributes,
link.attributes,
max_value_len=self._limits.max_attribute_length,
)
self._links = BoundedList.from_seq(self._limits.max_links, links)
def __init__(
self,
name: str,
context: trace_api.SpanContext,
parent: Optional[trace_api.SpanContext] = None,
sampler: Optional[sampling.Sampler] = None,
trace_config: None = None, # TODO
resource: Resource = Resource.create({}),
attributes: types.Attributes = None,
events: Sequence[Event] = None,
links: Sequence[trace_api.Link] = (),
kind: trace_api.SpanKind = trace_api.SpanKind.INTERNAL,
span_processor: SpanProcessor = SpanProcessor(),
instrumentation_info: InstrumentationInfo = None,
record_exception: bool = True,
set_status_on_exception: bool = True,
) -> None:
self.name = name
self.context = context
self.parent = parent
self.sampler = sampler
self.trace_config = trace_config
self.resource = resource
self.kind = kind
self._record_exception = record_exception
self._set_status_on_exception = set_status_on_exception
self.span_processor = span_processor
self.status = Status(StatusCode.UNSET)
self._lock = threading.Lock()
_filter_attribute_values(attributes)
if not attributes:
self.attributes = self._new_attributes()
else:
self.attributes = BoundedDict.from_map(
SPAN_ATTRIBUTE_COUNT_LIMIT, attributes
)
self.events = self._new_events()
if events:
for event in events:
_filter_attribute_values(event.attributes)
# pylint: disable=protected-access
event._attributes = _create_immutable_attributes(
event.attributes
)
self.events.append(event)
if links is None:
self.links = self._new_links()
else:
self.links = BoundedList.from_seq(SPAN_LINK_COUNT_LIMIT, links)
self._end_time = None # type: Optional[int]
self._start_time = None # type: Optional[int]
self.instrumentation_info = instrumentation_info
def _create_app(self):
# instrumentation is handled by the instrument call
resource = Resource.create({"key1": "value1", "key2": "value2"})
result = self.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
self.memory_exporter = exporter
self._instrumentor.instrument(tracer_provider=tracer_provider)
return self._create_fastapi_app()
def test_basic_wsgi_call(self):
resource = Resource.create({"service-key": "service-value"})
result = TestBase.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
app = otel_wsgi.OpenTelemetryMiddleware(
simple_wsgi, tracer_provider=tracer_provider)
response = app(self.environ, self.start_response)
self.validate_response(response, exporter)
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 setUp(self):
super().setUp()
resource = Resource.create({"resource-key": "resource-value"})
result = self.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
self.exporter = exporter
FalconInstrumentor().instrument(tracer_provider=tracer_provider)
self.app = make_app()
def setUpClass(cls):
os.environ.clear()
os.environ[
"APPINSIGHTS_INSTRUMENTATIONKEY"] = "1234abcd-5678-4efa-8abc-1234567890ab"
cls._exporter = AzureMonitorLogExporter()
cls._log_data = _logs.LogData(
_logs.LogRecord(
timestamp=1646865018558419456,
trace_id=125960616039069540489478540494783893221,
span_id=2909973987304607650,
severity_text="WARNING",
trace_flags=None,
severity_number=SeverityNumber.WARN,
name=None,
body="Test message",
resource=Resource.create(attributes={"asd": "test_resource"}),
attributes={"test": "attribute"},
),
InstrumentationInfo("test_name"),
)
cls._exc_data = _logs.LogData(
_logs.LogRecord(
timestamp=1646865018558419456,
trace_id=125960616039069540489478540494783893221,
span_id=2909973987304607650,
severity_text="EXCEPTION",
trace_flags=None,
severity_number=SeverityNumber.FATAL,
name=None,
body="Test message",
resource=Resource.create(attributes={"asd": "test_resource"}),
attributes={
"test":
"attribute",
SpanAttributes.EXCEPTION_TYPE:
"ZeroDivisionError",
SpanAttributes.EXCEPTION_MESSAGE:
"division by zero",
SpanAttributes.EXCEPTION_STACKTRACE:
'Traceback (most recent call last):\n File "test.py", line 38, in <module>\n raise ZeroDivisionError()\nZeroDivisionError\n'
},
),
InstrumentationInfo("test_name"),
)
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 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 setUp(self):
super().setUp()
resource = Resource.create({"service.name": "flask-api"})
result = self.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
self.memory_exporter = exporter
self.app = Flask(__name__)
FlaskInstrumentor().instrument_app(self.app,
tracer_provider=tracer_provider)
self._common_initialization()
def test_export_span_service_name(self):
resource = Resource.create({SERVICE_NAME: "test"})
span = trace._Span("test_span",
context=self.context,
resource=resource)
span.start()
span.end()
client_mock = mock.Mock()
exporter = JaegerExporter()
exporter._grpc_client = client_mock
exporter.export([span])
self.assertEqual(exporter.service_name, "test")
def __init__(
self,
stateful=True,
resource: Resource = Resource.create({}),
shutdown_on_exit: bool = True,
):
self.stateful = stateful
self.resource = resource
self._controllers = []
self._exporters = set()
self._atexit_handler = None
if shutdown_on_exit:
self._atexit_handler = atexit.register(self.shutdown)
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 __init__(
self,
resource: Resource = Resource.create(),
shutdown_on_exit: bool = True,
multi_log_processor: Union[SynchronousMultiLogProcessor,
ConcurrentMultiLogProcessor] = None,
):
self._resource = resource
self._multi_log_processor = (multi_log_processor
or SynchronousMultiLogProcessor())
self._at_exit_handler = None
if shutdown_on_exit:
self._at_exit_handler = atexit.register(self.shutdown)
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 setUp(self):
super().setUp()
resource = Resource.create({"service.name": "flask-api-no-app"})
result = self.create_tracer_provider(resource=resource)
tracer_provider, exporter = result
self.memory_exporter = exporter
FlaskInstrumentor().instrument(tracer_provider=tracer_provider)
# pylint: disable=import-outside-toplevel,reimported,redefined-outer-name
from flask import Flask
self.app = Flask(__name__)
self._common_initialization()
def test_export_span_service_name(self, mock_post):
mock_post.return_value = MockResponse(200)
resource = Resource.create({SERVICE_NAME: "test"})
context = trace.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
)
span = _Span("test_span", context=context, resource=resource)
span.start()
span.end()
exporter = ZipkinExporter()
exporter.export([span])
self.assertEqual(exporter.local_node.service_name, "test")
def _create_app_explicit_excluded_urls(self):
resource = Resource.create({"key1": "value1", "key2": "value2"})
tracer_provider, exporter = self.create_tracer_provider(
resource=resource)
self.memory_exporter = exporter
to_exclude = "/user/123,/foobar"
self._instrumentor.uninstrument(
) # Disable previous instrumentation (setUp)
self._instrumentor.instrument(
tracer_provider=tracer_provider,
excluded_urls=to_exclude,
)
return self._create_fastapi_app()
def __init__(
self,
resource: Resource = Resource.create({}),
shutdown_on_exit: bool = True,
):
self._resource = resource
self._atexit_handler = None
if shutdown_on_exit:
self._atexit_handler = register(self.shutdown)
self._metric_readers = []
self._metric_exporters = []
self._views = []
self._shutdown = False
def __init__(
self,
sampler: sampling.Sampler = sampling.DEFAULT_ON,
resource: Resource = Resource.create({}),
shutdown_on_exit: bool = True,
active_span_processor: Union[SynchronousMultiSpanProcessor,
ConcurrentMultiSpanProcessor] = None,
):
self._active_span_processor = (active_span_processor
or SynchronousMultiSpanProcessor())
self.resource = resource
self.sampler = sampler
self._atexit_handler = None
if shutdown_on_exit:
self._atexit_handler = atexit.register(self.shutdown)
def test_export(self):
channel = grpc.insecure_channel(self.address)
transport = metric_service_grpc_transport.MetricServiceGrpcTransport(
channel=channel
)
client = MagicMock(wraps=MetricServiceClient(transport=transport))
exporter = CloudMonitoringMetricsExporter(
self.project_id, client=client
)
meter_provider = metrics.MeterProvider(
resource=Resource.create(
{
"cloud.account.id": "some_account_id",
"cloud.provider": "gcp",
"cloud.zone": "us-east1-b",
"host.id": 654321,
"gcp.resource_type": "gce_instance",
}
)
)
meter = meter_provider.get_meter(__name__)
counter = meter.create_counter(
# TODO: remove "opentelemetry/" prefix which is a hack
# https://github.com/GoogleCloudPlatform/opentelemetry-operations-python/issues/84
name="opentelemetry/name",
description="desc",
unit="1",
value_type=int,
)
# interval doesn't matter, we don't start the thread and just run
# tick() instead
controller = PushController(meter, exporter, 10)
counter.add(10, {"env": "test"})
with patch(
"opentelemetry.exporter.cloud_monitoring.logger"
) as mock_logger:
controller.tick()
# run tox tests with `-- -log-cli-level=0` to see mock calls made
logger.debug(client.create_time_series.mock_calls)
mock_logger.warning.assert_not_called()
mock_logger.error.assert_not_called()
