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(): """ 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(): """Enable tracing for all urllib3 requests""" if getattr(urllib3, "__datadog_patch", False): return setattr(urllib3, "__datadog_patch", True) _w("urllib3", "connectionpool.HTTPConnectionPool.urlopen", _wrap_urlopen)
def patch(): """Patch the instrumented methods. """ if getattr(sanic, "__datadog_patch", False): return setattr(sanic, "__datadog_patch", True) _w("sanic", "Sanic.handle_request", patch_handle_request)
def patch(): if getattr(starlette, "_datadog_patch", False): return setattr(starlette, "_datadog_patch", True) _w("starlette.applications", "Starlette.__init__", traced_init)
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().onto(elasticsearch.transport.Transport)
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(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).onto(elasticsearch.transport.Transport)
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(): if getattr(fastapi, "_datadog_patch", False): return setattr(fastapi, "_datadog_patch", True) Pin().onto(fastapi) _w("fastapi.applications", "FastAPI.__init__", traced_init) _w("fastapi.routing", "serialize_response", traced_serialize_response)
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(): """Activate http calls tracing""" if getattr(requests, "__datadog_patch", False): return setattr(requests, "__datadog_patch", True) _w("requests", "Session.send", _wrap_send) Pin(_config=config.requests).onto(requests.Session)
def _patch_server(): if getattr(constants.GRPC_PIN_MODULE_SERVER, '__datadog_patch', False): return setattr(constants.GRPC_PIN_MODULE_SERVER, '__datadog_patch', True) Pin(service=config.grpc_server.service_name).onto(constants.GRPC_PIN_MODULE_SERVER) _w('grpc', 'server', _server_constructor_interceptor)
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_server(): if getattr(constants.GRPC_PIN_MODULE_SERVER, "__datadog_patch", False): return setattr(constants.GRPC_PIN_MODULE_SERVER, "__datadog_patch", True) Pin().onto(constants.GRPC_PIN_MODULE_SERVER) _w("grpc", "server", _server_constructor_interceptor)
def _patch_client(): if getattr(constants.GRPC_PIN_MODULE_CLIENT, '__datadog_patch', False): return setattr(constants.GRPC_PIN_MODULE_CLIENT, '__datadog_patch', True) Pin(service=config.grpc.service_name).onto( constants.GRPC_PIN_MODULE_CLIENT) _w('grpc', 'insecure_channel', _client_channel_interceptor) _w('grpc', 'secure_channel', _client_channel_interceptor)
def patch(): if getattr(consul, '__datadog_patch', False): return setattr(consul, '__datadog_patch', True) pin = Pin(service='consul', app='consul', app_type=AppTypes.cache) pin.onto(consul.Consul.KV) for f_name in _KV_FUNCS: _w('consul', f_name, wrap_function(f_name))
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_pymongo_module(): if getattr(pymongo, "_datadog_patch", False): return setattr(pymongo, "_datadog_patch", True) Pin(app=mongox.SERVICE).onto(pymongo.server.Server) # Whenever a pymongo command is invoked, the lib either: # - Creates a new socket & performs a TCP handshake # - Grabs a socket already initialized before _w("pymongo.server", "Server.get_socket", traced_get_socket)
def patch(): if getattr(consul, "__datadog_patch", False): return setattr(consul, "__datadog_patch", True) pin = Pin(service=consulx.SERVICE) pin.onto(consul.Consul.KV) for f_name in _KV_FUNCS: _w("consul", "Consul.KV.%s" % f_name, wrap_function(f_name))
def patch(): if getattr(consul, '__datadog_patch', False): return setattr(consul, '__datadog_patch', True) pin = Pin(service=consulx.SERVICE, app=consulx.APP) pin.onto(consul.Consul.KV) for f_name in _KV_FUNCS: _w('consul', 'Consul.KV.%s' % f_name, wrap_function(f_name))
def patch(): # type: () -> None if getattr(httpx, "_datadog_patch", False): return setattr(httpx, "_datadog_patch", True) _w(httpx.AsyncClient, "send", _wrapped_async_send) _w(httpx.Client, "send", _wrapped_sync_send) pin = Pin() pin.onto(httpx.AsyncClient) pin.onto(httpx.Client)
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() if CONTEXTVARS_IS_AVAILABLE: _w(loop, 'create_task', wrapped_create_task_contextvars) else: _w(loop, 'create_task', wrapped_create_task)
def patch(): """Patch the instrumented methods""" if getattr(molten, "_datadog_patch", False): return setattr(molten, "_datadog_patch", True) pin = Pin(app=config.molten["app"]) # 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(): """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']) # 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.send", _wrap_send) Pin(app="requests", _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(): """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) if sys.version_info < (3, 7, 0): _w(asyncio.BaseEventLoop, "create_task", wrapped_create_task) # also patch event loop if not inheriting the wrapped create_task from BaseEventLoop loop = asyncio.get_event_loop() if not isinstance(loop.create_task, ObjectProxy): _w(loop, "create_task", wrapped_create_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) wrapper = wrapped_create_task_contextvars if CONTEXTVARS_IS_AVAILABLE else wrapped_create_task _w(asyncio.BaseEventLoop, "create_task", wrapper) # also patch event loop if not inheriting the wrapped create_task from BaseEventLoop loop = asyncio.get_event_loop() if not isinstance(loop.create_task, ObjectProxy): _w(loop, "create_task", wrapper)
def trace_rendering(): """Patch all Pylons renderers. It supports multiple versions of Pylons and multiple renderers. """ # patch only once if getattr(pylons.templating, "__datadog_patch", False): return setattr(pylons.templating, "__datadog_patch", True) if legacy_pylons: # Pylons <= 0.9.7 _w("pylons.templating", "render", _traced_renderer) else: # Pylons > 0.9.7 _w("pylons.templating", "render_mako", _traced_renderer) _w("pylons.templating", "render_mako_def", _traced_renderer) _w("pylons.templating", "render_genshi", _traced_renderer) _w("pylons.templating", "render_jinja2", _traced_renderer)
def trace_rendering(): """Patch all Pylons renderers. It supports multiple versions of Pylons and multiple renderers. """ # patch only once if getattr(pylons.templating, '__datadog_patch', False): return setattr(pylons.templating, '__datadog_patch', True) if legacy_pylons: # Pylons <= 0.9.7 _w('pylons.templating', 'render', _traced_renderer) else: # Pylons > 0.9.7 _w('pylons.templating', 'render_mako', _traced_renderer) _w('pylons.templating', 'render_mako_def', _traced_renderer) _w('pylons.templating', 'render_genshi', _traced_renderer) _w('pylons.templating', 'render_jinja2', _traced_renderer)