def test_config_with_kwargs():
two = dict(three=3)
cfg = utils.Config(one=1, two=two)
assert cfg['one'] == 1
assert cfg.one == 1
assert cfg['two'] == two
assert cfg.two == two
cfg.one = 'one'
assert cfg['one'] == 'one'
assert cfg.one == 'one'
def test_empty_config():
cfg = utils.Config()
cfg.thing = 123
assert cfg['thing'] == 123
assert cfg.thing == 123
del cfg.thing
with pytest.raises(KeyError):
cfg['thing']
with pytest.raises(AttributeError):
cfg.thing
# Copyright (C) 2018 SignalFx, Inc. All rights reserved.
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
# Configures Requests tracing as described by
# https://github.com/signalfx/python-requests/blob/master/README.rst
config = utils.Config(
propagate=False,
span_tags=None,
tracer=None,
)
_session_new = [None]
_session_tracing_new = [None]
def session_new(_, __, *args, **kwargs):
"""Monkey patch Session.__new__() to create a SessionTracing object"""
from requests_opentracing import SessionTracing
return SessionTracing.__new__(SessionTracing)
def session_tracing_new(_, __, *args, **kwargs):
"""Monkey patch a valid SessionTracing.__new__() to avoid recursion on patched base class"""
from requests_opentracing import SessionTracing
return object.__new__(SessionTracing)
def instrument(tracer=None):
# Copyright (C) 2019 SignalFx, Inc. All rights reserved.
import opentracing
from signalfx_tracing import utils
# Configures Elasticsearch tracing as described by
# https://github.com/opentracing-contrib/python-elasticsearch/blob/master/README.rst
config = utils.Config(
prefix='Elasticsearch',
tracer=None,
)
_transport_new = [None]
_tracing_transport_new = [None]
def transport_new(_, __, *args, **kwargs):
"""Monkey patch Transport.__new__() to create a TracingTransport object"""
from elasticsearch_opentracing import TracingTransport
return TracingTransport.__new__(TracingTransport, *args, **kwargs)
def tracing_transport_new(_, __, *args, **kwargs):
"""Monkey patch a valid TracingTransport.__new__() to avoid recursion on patched base class"""
from elasticsearch_opentracing import TracingTransport
return object.__new__(TracingTransport)
def instrument(tracer=None):
"""
Elasticsearch auto-instrumentation works by hooking a __new__ proxy for a TracingTransport
# Copyright (C) 2018 SignalFx, Inc. All rights reserved.
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
# Configures Flask tracing as described by
# https://github.com/opentracing-contrib/python-flask/blob/master/README.rst
config = utils.Config(
trace_all=True,
traced_attributes=['path', 'method'],
tracer=None,
)
def instrument(tracer=None):
flask = utils.get_module('flask')
if utils.is_instrumented(flask):
return
flask_opentracing = utils.get_module('flask_opentracing')
def flask_tracer(__init__, app, args, kwargs):
"""
A function wrapper of flask.Flask.__init__ to create a corresponding
flask_opentracing.FlaskTracer upon app instantiation.
"""
__init__(*args, **kwargs)
_tracer = tracer or config.tracer or opentracing.tracer
import inspect
from wrapt import wrap_function_wrapper
from opentracing.ext import tags
import opentracing
from signalfx_tracing import utils
log = logging.getLogger(__name__)
# Configures Psycopg tracing as described by
# https://github.com/signalfx/python-dbapi/blob/master/README.rst
config = utils.Config(
traced_commands=[
'execute', 'executemany', 'callproc', 'commit', 'rollback'
],
span_tags=None,
tracer=None,
)
def instrument(tracer=None):
psycopg2 = utils.get_module('psycopg2')
if psycopg2 is None or utils.is_instrumented(psycopg2):
return
dbapi_opentracing = utils.get_module('dbapi_opentracing')
if dbapi_opentracing is None:
return
def psycopg2_tracer(connect, _, args, kwargs):
# Copyright (C) 2018 SignalFx, Inc. All rights reserved.
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
# Configures Redis tracing as described by
# https://github.com/opentracing-contrib/python-redis/blob/master/README.rst
config = utils.Config(
tracer=None,
)
def instrument(tracer=None):
redis = utils.get_module('redis')
if utils.is_instrumented(redis):
return
redis_opentracing = utils.get_module('redis_opentracing')
redis_opentracing.init_tracing(tracer=tracer or config.tracer or opentracing.tracer,
trace_all_classes=False)
def traced_client(__init__, client, args, kwargs):
__init__(*args, **kwargs)
redis_opentracing.trace_client(client)
wrap_function_wrapper('redis.client', 'StrictRedis.__init__', traced_client)
utils.mark_instrumented(redis)
# Copyright (C) 2018 SignalFx. All rights reserved.
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
# Configures Tornado tracing as described by
# https://github.com/opentracing-contrib/python-tornado/blob/master/README.rst
config = utils.Config(
trace_all=True,
trace_client=True,
traced_attributes=['path', 'method'],
start_span_cb=None,
tracer=None,
)
def instrument(tracer=None):
tornado = utils.get_module('tornado')
if utils.is_instrumented(tornado):
return
tornado_opentracing = utils.get_module('tornado_opentracing')
def _tracer_config(wrapped_tracer_config, _, wrapt_args, __):
"""
A function wrapper for tornado_opentracing's monkey patcher of tornado.web.Application.__init__()
used to inject tracer configuration as settings arguments. As a wrapt function wrapper of a
function_wrapper, _tracer_config's meaningful arguments are oddly nested.
"""
# Copyright (C) 2018 SignalFx, Inc. All rights reserved.
from signalfx_tracing import utils
# Configures Django tracing as described by
# https://github.com/opentracing-contrib/python-django/blob/master/README.rst
config = utils.Config(
trace_all=True,
traced_attributes=['path', 'method'],
tracer_callable=None,
tracer_parameters=None,
tracer=None,
set_global_tracer=False,
middleware_class='django_opentracing.OpenTracingMiddleware',
)
def get_middleware_and_setting_name():
"""
Returns the correct middleware list and the setting name for Django 1.10+ support:
https://docs.djangoproject.com/en/2.1/topics/http/middleware/#upgrading-pre-django-1-10-style-middleware
"""
# Deferred, explicit imports for supporting various environments and increasing testability
django = utils.get_module('django')
settings = utils.get_module('django.conf').settings
if hasattr(settings, 'MIDDLEWARE') and django.VERSION > (1, 10):
middleware = settings.MIDDLEWARE
if middleware is None:
middleware = []
return middleware, 'MIDDLEWARE'
return settings.MIDDLEWARE_CLASSES, 'MIDDLEWARE_CLASSES'
# Copyright (C) 2018 SignalFx. All rights reserved.
import os
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
from signalfx_tracing.constants import logging_format
config = utils.Config(injection_enabled=utils.is_truthy(
os.environ.get('SIGNALFX_LOGS_INJECTION', False)),
logging_format=os.environ.get('SIGNALFX_LOGGING_FORMAT',
logging_format))
def padded_hex(num):
return '{:016x}'.format(num)
def makeRecordPatched(makeRecord, instance, args, kwargs):
rv = makeRecord(*args, **kwargs)
span_id = ''
trace_id = ''
span = opentracing.tracer.active_span
if span is not None:
span_id = padded_hex(span.span_id)
trace_id = padded_hex(span.trace_id)
setattr(rv, 'sfxTraceId', span_id)
setattr(rv, 'sfxSpanId', trace_id)
return rv
# Copyright (C) 2018 SignalFx. All rights reserved.
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
# Configures PyMongo tracing as described by
# https://github.com/signalfx/python-pymongo/blob/master/README.rst
config = utils.Config(
span_tags=None,
tracer=None,
)
def instrument(tracer=None):
pymongo = utils.get_module('pymongo')
if utils.is_instrumented(pymongo):
return
pymongo_opentracing = utils.get_module('pymongo_opentracing')
def pymongo_tracer(__init__, app, args, kwargs):
"""
A function wrapper of pymongo.MongoClient.__init__ to register a corresponding
pymongo_opentracing.CommandTracing upon client instantiation.
"""
_tracer = tracer or config.tracer or opentracing.tracer
command_tracing = pymongo_opentracing.CommandTracing(
tracer=_tracer,
span_tags=config.span_tags or {},
# Copyright (C) 2020 SignalFx. All rights reserved.
from wrapt import wrap_function_wrapper
import opentracing
from signalfx_tracing import utils
from .middleware import TraceMiddleware
config = utils.Config(
tracer=None,
traced_attributes=['path'],
)
def instrument(tracer=None):
falcon = utils.get_module("falcon")
if utils.is_instrumented(falcon):
return
_tracer = tracer or config.tracer or opentracing.tracer
def traced_init(wrapped, instance, args, kwargs):
mw = kwargs.pop("middleware", [])
mw.insert(0, TraceMiddleware(_tracer, config.traced_attributes))
kwargs["middleware"] = mw
wrapped(*args, **kwargs)
wrap_function_wrapper("falcon", "API.__init__", traced_init)
utils.mark_instrumented(falcon)
