What it does

Adds a wrap_executor callback to the Tracer.configure() method, so that a contrib module can change the behavior of Tracer.wrap(). This is required because in some frameworks (i.e. Tornado), the Tracer.wrap() must handle "coroutine" executions that returns immediately a Future instance. On the other hand, we can't pollute the Tracer.wrap() with contrib code and PR goals are:

• if a wrap_executor is not defined, the Tracer.wrap() behaves as usual for regular functions or asyncio coroutines
• if a wrap_executor is defined, decorated functions are handled using this callable

Usage

from ddtrace import tracer

# this is the default signature
def wrap_executor(tracer, fn, args, kwargs, span_name, service, resource, span_type):
    with tracer.trace(span_name, service=service, resource=resource, span_type=span_type):
        # do something before
        result = fn(*args, **kwargs)
        # do something after
        return result

# enable the custom decorator handler
tracer.configure(wrap_executor=wrap_executor)

Integration example

Look at the Tornado integration and usage.

Limitation

The wrap_executor is executed each time the decorator is called. We can't use a wrap_factory that returns a new decorator because it could be too late. Indeed, users can decorate their functions before calling the tracer.configure() method. This may add a little overhead (order of nanoseconds) because the following is always evaluated for each call:

if getattr(self, '_wrap_executor', None):
    # _wrap_executor call