def test_constructor_by_environment_variables(self):
"""Test using Environment Variables."""
# pylint: disable=protected-access
Configuration._reset()
service = "my-opentelemetry-jaeger"
collector_endpoint = "localhost:14250"
env_patch = patch.dict(
"os.environ",
{
"OTEL_EXPORTER_JAEGER_ENDPOINT": collector_endpoint,
"OTEL_EXPORTER_JAEGER_CERTIFICATE": os.path.dirname(__file__)
+ "/certs/cred.cert",
},
)
env_patch.start()
exporter = JaegerSpanExporter(
service_name=service, transport_format="protobuf"
)
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 setUp(self): # pylint: disable=arguments-differ
self.exporter = OTLPMetricsExporter(insecure=True)
self.resource = SDKResource(OrderedDict([("a", 1), ("b", False)]))
self.meter = MeterProvider(resource=self.resource,).get_meter(
"name", "version"
)
Configuration._reset() # pylint: disable=protected-access
def setUp(self):
super().setUp()
setup_test_environment()
_django_instrumentor.instrument()
Configuration._reset() # pylint: disable=protected-access
self.env_patch = patch.dict(
"os.environ",
{
"OTEL_PYTHON_DJANGO_EXCLUDED_URLS":
"http://testserver/excluded_arg/123,excluded_noarg",
"OTEL_PYTHON_DJANGO_TRACED_REQUEST_ATTRS":
"path_info,content_type,non_existing_variable",
},
)
self.env_patch.start()
self.exclude_patch = patch(
"opentelemetry.instrumentation.django.middleware._DjangoMiddleware._excluded_urls",
Configuration()._excluded_urls("django"),
)
self.traced_patch = patch(
"opentelemetry.instrumentation.django.middleware._DjangoMiddleware._traced_request_attrs",
Configuration()._traced_request_attrs("django"),
)
self.exclude_patch.start()
self.traced_patch.start()
def test_non_default_propagators(self, mock_iter_entry_points,
mock_compositehttppropagator):
Configuration._reset()
def iter_entry_points_mock(_, propagator):
return iter([
Mock(**{
"load.side_effect":
[Mock(**{"side_effect": [propagator]})]
})
])
mock_iter_entry_points.configure_mock(
**{"side_effect": iter_entry_points_mock})
def test_propagators(propagators):
self.assertEqual(propagators, ["a", "b", "c"])
mock_compositehttppropagator.configure_mock(
**{"side_effect": test_propagators})
import opentelemetry.propagators
reload(opentelemetry.propagators)
def test_trace_init_custom_ids_generator(self, mock_iter_entry_points):
mock_iter_entry_points.configure_mock(return_value=[
IterEntryPoint("custom_ids_generator", CustomIdsGenerator)
])
Configuration._reset()
ids_generator_name = _get_ids_generator()
ids_generator = _import_ids_generator(ids_generator_name)
_init_tracing({}, ids_generator)
provider = self.set_provider_mock.call_args[0][0]
self.assertIsInstance(provider.ids_generator, CustomIdsGenerator)
def setUp(self):
tracer_provider = TracerProvider()
self.exporter = OTLPSpanExporter(insecure=True)
tracer_provider.add_span_processor(
SimpleExportSpanProcessor(self.exporter)
)
self.tracer = tracer_provider.get_tracer(__name__)
self.server = server(ThreadPoolExecutor(max_workers=10))
self.server.add_insecure_port("[::]:55680")
self.server.start()
event_mock = Mock(
**{
"timestamp": 1591240820506462784,
"attributes": OrderedDict([("a", 1), ("b", False)]),
}
)
type(event_mock).name = PropertyMock(return_value="a")
self.span = _Span(
"a",
context=Mock(
**{
"trace_state": OrderedDict([("a", "b"), ("c", "d")]),
"span_id": 10217189687419569865,
"trace_id": 67545097771067222548457157018666467027,
}
),
resource=SDKResource(OrderedDict([("a", 1), ("b", False)])),
parent=Mock(**{"span_id": 12345}),
attributes=OrderedDict([("a", 1), ("b", True)]),
events=[event_mock],
links=[
Mock(
**{
"context.trace_id": 1,
"context.span_id": 2,
"attributes": OrderedDict([("a", 1), ("b", False)]),
"kind": OTLPSpan.SpanKind.SPAN_KIND_INTERNAL, # pylint: disable=no-member
}
)
],
instrumentation_info=InstrumentationInfo(
name="name", version="version"
),
)
self.span.start()
self.span.end()
Configuration._reset() # pylint: disable=protected-access
def setUp(self):
# create and save span to be used in tests
context = trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
)
self._test_span = trace._Span("test_span", context=context)
self._test_span.start()
self._test_span.end()
# pylint: disable=protected-access
Configuration._reset()
def test_trace_init_default(self):
environ["OTEL_SERVICE_NAME"] = "my-test-service"
Configuration._reset()
_init_tracing({"zipkin": Exporter}, RandomIdsGenerator)
self.assertEqual(self.set_provider_mock.call_count, 1)
provider = self.set_provider_mock.call_args[0][0]
self.assertIsInstance(provider, Provider)
self.assertIsInstance(provider.ids_generator, RandomIdsGenerator)
self.assertIsInstance(provider.processor, Processor)
self.assertIsInstance(provider.processor.exporter, Exporter)
self.assertEqual(provider.processor.exporter.service_name,
"my-test-service")
def test_reset(self) -> None:
environ_patcher = patch.dict(
"os.environ",
{"OPENTELEMETRY_PYTHON_TRACER_PROVIDER": "tracer_provider"},
)
environ_patcher.start()
self.assertEqual(Configuration().TRACER_PROVIDER, "tracer_provider") # pylint: disable=no-member
environ_patcher.stop()
Configuration._reset()
self.assertIsNone(Configuration().TRACER_PROVIDER) # pylint: disable=no-member
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_trace_init_otlp(self):
environ["OTEL_SERVICE_NAME"] = "my-otlp-test-service"
Configuration._reset()
_init_tracing({"otlp": OTLPExporter}, RandomIdsGenerator)
self.assertEqual(self.set_provider_mock.call_count, 1)
provider = self.set_provider_mock.call_args[0][0]
self.assertIsInstance(provider, Provider)
self.assertIsInstance(provider.ids_generator, RandomIdsGenerator)
self.assertIsInstance(provider.processor, Processor)
self.assertIsInstance(provider.processor.exporter, OTLPExporter)
self.assertIsInstance(provider.resource, Resource)
self.assertEqual(
provider.resource.attributes.get("service.name"),
"my-otlp-test-service",
)
del environ["OTEL_SERVICE_NAME"]
def setUp(self):
self.exporter = OTLPMetricsExporter(insecure=True)
resource = SDKResource(OrderedDict([("a", 1), ("b", False)]))
self.counter_metric_record = MetricRecord(
Counter(
"c",
"d",
"e",
int,
MeterProvider(resource=resource, ).get_meter(__name__),
("f", ),
),
[("g", "h")],
SumAggregator(),
resource,
)
Configuration._reset() # pylint: disable=protected-access
def tearDown(self):
# pylint: disable=protected-access
Configuration._reset()
def tearDown(self):
# reset global state of configuration object
# pylint: disable=protected-access
Configuration._reset()
def tearDown(self):
self.server.stop(None)
Configuration._reset() # pylint: disable=protected-access
def setUp(self):
super().setUp()
setup_test_environment()
_django_instrumentor.instrument()
Configuration._reset() # pylint: disable=protected-access
def setUp(self) -> None:
Configuration._reset()
def setUp(self): # pylint: disable=invalid-name
super().setUp() # pylint: disable=no-member
Configuration._reset() # pylint: disable=protected-access
def tearDown(self) -> None:
# This call resets the attributes of the Configuration class so that
# each test is executed in the same conditions.
Configuration._reset()
