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)