def initialize_tracer(service_name,
async_transport=False,
host=None,
port=0,
sample_rate=1.0):
if sample_rate == 1.0:
# sample all traces
sampler_config = {'type': 'const', 'param': 1}
elif sample_rate == 0.0:
# sample none traces
sampler_config = {'type': 'const', 'param': 0}
else:
# random sampling decision with the probability
sampler_config = {'type': 'probabilistic', 'param': sample_rate}
tracer_config = {
'sampler': sampler_config,
}
if host:
tracer_config['local_agent'] = {
'reporting_host': host,
'reporting_port': port
}
config = Config(
config=tracer_config,
service_name=service_name,
validate=True,
scope_manager=AsyncioScopeManager() if async_transport else None,
)
return config.new_tracer()
def test_tracer_context_provider_config(self):
tracer = ddtrace.opentracer.Tracer("mysvc",
scope_manager=AsyncioScopeManager())
assert isinstance(
tracer._dd_tracer.context_provider,
ddtrace.contrib.asyncio.provider.AsyncioContextProvider,
)
def ot_tracer(ot_tracer_factory):
return ot_tracer_factory(
"asyncio_svc",
config={},
scope_manager=AsyncioScopeManager(),
context_provider=ddtrace.contrib.asyncio.context_provider,
)
def setup_opentracing(app):
"""
Helper function to setup opentracing with Jaeger client during setup.
Use during app startup as follows:
.. code-block:: python
app = FastAPI()
@app.on_event('startup')
async def startup():
setup_opentracing(app)
:param app: app object, instance of FastAPI
:return: None
"""
config = Config(config={
"local_agent": {
"reporting_host": settings.jaeger_host,
"reporting_port": settings.jaeger_port
},
"sampler": {
"type": settings.jaeger_sampler_type,
"param": settings.jaeger_sampler_rate,
},
"trace_id_header": settings.trace_id_header
},
service_name=settings.service_name,
validate=True,
scope_manager=AsyncioScopeManager())
# this call also sets opentracing.tracer
app.tracer = config.initialize_tracer()
def ot_tracer(request, ot_tracer_factory): # noqa: F811
# use the dummy asyncio ot tracer
request.instance.ot_tracer = ot_tracer_factory(
"asyncio_svc",
config={},
scope_manager=AsyncioScopeManager(),
context_provider=ddtrace.contrib.asyncio.context_provider,
)
request.instance.ot_writer = request.instance.ot_tracer._dd_tracer.writer
request.instance.dd_tracer = request.instance.ot_tracer._dd_tracer
def test_parenting_200_ot(self):
"""OpenTracing version of test_handler."""
ot_tracer = init_tracer('aiohttp_svc', self.tracer, scope_manager=AsyncioScopeManager())
with ot_tracer.start_active_span('aiohttp_op'):
request = yield from self.client.request('GET', '/')
eq_(200, request.status)
text = yield from request.text()
eq_("What's tracing?", text)
traces = self.tracer.writer.pop_traces()
self._assert_200_parenting(traces)
def test_parenting_200_ot(self):
"""OpenTracing version of test_handler."""
ot_tracer = init_tracer("aiohttp_svc",
self.tracer,
scope_manager=AsyncioScopeManager())
with ot_tracer.start_active_span("aiohttp_op"):
request = yield from self.client.request("GET", "/")
assert 200 == request.status
text = yield from request.text()
assert "What's tracing?" == text
traces = self.pop_traces()
self._assert_200_parenting(traces)
def init_jaeger_tracer() -> Tracer:
config = Config(config={
'sampler': {
'type': 'const',
'param': 1,
},
'logging': True,
'propagation': "b3",
'local_agent': {
'reporting_host': 'localhost'
}
},
service_name='service1',
validate=True,
scope_manager=AsyncioScopeManager())
return config.initialize_tracer()
async def test_parenting_200_ot(app_tracer, aiohttp_client):
"""OpenTracing version of test_handler."""
app, tracer = app_tracer
client = await aiohttp_client(app)
ot_tracer = init_tracer("aiohttp_svc",
tracer,
scope_manager=AsyncioScopeManager())
with ot_tracer.start_active_span("aiohttp_op"):
request = await client.request("GET", "/")
assert 200 == request.status
text = await request.text()
assert "What's tracing?" == text
traces = tracer.pop_traces()
_assert_200_parenting(client, traces)
def initialize_tracer(service_name):
# pylint: disable=E0401
from jaeger_client.config import Config
from opentracing.scope_managers.asyncio import AsyncioScopeManager
# pylint: enable=E0401
config = Config(
config={'sampler': {
'type': 'const',
'param': 1
}},
service_name=service_name,
validate=True,
scope_manager=AsyncioScopeManager(),
)
return config.initialize_tracer()
def init_tracer(service_name: str):
config = Config(
config={
"local_agent": {
"reporting_host": JAEGER_HOST,
"reporting_port": JAEGER_PORT,
},
"sampler": {
"type": JAEGER_SAMPLER_TYPE,
"param": JAEGER_SAMPLER_RATE
},
"trace_id_header": JAEGER_TRACE_ID_HEADER,
},
scope_manager=AsyncioScopeManager(),
service_name=service_name,
validate=True,
)
return config.initialize_tracer()
def setup_opentracing(app):
"""
Helper function to setup opentracing with Jaeger client during setup.
Use during app startup as follows:
.. code-block:: python
app = FastAPI()
@app.on_event('startup')
async def startup():
setup_opentracing(app)
:param app: app object, instance of FastAPI
:return: None
"""
config = Config(config={
"local_agent": {
"reporting_host": settings.jaeger_host,
"reporting_port": settings.jaeger_port
},
"sampler": {
"type": settings.jaeger_sampler_type,
"param": settings.jaeger_sampler_rate,
},
"trace_id_header": settings.trace_id_header
},
service_name=settings.service_name,
validate=True,
scope_manager=AsyncioScopeManager())
warnings.warn(
"""
tracer object in request.app will be removed in favor of saving it in
request.app.state in the next minor version 0.3.0
""", FutureWarning)
# this call also sets opentracing.tracer
app.state.tracer = config.initialize_tracer()
app.tracer = app.state.tracer
def __init__(self,
config,
metrics=None,
service_name=None,
metrics_factory=None,
validate=False,
is_async=False,
enabled=True):
if config is None:
raise AttributeError("config cannot be empty")
self.enabled = enabled
if self.enabled:
config = Config(
config,
metrics=metrics,
service_name=service_name,
metrics_factory=metrics_factory,
validate=validate,
scope_manager=AsyncioScopeManager() if is_async else None)
self.tracer = config.initialize_tracer()
else:
self.tracer = EmptyTracer()
def test_get_context_provider_for_scope_manager_asyncio(self):
scope_manager = AsyncioScopeManager()
ctx_prov = get_context_provider_for_scope_manager(scope_manager)
assert isinstance(ctx_prov, ddtrace.contrib.asyncio.provider.AsyncioContextProvider)
def __init__(self, config, custom_reactor, tracer=opentracing.tracer):
"""
Object that holds state for the entirety of a Sygnal instance.
Args:
config (dict): Configuration for this Sygnal
custom_reactor: a Twisted Reactor to use.
tracer (optional): an OpenTracing tracer. The default is the no-op tracer.
"""
self.config = config
self.reactor = custom_reactor
self.pushkins = {}
self.tracer = tracer
logging_dict_config = config["log"]["setup"]
logging.config.dictConfig(logging_dict_config)
logger.debug("Started logging")
observer = twisted_log.PythonLoggingObserver()
observer.start()
# Old format db config
if config.get("db") is not None:
logger.warning(
"Config includes the legacy 'db' option, please migrate"
" to 'database' instead")
config["database"] = {
"name": "sqlite3",
"args": {
"dbfile": config["db"]["dbfile"]
},
}
elif config.get("database") is None:
config["database"] = {
"name": "sqlite3",
"args": {
"dbfile": "sygnal.db"
},
}
sentrycfg = config["metrics"]["sentry"]
if sentrycfg["enabled"] is True:
import sentry_sdk
logger.info("Initialising Sentry")
sentry_sdk.init(sentrycfg["dsn"])
promcfg = config["metrics"]["prometheus"]
if promcfg["enabled"] is True:
prom_addr = promcfg["address"]
prom_port = int(promcfg["port"])
logger.info("Starting Prometheus Server on %s port %d", prom_addr,
prom_port)
prometheus_client.start_http_server(port=prom_port,
addr=prom_addr or "")
tracecfg = config["metrics"]["opentracing"]
if tracecfg["enabled"] is True:
if tracecfg["implementation"] == "jaeger":
try:
import jaeger_client
jaeger_cfg = jaeger_client.Config(
config=tracecfg["jaeger"],
service_name=tracecfg["service_name"],
scope_manager=AsyncioScopeManager(),
)
self.tracer = jaeger_cfg.initialize_tracer()
logger.info("Enabled OpenTracing support with Jaeger")
except ModuleNotFoundError:
logger.critical(
"You have asked for OpenTracing with Jaeger but do not have"
" the Python package 'jaeger_client' installed.")
raise
else:
logger.error("Unknown OpenTracing implementation: %s.",
tracecfg["impl"])
sys.exit(1)
db_name = config["database"]["name"]
if db_name == "psycopg2":
logger.info("Using postgresql database")
self.database_engine = "postgresql"
self.database = ConnectionPool(
"psycopg2",
cp_reactor=self.reactor,
**config["database"].get("args"),
)
elif db_name == "sqlite3":
logger.info("Using sqlite database")
self.database_engine = "sqlite"
self.database = ConnectionPool(
"sqlite3",
config["database"]["args"]["dbfile"],
cp_reactor=self.reactor,
cp_min=1,
cp_max=1,
check_same_thread=False,
)
else:
raise Exception("Unsupported database 'name'")
span_recorder = InstanaRecorder()
# The global OpenTracing compatible tracer used internally by
# this package.
#
# Usage example:
#
# import instana
# instana.tracer.start_span(...)
#
tracer = InstanaTracer(recorder=span_recorder)
if sys.version_info >= (3, 4):
from opentracing.scope_managers.asyncio import AsyncioScopeManager
async_tracer = InstanaTracer(scope_manager=AsyncioScopeManager(),
recorder=span_recorder)
# Mock the tornado tracer until tornado is detected and instrumented first
tornado_tracer = tracer
def setup_tornado_tracer():
global tornado_tracer
from opentracing.scope_managers.tornado import TornadoScopeManager
tornado_tracer = InstanaTracer(scope_manager=TornadoScopeManager(),
recorder=span_recorder)
# Set ourselves as the tracer.
opentracing.tracer = tracer
def setUp(self):
self.tracer = MockTracer(AsyncioScopeManager())
self.loop = asyncio.get_event_loop()
def scope_manager(self):
return AsyncioScopeManager()
import sys
import opentracing
from .agent import Agent # noqa
from .tracer import InstanaTracer # noqa
# The Instana Agent which carries along with it a Sensor that collects metrics.
agent = Agent()
# The global OpenTracing compatible tracer used internally by
# this package.
#
# Usage example:
#
# import instana
# instana.tracer.start_span(...)
#
tracer = InstanaTracer()
if sys.version_info >= (3, 4):
from opentracing.scope_managers.asyncio import AsyncioScopeManager
async_tracer = InstanaTracer(AsyncioScopeManager())
# Set ourselves as the tracer.
opentracing.tracer = tracer
def setUp(self):
self.tracer = MockTracer(AsyncioScopeManager())
self.loop = asyncio.get_event_loop()
self.client = Client(RequestHandler(self.tracer), self.loop)
def __init__(
self,
config: Dict[str, Any],
custom_reactor: SygnalReactor,
tracer: Tracer = opentracing.tracer,
):
"""
Object that holds state for the entirety of a Sygnal instance.
Args:
config: Configuration for this Sygnal
custom_reactor: a Twisted Reactor to use.
tracer (optional): an OpenTracing tracer. The default is the no-op tracer.
"""
self.config = config
self.reactor = custom_reactor
self.pushkins: Dict[str, Pushkin] = {}
self.tracer = tracer
logging_dict_config = config["log"]["setup"]
logging.config.dictConfig(logging_dict_config)
logger.debug("Started logging")
observer = twisted_log.PythonLoggingObserver()
observer.start()
proxy_url = config.get("proxy")
if proxy_url is not None:
logger.info("Using proxy configuration from Sygnal configuration file")
else:
proxy_url = os.getenv("HTTPS_PROXY")
if proxy_url:
logger.info(
"Using proxy configuration from HTTPS_PROXY environment variable."
)
config["proxy"] = proxy_url
sentrycfg = config["metrics"]["sentry"]
if sentrycfg["enabled"] is True:
import sentry_sdk
logger.info("Initialising Sentry")
sentry_sdk.init(sentrycfg["dsn"])
if config.get("db") is not None:
logger.warning(
"Config includes the legacy 'db' option and will be ignored"
" as Sygnal no longer uses a database, this field can be removed"
)
if config.get("database") is not None:
logger.warning(
"Config includes the legacy 'database' option and will be ignored"
" as Sygnal no longer uses a database, this field can be removed"
)
promcfg = config["metrics"]["prometheus"]
if promcfg["enabled"] is True:
prom_addr = promcfg["address"]
prom_port = int(promcfg["port"])
logger.info(
"Starting Prometheus Server on %s port %d", prom_addr, prom_port
)
prometheus_client.start_http_server(port=prom_port, addr=prom_addr or "")
tracecfg = config["metrics"]["opentracing"]
if tracecfg["enabled"] is True:
if tracecfg["implementation"] == "jaeger":
try:
import jaeger_client
jaeger_cfg = jaeger_client.Config(
config=tracecfg["jaeger"],
service_name=tracecfg["service_name"],
scope_manager=AsyncioScopeManager(),
)
jaeger_tracer = jaeger_cfg.initialize_tracer()
assert jaeger_tracer is not None
self.tracer = jaeger_tracer
logger.info("Enabled OpenTracing support with Jaeger")
except ModuleNotFoundError:
logger.critical(
"You have asked for OpenTracing with Jaeger but do not have"
" the Python package 'jaeger_client' installed."
)
raise
else:
raise RuntimeError(
"Unknown OpenTracing implementation: %s.", tracecfg["impl"]
)
@param new_agent: agent to replace current singleton
@return: None
"""
global agent
agent = new_agent
# The global OpenTracing compatible tracer used internally by
# this package.
tracer = InstanaTracer(recorder=span_recorder)
if sys.version_info >= (3, 4):
try:
from opentracing.scope_managers.asyncio import AsyncioScopeManager
async_tracer = InstanaTracer(scope_manager=AsyncioScopeManager(), recorder=span_recorder)
except Exception:
logger.debug("Error setting up async_tracer:", exc_info=True)
# Mock the tornado tracer until tornado is detected and instrumented first
tornado_tracer = tracer
def setup_tornado_tracer():
global tornado_tracer
from opentracing.scope_managers.tornado import TornadoScopeManager
tornado_tracer = InstanaTracer(scope_manager=TornadoScopeManager(), recorder=span_recorder)
# Set ourselves as the tracer.
