Skip to main content

OpenTracing API for Python. See documentation at http://opentracing.io

Project description

[![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/opentracing/public) [![Build Status](https://travis-ci.org/opentracing/opentracing-python.svg?branch=master)](https://travis-ci.org/opentracing/opentracing-python)

# OpenTracing API for Python

This library is a Python platform API for OpenTracing.

## Required Reading

In order to understand the Python platform API, one must first be familiar with
the [OpenTracing project](http://opentracing.io) and
[terminology](http://opentracing.io/spec/) more generally.

## Status

In the current version, `opentracing-python` provides only the API and a
basic no-op implementation that can be used by instrumentation libraries to
collect and propagate distributed tracing context.

Future versions will include a reference implementation utilizing an
abstract Recorder interface, as well as a
[Zipkin](http://openzipkin.github.io)-compatible Tracer.

## Usage

The work of instrumentation libraries generally consists of three steps:

1. When a service receives a new request (over HTTP or some other protocol),
it uses OpenTracing's Extractor API to join to an active trace, creating a Span
object in the process. If the request does not contain an active trace, the
service starts a new trace and a new *root* Span.
2. The service needs to store the current Span in some request-local storage,
where it can be retrieved from when a child Span must be created, e.g. in case
of the service making an RPC to another service.
3. When making outbound calls to another service, the current Span must be
retrieved from request-local storage, a child span must be created (e.g., by
using the `start_child_span()` helper), and that child span must be embedded
into the outbound request (e.g., using HTTP headers) via OpenTracing's Injector
API.

Below are the code examples for steps 1 and 3. Implementation of request-local
storage needed for step 2 is specific to the service and/or frameworks /
instrumentation libraries it is using (TODO: reference to other OSS projects
with examples of instrumentation).

### Inbound request

Somewhere in your server's request handler code:

```python

def handle_request(request):
span = before_request(request, opentracing.tracer)
# use span as Context Manager to ensure span.finish() will be called
with span:
# store span in some request-local storage
with RequestContext(span):
# actual business logic
handle_request_for_real(request)


def before_request(request, tracer):
text_carrier = opentracing.SplitTextCarrier(
request.headers, request.headers)
span = tracer.extractor(Format.SPLIT_TEXT).join_trace(
operation_name=request.operation,
carrier=text_carrier
)
if span is None:
span = tracer.start_span(operation_name=request.operation)
span.set_tag('http.url', request.full_url)

remote_ip = request.remote_ip
if remote_ip:
span.set_tag(tags.PEER_HOST_IPV4, remote_ip)

caller_name = request.caller_name
if caller_name:
span.set_tag(tags.PEER_SERVICE, caller_name)

remote_port = request.remote_port
if remote_port:
span.set_tag(tags.PEER_PORT, remote_port)

return span
```

### Outbound request

Somewhere in your service that's about to make an outgoing call:

```python

# create and serialize a child span and use it as context manager
with before_http_request(
request=out_request,
current_span_extractor=RequestContext.get_current_span):

# actual call
return urllib2.urlopen(request)


def before_http_request(request, current_span_extractor):
op = request.operation
parent_span = current_span_extractor()
outbound_span = opentracing.tracer.start_span(
operation_name=op,
parent=parent_span
)

outbound_span.set_tag('http.url', request.full_url)
service_name = request.service_name
host, port = request.host_port
if service_name:
outbound_span.set_tag(tags.PEER_SERVICE, service_name)
if host:
outbound_span.set_tag(tags.PEER_HOST_IPV4, host)
if port:
outbound_span.set_tag(tags.PEER_PORT, port)

text_carrier = opentracing.SplitTextCarrier()
opentracing.tracer.injector(Format.SPLIT_TEXT).inject(
span=outbound_span,
carrier=text_carrier
)
for key, value in text_carrier.tracer_state.iteritems():
request.add_header(key, value)
if text_carrier.baggage:
for key, value in text_carrier.baggage.iteritems():
request.add_header(key, value)

return outbound_span
```

# Development

## Tests

```
virtualenv env
source env/bin/activate
make bootstrap
make test
```

## Releases

Before new release, add a summary of changes since last version to CHANGELOG.rst

```
pip install zest.releaser[recommended]
prerelease
release
git push origin master --follow-tags
python setup.py sdist upload -r pypi
postrelease
git push
```

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

opentracing-1.0rc1.tar.gz (15.0 kB view details)

Uploaded Source

File details

Details for the file opentracing-1.0rc1.tar.gz.

File metadata

File hashes

Hashes for opentracing-1.0rc1.tar.gz
Algorithm Hash digest
SHA256 0dff2d22af7914f0808c6dfcbfdc3c1a1c3b0d5e0de6e1f9cfccdc1868ef6399
MD5 289187c818a773a2e02809629854765e
BLAKE2b-256 7be20665d5e1d1e3ff0920ea2369913c6be3e679f09e786ec92822212a9e9a71

See more details on using hashes here.

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page