Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

3.8 KB
Raw Blame
"""Structured JSON log formatter for Dify."""

import logging
import traceback
from datetime import UTC, datetime
from typing import Any, NotRequired, TypedDict, override

import orjson

from configs import dify_config


class IdentityDict(TypedDict, total=False):
    tenant_id: str
    user_id: str
    user_type: str


class LogDict(TypedDict):
    ts: str
    severity: str
    service: str
    caller: str
    message: str
    trace_id: NotRequired[str]
    span_id: NotRequired[str]
    identity: NotRequired[IdentityDict]
    attributes: NotRequired[dict[str, Any]]
    stack_trace: NotRequired[str]


class StructuredJSONFormatter(logging.Formatter):
    """
    JSON log formatter following the specified schema:
    {
      "ts": "ISO 8601 UTC",
      "severity": "INFO|ERROR|WARN|DEBUG",
      "service": "service name",
      "caller": "file:line",
      "trace_id": "hex 32",
      "span_id": "hex 16",
      "identity": { "tenant_id", "user_id", "user_type" },
      "message": "log message",
      "attributes": { ... },
      "stack_trace": "..."
    }
    """

    SEVERITY_MAP: dict[int, str] = {
        logging.DEBUG: "DEBUG",
        logging.INFO: "INFO",
        logging.WARNING: "WARN",
        logging.ERROR: "ERROR",
        logging.CRITICAL: "ERROR",
    }

    def __init__(self, service_name: str | None = None):
        super().__init__()
        self._service_name = service_name or dify_config.APPLICATION_NAME

    @override
    def format(self, record: logging.LogRecord) -> str:
        log_dict = self._build_log_dict(record)
        try:
            return orjson.dumps(log_dict).decode("utf-8")
        except TypeError:
            # Fallback: convert non-serializable objects to string
            import json

            return json.dumps(log_dict, default=str, ensure_ascii=False)

    def _build_log_dict(self, record: logging.LogRecord) -> LogDict:
        # Core fields
        log_dict: LogDict = {
            "ts": datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z"),
            "severity": self.SEVERITY_MAP.get(record.levelno, "INFO"),
            "service": self._service_name,
            "caller": f"{record.filename}:{record.lineno}",
            "message": record.getMessage(),
        }

        # Trace context (from TraceContextFilter)
        trace_id = getattr(record, "trace_id", "")
        span_id = getattr(record, "span_id", "")

        if trace_id:
            log_dict["trace_id"] = trace_id
        if span_id:
            log_dict["span_id"] = span_id

        # Identity context (from IdentityContextFilter)
        identity = self._extract_identity(record)
        if identity:
            log_dict["identity"] = identity

        # Dynamic attributes
        attributes = getattr(record, "attributes", None)
        if attributes:
            log_dict["attributes"] = attributes

        # Stack trace for errors with exceptions
        if record.exc_info and record.levelno >= logging.ERROR:
            log_dict["stack_trace"] = self._format_exception(record.exc_info)

        return log_dict

    def _extract_identity(self, record: logging.LogRecord) -> IdentityDict | None:
        tenant_id = getattr(record, "tenant_id", None)
        user_id = getattr(record, "user_id", None)
        user_type = getattr(record, "user_type", None)

        if not any([tenant_id, user_id, user_type]):
            return None

        identity: IdentityDict = {}
        if tenant_id:
            identity["tenant_id"] = tenant_id
        if user_id:
            identity["user_id"] = user_id
        if user_type:
            identity["user_type"] = user_type
        return identity

    def _format_exception(self, exc_info: tuple[Any, ...]) -> str:
        if exc_info and exc_info[0] is not None:
            return "".join(traceback.format_exception(*exc_info))
        return ""