def test_otlp_headers_from_env(self, mock_ssl_channel, mock_secure):
exporter = OTLPSpanExporter()
# pylint: disable=protected-access
self.assertEqual(exporter._headers,
(("key1", "value1"), ("key2", "value2")))
exporter = OTLPSpanExporter(headers=(("key3", "value3"), ("key4",
"value4")))
# pylint: disable=protected-access
self.assertEqual(exporter._headers,
(("key3", "value3"), ("key4", "value4")))
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 get_tracer_with_processor(span_processor_class):
span_processor = span_processor_class(OTLPSpanExporter())
tracer = TracerProvider(
active_span_processor=span_processor,
sampler=sampling.DEFAULT_ON,
).get_tracer("pipeline_benchmark_tracer")
return tracer
def setUp(self):
tracer_provider = TracerProvider()
self.exporter = OTLPSpanExporter()
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("[::]:55678")
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": SpanKind.INTERNAL,
})
],
)
self.span.start()
self.span.end()
def configure_tracing(configuration: dict):
# OTLP Exporter configuration
if configuration['exporter'] == 'otlp':
service_name = {'service.name': configuration['service_name']}
resource = Resource(service_name)
trace.set_tracer_provider(TracerProvider(resource=resource))
exporter = OTLPSpanExporter(
endpoint=configuration['exporter_endpoint'],
insecure=configuration['exporter_insecure'])
trace.get_tracer(__name__)
span_processor = BatchExportSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# Jaeger HTTP Exporter configuration
elif configuration['exporter'] == 'jaeger_http':
exporter = JaegerSpanExporter(
service_name=configuration['service_name'],
collector_endpoint=configuration['exporter_endpoint'],
)
trace.set_tracer_provider(TracerProvider())
trace.get_tracer(__name__)
span_processor = BatchExportSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# Jaeger Thrifth Compact Exporter configuration
elif configuration['exporter'] == 'jaeger_thrift':
exporter = JaegerSpanExporter(
service_name=configuration['service_name'],
agent_host_name=configuration['exporter_host'],
agent_port=configuration['exporter_port'],
)
trace.set_tracer_provider(TracerProvider())
trace.get_tracer(__name__)
span_processor = BatchExportSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# Zipkin Exporter configuration
elif configuration['exporter'] == 'zipkin':
exporter = ZipkinSpanExporter(
service_name=configuration['service_name'],
url=configuration['exporter_endpoint'])
trace.set_tracer_provider(TracerProvider())
trace.get_tracer(__name__)
span_processor = BatchExportSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# Console Exporter configuration
elif configuration['exporter'] == 'console':
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter()))
else:
raise ValueError(
'Only Otlp, Jaeger Thrift/HTTP and Zipkin exporters are supported. '
'Please check your configuration.')
def test_env_variables(self, mock_exporter_mixin):
OTLPSpanExporter()
self.assertTrue(len(mock_exporter_mixin.call_args_list) == 1)
_, kwargs = mock_exporter_mixin.call_args_list[0]
self.assertEqual(kwargs["endpoint"], "collector:55680")
self.assertEqual(kwargs["headers"], "key1:value1;key2:value2")
self.assertEqual(kwargs["timeout"], 10)
self.assertIsNotNone(kwargs["credentials"])
self.assertIsInstance(kwargs["credentials"], ChannelCredentials)
def get_otlp_exporter():
if os.getenv("OTEL_EXPORTER_OTLP_INSECURE", False):
credentials = None
else:
credentials = grpc.ssl_channel_credentials()
return OTLPSpanExporter(
credentials=credentials,
headers=(("lightstep-access-token",
os.environ.get("LS_ACCESS_TOKEN")), ),
)
def test_no_credentials_error(self):
with self.assertRaises(ValueError):
OTLPSpanExporter()
)
console_exporter = os.environ.get("ADOT_DEBUG", None)
if not console_exporter is None:
from opentelemetry.sdk.trace.export import ConsoleSpanExporter
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter())
)
logger.info("Console exporter initialized.")
ci = os.environ.get("_ADOT_CI", None)
if ci is None:
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
otlp_exporter = OTLPSpanExporter(endpoint="localhost:55680", insecure=True)
span_processor = BatchExportSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
logger.info("Otlp exporter initialized.")
AwsLambdaInstrumentor().instrument()
# Load instrumentors from entry_points
for entry_point in iter_entry_points("opentelemetry_instrumentor"):
print(entry_point)
try:
entry_point.load()().instrument() # type: ignore
logger.debug("Instrumented %s", entry_point.name)
except Exception:
logger.debug("Instrumenting of %s failed", entry_point.name)
import json
from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
from kafka import KafkaConsumer
span_exporter = OTLPSpanExporter(insecure=True)
if __name__ == '__main__':
consumer = KafkaConsumer(bootstrap_servers='kafka:9092')
consumer.subscribe(['staff'])
for message in consumer:
print(message)
OpenCensusMetricsExporter, )
from opentelemetry.sdk.metrics import Counter, MeterProvider
from opentelemetry.sdk.metrics.export.controller import PushController
from flask import Flask, request
import requests
import os
resource = Resource({"service.name": "service1"})
trace.set_tracer_provider(TracerProvider(resource=resource))
tracer = trace.get_tracer(__name__)
OTEL_AGENT = os.getenv('OTEL_AGENT', "otel-agent")
otlp_exporter = OTLPSpanExporter(endpoint=OTEL_AGENT + ":4317", insecure=True)
span_processor = BatchExportSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
metric_exporter = OpenCensusMetricsExporter(
endpoint=OTEL_AGENT + ":55678",
service_name="service1",
)
# Meter is responsible for creating and recording metrics
metrics.set_meter_provider(MeterProvider(resource=resource))
meter = metrics.get_meter(__name__)
# controller collects metrics created from meter and exports it via the
# exporter every interval
controller = PushController(meter, metric_exporter, 5)
@app.route('/book/<username>')
def hello_world(username):
status = requests.post(os.getenv("BOOK_SVC"),
json={
"card":
"VISA",
"name":
username,
"date":
datetime.datetime.today().strftime('%Y-%m-%d')
})
if status.ok:
resp = status.json()
return resp
else:
return 'bad request!', 400
if __name__ == '__main__':
endpoint = "{}:{}".format(os.getenv("OTC_HOST"),
os.getenv("OTC_PORT", "55680"))
print('OTC Collector endpoint set to {}'.format(endpoint))
trace.set_tracer_provider(
TracerProvider(resource=Resource({"service.name": "api"})))
trace.get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(
OTLPSpanExporter(endpoint=endpoint, insecure=True)))
app.run(debug=True, host='0.0.0.0')
class TestOTLPSpanExporter(TestCase):
def setUp(self):
tracer_provider = TracerProvider()
self.exporter = OTLPSpanExporter()
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": SpanKind.INTERNAL,
}
)
],
)
self.span.start()
self.span.end()
def tearDown(self):
self.server.stop(None)
@patch("opentelemetry.exporter.otlp.exporter.expo")
@patch("opentelemetry.exporter.otlp.exporter.sleep")
def test_unavailable(self, mock_sleep, mock_expo):
mock_expo.configure_mock(**{"return_value": [1]})
add_TraceServiceServicer_to_server(
TraceServiceServicerUNAVAILABLE(), self.server
)
self.assertEqual(
self.exporter.export([self.span]), SpanExportResult.FAILURE
)
mock_sleep.assert_called_with(1)
@patch("opentelemetry.exporter.otlp.exporter.expo")
@patch("opentelemetry.exporter.otlp.exporter.sleep")
def test_unavailable_delay(self, mock_sleep, mock_expo):
mock_expo.configure_mock(**{"return_value": [1]})
add_TraceServiceServicer_to_server(
TraceServiceServicerUNAVAILABLEDelay(), self.server
)
self.assertEqual(
self.exporter.export([self.span]), SpanExportResult.FAILURE
)
mock_sleep.assert_called_with(4)
def test_success(self):
add_TraceServiceServicer_to_server(
TraceServiceServicerSUCCESS(), self.server
)
self.assertEqual(
self.exporter.export([self.span]), SpanExportResult.SUCCESS
)
def test_translate_spans(self):
expected = ExportTraceServiceRequest(
resource_spans=[
ResourceSpans(
resource=CollectorResource(
attributes=[
KeyValue(key="a", value=AnyValue(int_value=1)),
KeyValue(
key="b", value=AnyValue(bool_value=False)
),
]
),
instrumentation_library_spans=[
InstrumentationLibrarySpans(
spans=[
CollectorSpan(
# pylint: disable=no-member
name="a",
start_time_unix_nano=self.span.start_time,
end_time_unix_nano=self.span.end_time,
trace_state="a=b,c=d",
span_id=int.to_bytes(
10217189687419569865, 8, "big"
),
trace_id=int.to_bytes(
67545097771067222548457157018666467027,
16,
"big",
),
parent_span_id=(
b"\000\000\000\000\000\00009"
),
kind=CollectorSpan.SpanKind.INTERNAL,
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(bool_value=True),
),
],
events=[
CollectorSpan.Event(
name="a",
time_unix_nano=1591240820506462784,
attributes=[
KeyValue(
key="a",
value=AnyValue(
int_value=1
),
),
KeyValue(
key="b",
value=AnyValue(
bool_value=False
),
),
],
)
],
status=Status(code=0, message=""),
links=[
CollectorSpan.Link(
trace_id=int.to_bytes(
1, 16, "big"
),
span_id=int.to_bytes(2, 8, "big"),
attributes=[
KeyValue(
key="a",
value=AnyValue(
int_value=1
),
),
KeyValue(
key="b",
value=AnyValue(
bool_value=False
),
),
],
)
],
)
]
)
],
),
]
)
# pylint: disable=protected-access
self.assertEqual(expected, self.exporter._translate_data([self.span]))
class TestOTLPSpanExporter(TestCase):
def setUp(self):
tracer_provider = TracerProvider()
self.exporter = OTLPSpanExporter(insecure=True)
tracer_provider.add_span_processor(SimpleSpanProcessor(self.exporter))
self.tracer = tracer_provider.get_tracer(__name__)
self.server = server(ThreadPoolExecutor(max_workers=10))
self.server.add_insecure_port("[::]:4317")
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()
def tearDown(self):
self.server.stop(None)
@patch.dict(
"os.environ",
{
OTEL_EXPORTER_OTLP_SPAN_ENDPOINT: "collector:4317",
OTEL_EXPORTER_OTLP_SPAN_CERTIFICATE:
THIS_DIR + "/fixtures/test.cert",
OTEL_EXPORTER_OTLP_SPAN_HEADERS: "key1=value1,key2=value2",
OTEL_EXPORTER_OTLP_SPAN_TIMEOUT: "10",
},
)
@patch("opentelemetry.exporter.otlp.exporter.OTLPExporterMixin.__init__")
def test_env_variables(self, mock_exporter_mixin):
OTLPSpanExporter()
self.assertTrue(len(mock_exporter_mixin.call_args_list) == 1)
_, kwargs = mock_exporter_mixin.call_args_list[0]
self.assertEqual(kwargs["endpoint"], "collector:4317")
self.assertEqual(kwargs["headers"], "key1=value1,key2=value2")
self.assertEqual(kwargs["timeout"], 10)
self.assertIsNotNone(kwargs["credentials"])
self.assertIsInstance(kwargs["credentials"], ChannelCredentials)
@patch("opentelemetry.exporter.otlp.exporter.ssl_channel_credentials")
@patch("opentelemetry.exporter.otlp.exporter.secure_channel")
@patch("opentelemetry.exporter.otlp.trace_exporter.OTLPSpanExporter._stub")
# pylint: disable=unused-argument
def test_no_credentials_error(self, mock_ssl_channel, mock_secure,
mock_stub):
OTLPSpanExporter(insecure=False)
self.assertTrue(mock_ssl_channel.called)
@patch.dict(
"os.environ",
{OTEL_EXPORTER_OTLP_SPAN_HEADERS: "key1=value1,key2=value2"},
)
@patch("opentelemetry.exporter.otlp.exporter.ssl_channel_credentials")
@patch("opentelemetry.exporter.otlp.exporter.secure_channel")
# pylint: disable=unused-argument
def test_otlp_headers_from_env(self, mock_ssl_channel, mock_secure):
exporter = OTLPSpanExporter()
# pylint: disable=protected-access
self.assertEqual(exporter._headers,
(("key1", "value1"), ("key2", "value2")))
exporter = OTLPSpanExporter(headers=(("key3", "value3"), ("key4",
"value4")))
# pylint: disable=protected-access
self.assertEqual(exporter._headers,
(("key3", "value3"), ("key4", "value4")))
@patch("opentelemetry.exporter.otlp.exporter.ssl_channel_credentials")
@patch("opentelemetry.exporter.otlp.exporter.secure_channel")
# pylint: disable=unused-argument
def test_otlp_headers(self, mock_ssl_channel, mock_secure):
exporter = OTLPSpanExporter()
# pylint: disable=protected-access
self.assertIsNone(exporter._headers, None)
@patch("opentelemetry.exporter.otlp.exporter.expo")
@patch("opentelemetry.exporter.otlp.exporter.sleep")
def test_unavailable(self, mock_sleep, mock_expo):
mock_expo.configure_mock(**{"return_value": [1]})
add_TraceServiceServicer_to_server(TraceServiceServicerUNAVAILABLE(),
self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.FAILURE)
mock_sleep.assert_called_with(1)
@patch("opentelemetry.exporter.otlp.exporter.expo")
@patch("opentelemetry.exporter.otlp.exporter.sleep")
def test_unavailable_delay(self, mock_sleep, mock_expo):
mock_expo.configure_mock(**{"return_value": [1]})
add_TraceServiceServicer_to_server(
TraceServiceServicerUNAVAILABLEDelay(), self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.FAILURE)
mock_sleep.assert_called_with(4)
def test_success(self):
add_TraceServiceServicer_to_server(TraceServiceServicerSUCCESS(),
self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.SUCCESS)
def test_failure(self):
add_TraceServiceServicer_to_server(
TraceServiceServicerALREADY_EXISTS(), self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.FAILURE)
def test_translate_spans(self):
expected = ExportTraceServiceRequest(resource_spans=[
ResourceSpans(
resource=OTLPResource(attributes=[
KeyValue(key="a", value=AnyValue(int_value=1)),
KeyValue(key="b", value=AnyValue(bool_value=False)),
]),
instrumentation_library_spans=[
InstrumentationLibrarySpans(
instrumentation_library=InstrumentationLibrary(
name="name", version="version"),
spans=[
OTLPSpan(
# pylint: disable=no-member
name="a",
start_time_unix_nano=self.span.start_time,
end_time_unix_nano=self.span.end_time,
trace_state="a=b,c=d",
span_id=int.to_bytes(10217189687419569865, 8,
"big"),
trace_id=int.to_bytes(
67545097771067222548457157018666467027,
16,
"big",
),
parent_span_id=(b"\000\000\000\000\000\00009"),
kind=(OTLPSpan.SpanKind.SPAN_KIND_INTERNAL),
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(bool_value=True),
),
],
events=[
OTLPSpan.Event(
name="a",
time_unix_nano=1591240820506462784,
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(
bool_value=False),
),
],
)
],
status=Status(code=0, message=""),
links=[
OTLPSpan.Link(
trace_id=int.to_bytes(1, 16, "big"),
span_id=int.to_bytes(2, 8, "big"),
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(
bool_value=False),
),
],
)
],
)
],
)
],
),
])
# pylint: disable=protected-access
self.assertEqual(expected, self.exporter._translate_data([self.span]))
def _check_translated_status(
self,
translated: ExportTraceServiceRequest,
code_expected: Status,
deprecated_code_expected: Status,
):
status = (translated.resource_spans[0].
instrumentation_library_spans[0].spans[0].status)
self.assertEqual(
status.code,
code_expected,
)
self.assertEqual(
status.deprecated_code,
deprecated_code_expected,
)
def test_span_status_translate(self):
# pylint: disable=protected-access,no-member
unset = SDKStatus(status_code=SDKStatusCode.UNSET)
ok = SDKStatus(status_code=SDKStatusCode.OK)
error = SDKStatus(status_code=SDKStatusCode.ERROR)
unset_translated = self.exporter._translate_data(
[_create_span_with_status(unset)])
ok_translated = self.exporter._translate_data(
[_create_span_with_status(ok)])
error_translated = self.exporter._translate_data(
[_create_span_with_status(error)])
self._check_translated_status(
unset_translated,
Status.STATUS_CODE_UNSET,
Status.DEPRECATED_STATUS_CODE_OK,
)
self._check_translated_status(
ok_translated,
Status.STATUS_CODE_OK,
Status.DEPRECATED_STATUS_CODE_OK,
)
self._check_translated_status(
error_translated,
Status.STATUS_CODE_ERROR,
Status.DEPRECATED_STATUS_CODE_UNKNOWN_ERROR,
)
from opentelemetry.sdk.trace import TracerProvider, sampling
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
TEST_DURATION_SECONDS = 15
SPANS_PER_SECOND = 10_000
class MockTraceServiceStub(object):
def __init__(self, channel):
self.Export = lambda *args, **kwargs: None
old_stub = OTLPSpanExporter._stub
OTLPSpanExporter._stub = MockTraceServiceStub
simple_span_processor = BatchExportSpanProcessor(OTLPSpanExporter())
tracer = TracerProvider(
active_span_processor=simple_span_processor,
sampler=sampling.DEFAULT_ON,
).get_tracer("resource_usage_tracer")
starttime = time.time()
for _ in range(TEST_DURATION_SECONDS):
for _ in range(SPANS_PER_SECOND):
span = tracer.start_span("benchmarkedSpan")
span.end()
time_to_finish_spans = time.time() - starttime
time.sleep(1.0 - time_to_finish_spans if time_to_finish_spans < 1.0 else 0)
OTLPSpanExporter._stub = old_stub
from flask import jsonify, Flask, request
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider, Resource
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
app = Flask("reservations")
@app.route("/reserve", methods=["POST"])
def reserve():
return jsonify({"status": "reserved for {} {}".format(request.json['name'], request.json['date'])})
if __name__ == '__main__':
endpoint = "{}:{}".format(os.getenv("OTC_HOST"), os.getenv("OTC_PORT", "55680"))
print('OTC Collector endpoint set to {}'.format(endpoint))
trace.set_tracer_provider(TracerProvider(resource=Resource({"service.name": "reservations"})))
trace.get_tracer_provider().add_span_processor(BatchExportSpanProcessor(OTLPSpanExporter(endpoint=endpoint,
insecure=True)))
app.run(debug=True, host='0.0.0.0')
import time
import math
import random
from flask import Flask
import requests
from opentelemetry import trace
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
app = Flask(__name__)
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
otlp_exporter = OTLPSpanExporter(endpoint="otel-agent:55680")
span_processor = BatchExportSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
def wait_every_10s():
i = int(math.floor(random.uniform(0, 10)))
if i in [1, 2, 3]:
time.sleep(0.1)
class InvalidCredentials(Exception):
pass
# jaeger_exporter = jaeger.JaegerSpanExporter(
# service_name="my-multi-processors",
# agent_host_name="localhost",
# agent_port=6831,
# )
# trace.get_tracer_provider().add_span_processor(
# SimpleExportSpanProcessor(jaeger_exporter)
# )
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter())
)
# === otlp exporter, collector
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
otlp_exporter = OTLPSpanExporter(endpoint="localhost:55680")
span_processor = SimpleExportSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# === xray daemon exporter, xray daemon
# from opentelemetry.exporter.xraydaemon import XrayDaemonSpanExporter
# xrayDaemonSpanExporter = XrayDaemonSpanExporter()
# trace.get_tracer_provider().add_span_processor(
# SimpleExportSpanProcessor(xrayDaemonSpanExporter)
# )
tracer = trace.get_tracer(__name__)
# Customer's lambda function
def main():
class TestOTLPSpanExporter(TestCase):
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 tearDown(self):
self.server.stop(None)
Configuration._reset() # pylint: disable=protected-access
@patch.dict(
"os.environ",
{
"OTEL_EXPORTER_OTLP_SPAN_ENDPOINT": "collector:55680",
"OTEL_EXPORTER_OTLP_SPAN_CERTIFICATE":
THIS_DIR + "/fixtures/test.cert",
"OTEL_EXPORTER_OTLP_SPAN_HEADERS": "key1:value1;key2:value2",
"OTEL_EXPORTER_OTLP_SPAN_TIMEOUT": "10",
},
)
@patch("opentelemetry.exporter.otlp.exporter.OTLPExporterMixin.__init__")
def test_env_variables(self, mock_exporter_mixin):
OTLPSpanExporter()
self.assertTrue(len(mock_exporter_mixin.call_args_list) == 1)
_, kwargs = mock_exporter_mixin.call_args_list[0]
self.assertEqual(kwargs["endpoint"], "collector:55680")
self.assertEqual(kwargs["headers"], "key1:value1;key2:value2")
self.assertEqual(kwargs["timeout"], 10)
self.assertIsNotNone(kwargs["credentials"])
self.assertIsInstance(kwargs["credentials"], ChannelCredentials)
def test_no_credentials_error(self):
with self.assertRaises(ValueError):
OTLPSpanExporter()
@patch("opentelemetry.exporter.otlp.exporter.expo")
@patch("opentelemetry.exporter.otlp.exporter.sleep")
def test_unavailable(self, mock_sleep, mock_expo):
mock_expo.configure_mock(**{"return_value": [1]})
add_TraceServiceServicer_to_server(TraceServiceServicerUNAVAILABLE(),
self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.FAILURE)
mock_sleep.assert_called_with(1)
@patch("opentelemetry.exporter.otlp.exporter.expo")
@patch("opentelemetry.exporter.otlp.exporter.sleep")
def test_unavailable_delay(self, mock_sleep, mock_expo):
mock_expo.configure_mock(**{"return_value": [1]})
add_TraceServiceServicer_to_server(
TraceServiceServicerUNAVAILABLEDelay(), self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.FAILURE)
mock_sleep.assert_called_with(4)
def test_success(self):
add_TraceServiceServicer_to_server(TraceServiceServicerSUCCESS(),
self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.SUCCESS)
def test_failure(self):
add_TraceServiceServicer_to_server(
TraceServiceServicerALREADY_EXISTS(), self.server)
self.assertEqual(self.exporter.export([self.span]),
SpanExportResult.FAILURE)
def test_translate_spans(self):
expected = ExportTraceServiceRequest(resource_spans=[
ResourceSpans(
resource=OTLPResource(attributes=[
KeyValue(key="a", value=AnyValue(int_value=1)),
KeyValue(key="b", value=AnyValue(bool_value=False)),
]),
instrumentation_library_spans=[
InstrumentationLibrarySpans(
instrumentation_library=InstrumentationLibrary(
name="name", version="version"),
spans=[
OTLPSpan(
# pylint: disable=no-member
name="a",
start_time_unix_nano=self.span.start_time,
end_time_unix_nano=self.span.end_time,
trace_state="a=b,c=d",
span_id=int.to_bytes(10217189687419569865, 8,
"big"),
trace_id=int.to_bytes(
67545097771067222548457157018666467027,
16,
"big",
),
parent_span_id=(b"\000\000\000\000\000\00009"),
kind=(OTLPSpan.SpanKind.SPAN_KIND_INTERNAL),
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(bool_value=True),
),
],
events=[
OTLPSpan.Event(
name="a",
time_unix_nano=1591240820506462784,
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(
bool_value=False),
),
],
)
],
status=Status(code=0, message=""),
links=[
OTLPSpan.Link(
trace_id=int.to_bytes(1, 16, "big"),
span_id=int.to_bytes(2, 8, "big"),
attributes=[
KeyValue(
key="a",
value=AnyValue(int_value=1),
),
KeyValue(
key="b",
value=AnyValue(
bool_value=False),
),
],
)
],
)
],
)
],
),
])
# pylint: disable=protected-access
self.assertEqual(expected, self.exporter._translate_data([self.span]))
def test_no_credentials_error(
self, mock_ssl_channel, mock_secure, mock_stub
):
OTLPSpanExporter(insecure=False)
self.assertTrue(mock_ssl_channel.called)
"service.instance.id": str(id(app)),
"telemetry.sdk.name": "opentelemetry",
"telemetry.sdk.language": "python",
"telemetry.sdk.version": pkg_resources.get_distribution("opentelemetry-sdk").version,
"host.hostname": socket.gethostname(),
}
)
)
)
tracerProvider = trace.get_tracer_provider()
tracer = tracerProvider.get_tracer(__name__)
tracerProvider.add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter())
)
otlp_exporter = OTLPSpanExporter(endpoint="{}:55680".format(OTLP))
tracerProvider.add_span_processor(
SimpleExportSpanProcessor(otlp_exporter)
)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument(tracer_provider=tracerProvider)
@app.errorhandler(Error)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
@app.route("/update_order", methods=["POST", "PUT"])
def update_order():
# limitations under the License.
# otcollector.py
import time
from opentelemetry import metrics, trace
from opentelemetry.exporter.otlp.metrics_exporter import OTLPMetricsExporter
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export.controller import PushController
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
span_exporter = OTLPSpanExporter(
# optional
# endpoint:="myCollectorURL:55678",
# credentials=ChannelCredentials(credentials),
# metadata=(("metadata", "metadata")),
)
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
span_processor = BatchExportSpanProcessor(span_exporter)
tracer_provider.add_span_processor(span_processor)
metric_exporter = OTLPMetricsExporter(
# optional
# endpoint:="myCollectorURL:55678",
# credentials=ChannelCredentials(credentials),
# metadata=(("metadata", "metadata")),
)
# Meter is responsible for creating and recording metrics
import logging
from flask import Flask, request
from opentelemetry import propagators, trace
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor
logging.basicConfig(level=logging.DEBUG)
app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)
tracer_provider = TracerProvider(resource=Resource.create({"service.name": "backend"}))
tracer_provider.add_span_processor(
SimpleExportSpanProcessor(OTLPSpanExporter(endpoint="opentelemetry-collector:55680"))
)
trace.set_tracer_provider(tracer_provider)
@app.route("/backend")
def server_request():
return "served"
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8081)
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleExportSpanProcessor
from opentelemetry.trace.propagation.textmap import DictGetter
from opentelemetry.ext.honeycomb.sampling import DeterministicSampler
from grpc import ssl_channel_credentials
app = Flask(__name__)
sampler = DeterministicSampler(5)
trace.set_tracer_provider(TracerProvider(sampler=sampler))
tracer = trace.get_tracer_provider().get_tracer(__name__)
otlp_exporter = OTLPSpanExporter(
endpoint="api.honeycomb.io:443",
insecure=False,
credentials=ssl_channel_credentials(),
headers=(("x-honeycomb-team", os.environ.get("HONEYCOMB_WRITE_KEY")),
("x-honeycomb-dataset", os.environ.get("HONEYCOMB_DATASET"))))
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(ConsoleSpanExporter()))
trace.get_tracer_provider().add_span_processor(
SimpleExportSpanProcessor(otlp_exporter))
@app.route("/server_request")
def server_request():
with tracer.start_as_current_span(
"server_request",
context=propagators.extract(DictGetter(), request.headers),
kind=trace.SpanKind.SERVER,
from opentelemetry import trace, baggage
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
import os
service_name = os.getenv('DD_SERVICE')
otel_collector = os.getenv('OTEL_EXPORTER_OTLP_ENDPOINT')
app = Sanic(name=service_name)
resource = Resource.create({"service.name": service_name})
trace.set_tracer_provider(TracerProvider(resource=resource))
tracer = trace.get_tracer(__name__)
otlp_exporter = OTLPSpanExporter(endpoint=otel_collector, insecure=True)
span_processor = BatchExportSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
@app.route('/')
async def test(request):
with tracer.start_as_current_span("hello-world"):
return json({'hello': 'world'})
if __name__ == '__main__':
with tracer.start_as_current_span("start"):
print("Hello world!")
app.run(host='0.0.0.0', port=5000, auto_reload=True)
from opentelemetry import metrics
from opentelemetry.sdk.metrics.export import ConsoleMetricsExporter
from opentelemetry.exporter.otlp.metrics_exporter import OTLPMetricsExporter
app = Flask("api")
@app.route('/book/<username>')
def hello_world(username):
status = requests.post(os.getenv("BOOK_SVC"), json={
"card": "VISA",
"name": username,
"date": datetime.datetime.today().strftime('%Y-%m-%d')
})
if status.ok:
resp = status.json()
return resp
else:
return 'bad request!', 400
if __name__ == '__main__':
resource = Resource({"service.name": "gateway"})
trace.get_tracer_provider().resource = resource
trace.get_tracer_provider().add_span_processor(BatchExportSpanProcessor(OTLPSpanExporter(os.getenv("OTC_HOST"))))
metrics.get_meter_provider().resource = resource
metrics.get_meter_provider().start_pipeline(RequestsInstrumentor().meter, ConsoleMetricsExporter(), 1)
app.run(debug=True, host='0.0.0.0')
def test_otlp_headers(self, mock_ssl_channel, mock_secure):
exporter = OTLPSpanExporter()
# pylint: disable=protected-access
self.assertIsNone(exporter._headers, None)
# otcollector-agent-opencensus-metrics.py
import time
from opentelemetry import metrics, trace
from opentelemetry.exporter.otlp.metrics_exporter import OTLPMetricsExporter
from opentelemetry.exporter.otlp.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.metrics import Counter, MeterProvider
from opentelemetry.sdk.metrics.export.controller import PushController
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
# create a CollectorSpanExporter
span_exporter = OTLPSpanExporter(
# optional:
# endpoint="myCollectorUrl:55678",
# service_name="test_service",
# host_name="machine/container name",
)
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
span_processor = BatchExportSpanProcessor(span_exporter)
tracer_provider.add_span_processor(span_processor)
# create a CollectorMetricsExporter
metric_exporter = OTLPMetricsExporter(
# optional:
# endpoint="myCollectorUrl:55678",
# service_name="test_service",
# host_name="machine/container name",
)
async def fetch(session: aiohttp.ClientSession, url, payload):
async with session.post(url, data=payload) as resp:
return await resp.json()
async def make_booking(request):
async with aiohttp.ClientSession() as session:
results = await asyncio.gather(
fetch(session,
os.getenv("PAY_SVC"),
payload={"card": request.json["card"]}),
fetch(session,
os.getenv("RSV_SVC"),
payload={
"date": request.json["date"],
"name": request.json["name"]
}))
print(results)
return web.Response(body="success!", status=200)
app = web.Application()
app.add_routes([web.get('/booking', make_booking)])
if __name__ == '__main__':
trace.set_tracer_provider(
TracerProvider(resource=Resource({"service.name": "booking"})))
trace.get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(OTLPSpanExporter(os.getenv("OTC_HOST"))))
web.run_app(app, port=5000)
from opentelemetry.sdk.trace import TracerProvider, sampling
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
TEST_DURATION_SECONDS = 15
SPANS_PER_SECOND = 10_000
class MockTraceServiceStub(object):
def __init__(self, channel):
self.Export = lambda *args, **kwargs: None
old_stub = OTLPSpanExporter._stub
OTLPSpanExporter._stub = MockTraceServiceStub
simple_span_processor = SimpleSpanProcessor(OTLPSpanExporter())
tracer = TracerProvider(
active_span_processor=simple_span_processor,
sampler=sampling.DEFAULT_ON,
).get_tracer("resource_usage_tracer")
starttime = time.time()
for _ in range(TEST_DURATION_SECONDS):
for _ in range(SPANS_PER_SECOND):
span = tracer.start_span("benchmarkedSpan")
span.end()
time_to_finish_spans = time.time() - starttime
time.sleep(1.0 - time_to_finish_spans if time_to_finish_spans < 1.0 else 0)
OTLPSpanExporter._stub = old_stub
