async def _message_loop(self):
async for message in self.websocket:
# Clear context vars for logging
clear_contextvars()
bind_contextvars(message=message)
if message.type == aiohttp.WSMsgType.ERROR:
await self.websocket_message_error(message)
continue
try:
data = json.loads(message.data)
except JSONDecodeError as exception:
await self.websocket_message_not_parsable(message, exception)
continue
unbind_contextvars("message")
# bind_contextvars(data=data)
if "msg" not in data:
await self.websocket_message_missing_data_msg(data)
continue
num_fired = self.websocket_event_system.fire_event(
event=data["msg"], data=data)
if num_fired == 0:
await self.missing_message_handler(data)
async def _bind_logger_tracecontext_middleware(request: Request, call_next) -> Response:
"""Bind request and tracing variables to logging."""
# X-Request-ID can be used to assign a user-defined value to all log messages
# and to the tracing span context.
request_id = request.headers.get("x-request-id")
current_span = trace.get_current_span()
if request_id is not None:
current_span.set_attribute("request_id", request_id)
# The Trace-ID and Span-ID from the spancontext will be bound to log messages
spancontext = current_span.get_span_context()
trace_id = hex(spancontext.trace_id)
span_id = hex(spancontext.span_id)
clear_contextvars()
with _bind_context(trace_id=trace_id):
with _bind_context(span_id=span_id):
with _bind_context(request_id=request_id):
response = await call_next(request)
# Set response headers with tracing information
if request_id is not None:
response.headers["X-Request-ID"] = request_id
response.headers["X-Trace-ID"] = trace_id
response.headers["X-Span-ID"] = span_id
return response
def close(self):
"""Flush and tear down the context."""
self._bulk.flush()
clear_contextvars()
# Explicitly clear HTTP cache:
expire = timedelta(seconds=settings.CACHE_EXPIRE)
expire_at = datetime.utcnow() - expire
self.http.cache.remove_old_entries(expire_at)
def apply_task_context(task, **kwargs):
"""This clears the current structured logging context and readies it
for a new task from `servicelayer.jobs`."""
# Setup context for structured logging
clear_contextvars()
bind_contextvars(job_id=task.job.id,
stage=task.stage.stage,
dataset=task.job.dataset.name,
start_time=time.time(),
trace_id=str(uuid.uuid4()),
**kwargs)
async def add_context_logging(request: Request, call_next):
clear_contextvars()
request_id = str(uuid.uuid4())
bind_contextvars(request_id=request_id)
response = await call_next(request)
clear_contextvars()
response.headers["X-Request-ID"] = request_id
return response
def on_request(request: Request) -> None:
"""Middleware function that runs prior to processing a request via Sanic."""
# Generate a unique request ID and use it as a field in any logging that
# takes place during the request handling.
req_id = shortuuid.uuid()
request.ctx.uuid = req_id
contextvars.clear_contextvars()
contextvars.bind_contextvars(request_id=req_id, )
logger.debug(
'processing HTTP request',
method=request.method,
ip=request.ip,
path=request.path,
headers=dict(request.headers),
args=request.args,
)
def setup_logging_context(request):
role_id = None
if hasattr(request, "authz"):
role_id = request.authz.id
# Set up context varibales for structured logging. The context is included
# with every log entry produced by this particular request
clear_contextvars()
bind_contextvars(
v=__version__,
method=request.method,
endpoint=request.endpoint,
referrer=request.referrer,
ip=_get_remote_ip(),
ua=str(request.user_agent),
begin_time=datetime.utcfromtimestamp(request._begin_time).isoformat(),
role_id=role_id,
session_id=getattr(request, "_session_id", None),
locale=getattr(request, "_app_locale", None),
url=request.url,
path=request.full_path,
trace_id=request._trace_id,
)
async def coro():
bind_contextvars(a=1)
clear_contextvars()
return merge_contextvars(None, None, {"b": 2})
async def coro():
clear_contextvars()
return merge_contextvars(None, None, {})
def bind_logger(tracker: Tracker):
clear_contextvars()
bind_contextvars(sender_id=tracker.sender_id)
def close(self) -> None:
"""Flush and tear down the context."""
self.http.close()
clear_contextvars()
def _bind(request_id):
bind_contextvars(request_id=request_id)
yield
clear_contextvars()
async def clear_structlog_context(request: Request, call_next) -> Response:
from structlog.contextvars import clear_contextvars
clear_contextvars()
return await call_next(request)
def close(self) -> None:
"""Flush and tear down the context."""
clear_contextvars()
db.session.commit()