def patch():
"""
Tracing function that patches the Tornado web application so that it will be
traced using the given ``tracer``.
"""
# patch only once
if getattr(tornado, '__datadog_patch', False):
return
setattr(tornado, '__datadog_patch', True)
# patch Application to initialize properly our settings and tracer
_w('tornado.web', 'Application.__init__', application.tracer_config)
# patch RequestHandler to trace all Tornado handlers
_w('tornado.web', 'RequestHandler._execute', handlers.execute)
_w('tornado.web', 'RequestHandler.on_finish', handlers.on_finish)
_w('tornado.web', 'RequestHandler.log_exception', handlers.log_exception)
# patch Template system
_w('tornado.template', 'Template.generate', template.generate)
# patch Python Futures if available when an Executor pool is used
compat.wrap_futures()
# configure the global tracer
ddtrace.tracer.configure(
context_provider=context_provider,
wrap_executor=decorators.wrap_executor,
)
def patch():
"""Enables Context Propagation between threads"""
if getattr(futures, '__datadog_patch', False):
return
setattr(futures, '__datadog_patch', True)
_w('concurrent.futures', 'ThreadPoolExecutor.submit', _wrap_submit)
def patch():
if getattr(sqlalchemy.engine, '__datadog_patch', False):
return
setattr(sqlalchemy.engine, '__datadog_patch', True)
# patch the engine creation function
_w('sqlalchemy', 'create_engine', _wrap_create_engine)
_w('sqlalchemy.engine', 'create_engine', _wrap_create_engine)
def _patch(elasticsearch):
if getattr(elasticsearch, '_datadog_patch', False):
return
setattr(elasticsearch, '_datadog_patch', True)
_w(elasticsearch.transport, 'Transport.perform_request',
_get_perform_request(elasticsearch))
Pin(service=metadata.SERVICE, app=metadata.APP,
app_type=AppTypes.db).onto(elasticsearch.transport.Transport)
def patch():
"""Instrument Celery base application and the `TaskRegistry` so
that any new registered task is automatically instrumented. In the
case of Django-Celery integration, also the `@shared_task` decorator
must be instrumented because Django doesn't use the Celery registry.
"""
setattr(celery, 'Celery', patch_app(celery.Celery))
_w('celery.app.registry', 'TaskRegistry.register', _wrap_register)
_w('celery', 'shared_task', _wrap_shared_task)
def patch():
"""Patches current loop `create_task()` method to enable spawned tasks to
parent to the base task context.
"""
if getattr(asyncio, '_datadog_patch', False):
return
setattr(asyncio, '_datadog_patch', True)
loop = asyncio.get_event_loop()
_w(loop, 'create_task', _wrapped_create_task)
def patch():
# patch only once
if getattr(MySQLdb, '__datadog_patch', False):
return
setattr(MySQLdb, '__datadog_patch', True)
_w('MySQLdb', 'Connect', _connect)
# `Connection` and `connect` are aliases for
# `Connect`; patch them too
if hasattr(MySQLdb, 'Connection'):
MySQLdb.Connection = MySQLdb.Connect
if hasattr(MySQLdb, 'connect'):
MySQLdb.connect = MySQLdb.Connect
def patch():
# patch only once
if getattr(MySQLdb, '__datadog_patch', False):
return
setattr(MySQLdb, '__datadog_patch', True)
_w('MySQLdb', 'Connect', _connect)
# `Connection` and `connect` are aliases for
# `Connect`; patch them too
if hasattr(MySQLdb, 'Connection'):
MySQLdb.Connection = MySQLdb.Connect
if hasattr(MySQLdb, 'connect'):
MySQLdb.connect = MySQLdb.Connect
def patch():
"""Patch the instrumented methods
"""
if getattr(molten, '_datadog_patch', False):
return
setattr(molten, '_datadog_patch', True)
pin = Pin(
service=config.molten['service_name'],
app=config.molten['app'],
app_type=config.molten['app_type'],
)
# add pin to module since many classes use __slots__
pin.onto(molten)
_w(molten.BaseApp, '__init__', patch_app_init)
_w(molten.App, '__call__', patch_app_call)
def patch():
"""Activate http calls tracing"""
if getattr(requests, '__datadog_patch', False):
return
setattr(requests, '__datadog_patch', True)
_w('requests', 'Session.request', _wrap_request)
Pin(
service=config.requests['service_name'],
_config=config.requests,
).onto(requests.Session)
# [Backward compatibility]: `session.distributed_tracing` should point and
# update the `Pin` configuration instead. This block adds a property so that
# old implementations work as expected
fn = property(_distributed_tracing)
fn = fn.setter(_distributed_tracing_setter)
requests.Session.distributed_tracing = fn
def patch():
"""Activate http calls tracing"""
if getattr(requests, '__datadog_patch', False):
return
setattr(requests, '__datadog_patch', True)
_w('requests', 'Session.request', _wrap_request)
Pin(
service=config.requests['service_name'],
app='requests',
app_type=AppTypes.web,
_config=config.requests,
).onto(requests.Session)
# [Backward compatibility]: `session.distributed_tracing` should point and
# update the `Pin` configuration instead. This block adds a property so that
# old implementations work as expected
fn = property(_distributed_tracing)
fn = fn.setter(_distributed_tracing_setter)
requests.Session.distributed_tracing = fn
def patch():
if getattr(jinja2, '__datadog_patch', False):
# already patched
return
setattr(jinja2, '__datadog_patch', True)
Pin(
service=config.jinja2['service_name'],
_config=config.jinja2,
).onto(jinja2.environment.Environment)
_w(jinja2, 'environment.Template.render', _wrap_render)
_w(jinja2, 'environment.Template.generate', _wrap_render)
_w(jinja2, 'environment.Environment.compile', _wrap_compile)
_w(jinja2, 'environment.Environment._load_template', _wrap_load_template)
def _instrument(self, **kwargs):
"""Instruments SQLAlchemy engine creation methods and the engine
if passed as an argument.
Args:
**kwargs: Optional arguments
``engine``: a SQLAlchemy engine instance
``tracer_provider``: a TracerProvider, defaults to global
Returns:
An instrumented engine if passed in as an argument, None otherwise.
"""
_w("sqlalchemy", "create_engine", _wrap_create_engine)
_w("sqlalchemy.engine", "create_engine", _wrap_create_engine)
if kwargs.get("engine") is not None:
return EngineTracer(
_get_tracer(kwargs.get("engine"),
kwargs.get("tracer_provider")),
kwargs.get("engine"),
)
return None
def _instrument(self, **kwargs):
"""Instruments SQLAlchemy engine creation methods and the engine
if passed as an argument.
Args:
**kwargs: Optional arguments
``engine``: a SQLAlchemy engine instance
``engines``: a list of SQLAlchemy engine instances
``tracer_provider``: a TracerProvider, defaults to global
Returns:
An instrumented engine if passed in as an argument or list of instrumented engines, None otherwise.
"""
tracer_provider = kwargs.get("tracer_provider")
_w("sqlalchemy", "create_engine", _wrap_create_engine(tracer_provider))
_w(
"sqlalchemy.engine",
"create_engine",
_wrap_create_engine(tracer_provider),
)
_w(
"sqlalchemy.engine.base",
"Engine.connect",
_wrap_connect(tracer_provider),
)
if parse_version(sqlalchemy.__version__).release >= (1, 4):
_w(
"sqlalchemy.ext.asyncio",
"create_async_engine",
_wrap_create_async_engine(tracer_provider),
)
if kwargs.get("engine") is not None:
return EngineTracer(
_get_tracer(tracer_provider),
kwargs.get("engine"),
kwargs.get("enable_commenter", False),
kwargs.get("commenter_options", {}),
)
if kwargs.get("engines") is not None and isinstance(
kwargs.get("engines"), Sequence):
return [
EngineTracer(
_get_tracer(tracer_provider),
engine,
kwargs.get("enable_commenter", False),
kwargs.get("commenter_options", {}),
) for engine in kwargs.get("engines")
]
return None
def _instrument(self, **kwargs):
"""Instruments SQLAlchemy engine creation methods and the engine
if passed as an argument.
Args:
**kwargs: Optional arguments
``engine``: a SQLAlchemy engine instance
``tracer_provider``: a TracerProvider, defaults to global
Returns:
An instrumented engine if passed in as an argument, None otherwise.
"""
tracer_provider = kwargs.get("tracer_provider")
_w("sqlalchemy", "create_engine", _wrap_create_engine(tracer_provider))
_w(
"sqlalchemy.engine",
"create_engine",
_wrap_create_engine(tracer_provider),
)
if parse_version(sqlalchemy.__version__).release >= (1, 4):
_w(
"sqlalchemy.ext.asyncio",
"create_async_engine",
_wrap_create_async_engine(tracer_provider),
)
if kwargs.get("engine") is not None:
return EngineTracer(
_get_tracer(kwargs.get("engine"), tracer_provider),
kwargs.get("engine"),
)
return None
def patch():
if getattr(mako, '__datadog_patch', False):
# already patched
return
setattr(mako, '__datadog_patch', True)
Pin(service='mako', app='mako', app_type=http.TEMPLATE).onto(Template)
_w(mako, 'template.Template.render', _wrap_render)
_w(mako, 'template.Template.render_unicode', _wrap_render)
_w(mako, 'template.Template.render_context', _wrap_render)
def patch():
"""
Tracing function that patches the Tornado web application so that it will be
traced using the given ``tracer``.
"""
# patch only once
if getattr(tornado, '__datadog_patch', False):
return
setattr(tornado, '__datadog_patch', True)
# patch Application to initialize properly our settings and tracer
_w('tornado.web', 'Application.__init__', application.tracer_config)
# patch RequestHandler to trace all Tornado handlers
_w('tornado.web', 'RequestHandler._execute', handlers.execute)
_w('tornado.web', 'RequestHandler.on_finish', handlers.on_finish)
_w('tornado.web', 'RequestHandler.log_exception', handlers.log_exception)
# patch Template system
_w('tornado.template', 'Template.generate', template.generate)
# patch Python Futures when an Executor pool is used
# TODO: this may be a generic module and should be moved
# in a separate contributions when we want to support multi-threading
# context propagation
if compat.futures_available:
_w('concurrent.futures', 'ThreadPoolExecutor.submit',
futures._wrap_submit)
# configure the global tracer
ddtrace.tracer.configure(
context_provider=context_provider,
wrap_executor=decorators.wrap_executor,
)
def patch():
"""
Patch `flask` module for tracing
"""
# Check to see if we have patched Flask yet or not
if getattr(flask, '_datadog_patch', False):
return
setattr(flask, '_datadog_patch', True)
# Attach service pin to `flask.app.Flask`
Pin(
service=config.flask['service_name'],
app=config.flask['app'],
app_type=config.flask['app_type'],
).onto(flask.Flask)
# flask.app.Flask methods that have custom tracing (add metadata, wrap functions, etc)
_w('flask', 'Flask.wsgi_app', traced_wsgi_app)
_w('flask', 'Flask.dispatch_request', request_tracer('dispatch_request'))
_w('flask', 'Flask.preprocess_request', request_tracer('preprocess_request'))
_w('flask', 'Flask.add_url_rule', traced_add_url_rule)
_w('flask', 'Flask.endpoint', traced_endpoint)
_w('flask', 'Flask._register_error_handler', traced_register_error_handler)
# flask.blueprints.Blueprint methods that have custom tracing (add metadata, wrap functions, etc)
_w('flask', 'Blueprint.register', traced_blueprint_register)
_w('flask', 'Blueprint.add_url_rule', traced_blueprint_add_url_rule)
# flask.app.Flask traced hook decorators
flask_hooks = [
'before_request',
'before_first_request',
'after_request',
'teardown_request',
'teardown_appcontext',
]
for hook in flask_hooks:
_w('flask', 'Flask.{}'.format(hook), traced_flask_hook)
_w('flask', 'after_this_request', traced_flask_hook)
# flask.app.Flask traced methods
flask_app_traces = [
'process_response',
'handle_exception',
'handle_http_exception',
'handle_user_exception',
'try_trigger_before_first_request_functions',
'do_teardown_request',
'do_teardown_appcontext',
'send_static_file',
]
for name in flask_app_traces:
_w('flask', 'Flask.{}'.format(name), simple_tracer('flask.{}'.format(name)))
# flask static file helpers
_w('flask', 'send_file', simple_tracer('flask.send_file'))
# flask.json.jsonify
_w('flask', 'jsonify', traced_jsonify)
# flask.templating traced functions
_w('flask.templating', '_render', traced_render)
_w('flask', 'render_template', traced_render_template)
_w('flask', 'render_template_string', traced_render_template_string)
# flask.blueprints.Blueprint traced hook decorators
bp_hooks = [
'after_app_request',
'after_request',
'before_app_first_request',
'before_app_request',
'before_request',
'teardown_request',
'teardown_app_request',
]
for hook in bp_hooks:
_w('flask', 'Blueprint.{}'.format(hook), traced_flask_hook)
# flask.signals signals
if config.flask['trace_signals']:
signals = [
'template_rendered',
'request_started',
'request_finished',
'request_tearing_down',
'got_request_exception',
'appcontext_tearing_down',
]
# These were added in 0.11.0
if flask_version >= (0, 11):
signals.append('before_render_template')
# These were added in 0.10.0
if flask_version >= (0, 10):
signals.append('appcontext_pushed')
signals.append('appcontext_popped')
signals.append('message_flashed')
for signal in signals:
module = 'flask'
# v0.9 missed importing `appcontext_tearing_down` in `flask/__init__.py`
# https://github.com/pallets/flask/blob/0.9/flask/__init__.py#L35-L37
# https://github.com/pallets/flask/blob/0.9/flask/signals.py#L52
# DEV: Version 0.9 doesn't have a patch version
if flask_version <= (0, 9) and signal == 'appcontext_tearing_down':
module = 'flask.signals'
# DEV: Patch `receivers_for` instead of `connect` to ensure we don't mess with `disconnect`
_w(module, '{}.receivers_for'.format(signal), traced_signal_receivers_for(signal))
import requests
from wrapt import wrap_function_wrapper as _w
from .connection import _wrap_send
class TracedSession(requests.Session):
"""TracedSession is a requests' Session that is already traced.
You can use it if you want a finer grained control for your
HTTP clients.
"""
pass
# always patch our `TracedSession` when imported
_w(TracedSession, 'send', _wrap_send)
def patch():
"""
Tracing function that patches the Tornado web application so that it will be
traced using the given ``tracer``.
"""
# patch only once
if getattr(tornado, '__datadog_patch', False):
return
setattr(tornado, '__datadog_patch', True)
# patch Application to initialize properly our settings and tracer
_w('tornado.web', 'Application.__init__', application.tracer_config)
# patch RequestHandler to trace all Tornado handlers
_w('tornado.web', 'RequestHandler._execute', handlers.execute)
_w('tornado.web', 'RequestHandler.on_finish', handlers.on_finish)
_w('tornado.web', 'RequestHandler.log_exception', handlers.log_exception)
# patch Tornado decorators
_w('tornado.concurrent', 'run_on_executor', decorators._run_on_executor)
# patch Template system
_w('tornado.template', 'Template.generate', template.generate)
# configure the global tracer
ddtrace.tracer.configure(
context_provider=TracerStackContext,
wrap_executor=decorators.wrap_executor,
)
import requests
from wrapt import wrap_function_wrapper as _w
from .connection import _wrap_request
class TracedSession(requests.Session):
"""TracedSession is a requests' Session that is already traced.
You can use it if you want a finer grained control for your
HTTP clients.
"""
pass
# always patch our `TracedSession` when imported
_w(TracedSession, 'request', _wrap_request)
