def test_pickle(self, level):
        """
        FilteringBoundLogger are pickleable.
        """
        bl = make_filtering_bound_logger(level)

        assert bl == pickle.loads(pickle.dumps(bl))
Exemplo n.º 2
0
def configure_logging(processor: Any, level: int) -> None:
    level_str = logging.getLevelName(level)
    timestamper = structlog.processors.TimeStamper(fmt="iso")

    logging.config.dictConfig({
        "version": 1,
        "disable_existing_loggers": False,
        "formatters": {
            "formater": {
                "()":
                structlog.stdlib.ProcessorFormatter,
                "processor":
                processor,
                # Adjust log entries that are not from structlog
                "foreign_pre_chain": [
                    structlog.stdlib.add_log_level,
                    structlog.stdlib.add_logger_name,
                    timestamper,
                ],
            },
        },
        "handlers": {
            "default": {
                "level": level_str,
                "class": "logging.StreamHandler",
                "formatter": "formater",
            },
        },
        "loggers": {
            "": {
                "handlers": ["default"],
                "level": level_str,
                "propagate": True,
            },
            "sqlalchemy": {
                "handlers": ["default"],
                "level": level_str,
            },
            "PyQt5": {
                "handlers": ["default"],
                "level": level_str,
            },
        },
    })

    structlog.configure_once(
        processors=[
            merge_contextvars,
            structlog.stdlib.add_log_level,
            structlog.stdlib.add_logger_name,
            structlog.stdlib.PositionalArgumentsFormatter(),
            timestamper,
            structlog.processors.StackInfoRenderer(),
            structlog.processors.format_exc_info,
            structlog.processors.UnicodeDecoder(),
            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
        ],
        context_class=dict,
        logger_factory=structlog.stdlib.LoggerFactory(),
        wrapper_class=structlog.make_filtering_bound_logger(level),
        cache_logger_on_first_use=True,
    )
def fixture_bl(cl):
    return make_filtering_bound_logger(logging.INFO)(cl, [], {})
Exemplo n.º 4
0
from server.db.database import DBSessionMiddleware
from server.exception_handlers.generic_exception_handlers import form_error_handler, problem_detail_handler
from server.forms import FormException
from server.settings import app_settings
from server.version import GIT_COMMIT_HASH

structlog.configure(
    processors=[
        structlog.processors.add_log_level,
        structlog.processors.StackInfoRenderer(),
        structlog.dev.set_exc_info,
        structlog.processors.format_exc_info,
        structlog.processors.TimeStamper(),
        structlog.dev.ConsoleRenderer(),
    ],
    wrapper_class=structlog.make_filtering_bound_logger(logging.NOTSET),
    context_class=dict,
    logger_factory=structlog.PrintLoggerFactory(),
    cache_logger_on_first_use=False,
)

logger = structlog.get_logger(__name__)

app = FastAPI(
    title="Boilerplate",
    description="The boilerplate is a project that can be copied and adapted.",
    openapi_url="/api/openapi.json",
    docs_url="/api/docs",
    redoc_url="/api/redoc",
    version=GIT_COMMIT_HASH if GIT_COMMIT_HASH else "0.1.0",
    default_response_class=JSONResponse,