mirror of
https://mau.dev/maunium/synapse.git
synced 2024-09-04 08:32:29 +00:00
![Jorik Schellekens](/assets/img/avatar_default.png)
* Configure and initialise tracer Includes config options for the tracer and sets up JaegerClient. * Scope manager using LogContexts We piggy-back our tracer scopes by using log context. The current log context gives us the current scope. If new scope is created we create a stack of scopes in the context. * jaeger is a dependency now * Carrier inject and extraction for Twisted Headers * Trace federation requests on the way in and out. The span is created in _started_processing and closed in _finished_processing because we need a meaningful log context. * Create logcontext for new scope. Instead of having a stack of scopes in a logcontext we create a new context for a new scope if the current logcontext already has a scope. * Remove scope from logcontext if logcontext is top level * Disable tracer if not configured * typo * Remove dependence on jaeger internals * bools * Set service name * :Explicitely state that the tracer is disabled * Black is the new black * Newsfile * Code style * Use the new config setup. * Generate config. * Copyright * Rename config to opentracing * Remove user whitelisting * Empty whitelist by default * User ConfigError instead of RuntimeError * Use isinstance * Use tag constants for opentracing. * Remove debug comment and no need to explicitely record error * Two errors a "s(c)entry" * Docstrings! * Remove debugging brainslip * Homeserver Whitlisting * Better opentracing config comment * linting * Inclue worker name in service_name * Make opentracing an optional dependency * Neater config retreival * Clean up dummy tags * Instantiate tracing as object instead of global class * Inlcude opentracing as a homeserver member. * Thread opentracing to the request level * Reference opetnracing through hs * Instantiate dummy opentracin g for tests. * About to revert, just keeping the unfinished changes just in case * Revert back to global state, commit number: 9ce4a3d9067bf9889b86c360c05ac88618b85c4f * Use class level methods in tracerutils * Start and stop requests spans in a place where we have access to the authenticated entity * Seen it, isort it * Make sure to close the active span. * I'm getting black and blue from this. * Logger formatting Co-Authored-By: Erik Johnston <erik@matrix.org> * Outdated comment * Import opentracing at the top * Return a contextmanager * Start tracing client requests from the servlet * Return noop context manager if not tracing * Explicitely say that these are federation requests * Include servlet name in client requests * Use context manager * Move opentracing to logging/ * Seen it, isort it again! * Ignore twisted return exceptions on context exit * Escape the scope * Scopes should be entered to make them useful. * Nicer decorator names * Just one init, init? * Don't need to close something that isn't open * Docs make you smarter
141 lines
5.0 KiB
Python
141 lines
5.0 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright 2019 The Matrix.org Foundation C.I.C.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.import logging
|
|
|
|
import logging
|
|
|
|
from opentracing import Scope, ScopeManager
|
|
|
|
import twisted
|
|
|
|
from synapse.logging.context import LoggingContext, nested_logging_context
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class LogContextScopeManager(ScopeManager):
|
|
"""
|
|
The LogContextScopeManager tracks the active scope in opentracing
|
|
by using the log contexts which are native to synapse. This is so
|
|
that the basic opentracing api can be used across twisted defereds.
|
|
(I would love to break logcontexts and this into an OS package. but
|
|
let's wait for twisted's contexts to be released.)
|
|
"""
|
|
|
|
def __init__(self, config):
|
|
# Set the whitelists
|
|
logger.info(config.tracer_config)
|
|
self._homeserver_whitelist = config.tracer_config["homeserver_whitelist"]
|
|
|
|
@property
|
|
def active(self):
|
|
"""
|
|
Returns the currently active Scope which can be used to access the
|
|
currently active Scope.span.
|
|
If there is a non-null Scope, its wrapped Span
|
|
becomes an implicit parent of any newly-created Span at
|
|
Tracer.start_active_span() time.
|
|
|
|
Return:
|
|
(Scope) : the Scope that is active, or None if not
|
|
available.
|
|
"""
|
|
ctx = LoggingContext.current_context()
|
|
if ctx is LoggingContext.sentinel:
|
|
return None
|
|
else:
|
|
return ctx.scope
|
|
|
|
def activate(self, span, finish_on_close):
|
|
"""
|
|
Makes a Span active.
|
|
Args
|
|
span (Span): the span that should become active.
|
|
finish_on_close (Boolean): whether Span should be automatically
|
|
finished when Scope.close() is called.
|
|
|
|
Returns:
|
|
Scope to control the end of the active period for
|
|
*span*. It is a programming error to neglect to call
|
|
Scope.close() on the returned instance.
|
|
"""
|
|
|
|
enter_logcontext = False
|
|
ctx = LoggingContext.current_context()
|
|
|
|
if ctx is LoggingContext.sentinel:
|
|
# We don't want this scope to affect.
|
|
logger.error("Tried to activate scope outside of loggingcontext")
|
|
return Scope(None, span)
|
|
elif ctx.scope is not None:
|
|
# We want the logging scope to look exactly the same so we give it
|
|
# a blank suffix
|
|
ctx = nested_logging_context("")
|
|
enter_logcontext = True
|
|
|
|
scope = _LogContextScope(self, span, ctx, enter_logcontext, finish_on_close)
|
|
ctx.scope = scope
|
|
return scope
|
|
|
|
|
|
class _LogContextScope(Scope):
|
|
"""
|
|
A custom opentracing scope. The only significant difference is that it will
|
|
close the log context it's related to if the logcontext was created specifically
|
|
for this scope.
|
|
"""
|
|
|
|
def __init__(self, manager, span, logcontext, enter_logcontext, finish_on_close):
|
|
"""
|
|
Args:
|
|
manager (LogContextScopeManager):
|
|
the manager that is responsible for this scope.
|
|
span (Span):
|
|
the opentracing span which this scope represents the local
|
|
lifetime for.
|
|
logcontext (LogContext):
|
|
the logcontext to which this scope is attached.
|
|
enter_logcontext (Boolean):
|
|
if True the logcontext will be entered and exited when the scope
|
|
is entered and exited respectively
|
|
finish_on_close (Boolean):
|
|
if True finish the span when the scope is closed
|
|
"""
|
|
super(_LogContextScope, self).__init__(manager, span)
|
|
self.logcontext = logcontext
|
|
self._finish_on_close = finish_on_close
|
|
self._enter_logcontext = enter_logcontext
|
|
|
|
def __enter__(self):
|
|
if self._enter_logcontext:
|
|
self.logcontext.__enter__()
|
|
|
|
def __exit__(self, type, value, traceback):
|
|
if type == twisted.internet.defer._DefGen_Return:
|
|
super(_LogContextScope, self).__exit__(None, None, None)
|
|
else:
|
|
super(_LogContextScope, self).__exit__(type, value, traceback)
|
|
if self._enter_logcontext:
|
|
self.logcontext.__exit__(type, value, traceback)
|
|
else: # the logcontext existed before the creation of the scope
|
|
self.logcontext.scope = None
|
|
|
|
def close(self):
|
|
if self.manager.active is not self:
|
|
logger.error("Tried to close a none active scope!")
|
|
return
|
|
|
|
if self._finish_on_close:
|
|
self.span.finish()
|