OT Bridge - Initial implementation #6

Add missing stubs for fully implementing the Span and Scope classes from OpenTracing.

- Explicitly use opentracing.* to make OpenTracing imports easily distinguishable. - Leave OpenTelemetry class names as-is.

Since start_span() is a context manager and since we want the OpenTelemetry Span to stop when the SpanWrapper stops, we need to turn start_active_span() into a context manager and yield the ScopeWrapper rather than return it.

Move type test to a separate method because it's not related to start_active_span().

The inject() and extract() methods on opentracing.Tracer have an argument called "format", which clashes with a Python builtin. We can't rename the argument in the subclass without generating W0221.

Verify the `parent` field of the child span is set to the parent span object.

We can't return an OTel object to the consumer of the OT API.

Since the OpenTelemetry API expects an event name and the OpenTracing API doesn't provide this information, we use a helper function to derive an event name from the key-value pairs passed to the `log_kv()` method. The helper function is adapted from the Java OpenTracing bridge implementation: https://github.com/open-telemetry/opentelemetry-java/blob/2379965a97c306f160de510d47daaaa77ef32550/opentracing_shim/src/main/java/io/opentelemetry/opentracingshim/SpanShim.java#L152

`__enter__()` and `__exit__()` on `SpanWrapper` aren't needed because the same methods on the base class `opentracing.Span` do what we need them to do when `SpanWrapper` is used as a context manager. `__enter__()` and `__exit__()` on `ScopeWrapper` aren't needed because we use the `@contextmanager` decorator on `start_active_span(). When the `with start_active_span()` block ends, the `with` block in the *implementation* of `start_active_span()` ends as well, which in turn makes the `with` block in OpenTelemetry's `start_span()` end, which makes the `finally` block in `use_span()` run, which calls `end()` on the OpenTelemetry span.

We shouldn't return an OpenTelemetry object to OpenTracing API calls.

According to the OpenTracing API, `child_of` can only be of type `Span` or `SpanContext`. In the shim these are represented as `SpanWrapper` and `SpanContextWrapper`, respectively. In case we receive a different type in `child_of`, it's safer to bail out than to try to set an unexpected object as the span's parent.

- Reorder tests. - Replace `otel_*` properties with `unwrap()` method. - Use correct type in `tracer` argument of `ScopeManagerWrapper`.

Use a `with` statement to finish spans automatically where possible, i.e. when not testing things which require explicit calling to `span.finish()`.

We have many methods because we have many tests.

Handle time format differences between OpenTracing and OpenTelemetry. OpenTracing expects time values in seconds since the epoch represented as floats. OpenTelemetry expects time values in nanoseconds since the epoch represented as ints.

Return `self` from all "setter" methods on `SpanWrapper` to allow call chaining.

It seems we cannot consistently use Python type hints in the OpenTracing shim since we rely on the `opentracing` library which doesn't contain type hints, nor does it have PEP 561 compliant stub packages or a module on typeshed. Rather than including partial typing information it's better not to include typing information at all.

In some cases we had duplicated logic from the base class' `__init__` method. In others we had overridden methods with the same logic as the equivalent methods in the base class. We clean up the above and add comments to help understand some of the inheritance-related choices.

Due to the differences between decimal and binary float representations, some time values yield "surprising" results when performing float arithmetic operations to convert seconds to nanoseconds and vice versa.

"ot" isn't clear enough and could lead to confusion.

If the user passes a custom ScopeManager, we want the TracerWrapper to call `active_span` on the custom ScopeManager.

Log a warning instead in order not to break application code.

Let the OTel implementation create event timestamps instead of generating a timestamp in the shim, i.e. outside of OpenTelemetry.

- Remove an unnecessary context manager layers. - Allow creating `ContextWrapper` objects either from a `SpanWrapper` or from a `Span` context manager.

Until we figure out how to handle unsupported frameworks (e.g. gevent), we remove the `scope_manager` argument of `create_tracer` to avoid breaking the OpenTelemetry context propagation.

These are obvious and therefore unnecessary.

The API docs are clear about the `references` argument being a list. We don't try to compensate for wrong argument types elsewhere, so no reason to do that here.

Not all classes in the shim are actually wrappers, which makes the XWrapper naming convention confusing. XShim is more neutral.

In the OpenTracing API, when an exception occurs while a span is active, information about the exception is added to the span as logs and a tag is added as well. We re-add this functionality to the shim since we've overridden the `__exit__()` method in which it lives.

Validating the parent type complicates the logic of `start_span()`. Since the OpenTracing API clearly specifies the valid types for a parent span, it's the user's responsibility to specify a valid parent.

Verify that calling `close()` on a `ScopeShim` deactivates the span in the OpenTelemetry tracer.

We shouldn't return OpenTelemetry objects to the OpenTracing API.

Make it clearer that the provided tracer object should be an OpenTelemetry tracer, not an OpenTracing tracer.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

OT Bridge - Initial implementation #6

OT Bridge - Initial implementation #6

Commits on Oct 23, 2019