fluidattacks_core_logging 12.0.0__py3-none-any.whl

fluidattacks_core/logging/__init__.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import logging
+import logging.config
+import sys
+from typing import TYPE_CHECKING
+
+from fluidattacks_core.logging.presets import DATE_FORMAT, PRODUCT_LOGGING
+from fluidattacks_core.logging.sources.utils import (
+    set_commit_ref_name,
+    set_commit_sha,
+    set_product_environment,
+    set_product_id,
+    set_product_version,
+)
+from fluidattacks_core.logging.utils import set_telemetry_metadata
+
+if TYPE_CHECKING:
+    from logging.config import _DictConfigArgs
+    from types import TracebackType
+
+
+def init_uncaught_exception_logging() -> None:
+    logger = logging.getLogger("unhandled")
+
+    def handle_uncaught_exception(
+        exception_type: type[BaseException],
+        msg: BaseException,
+        traceback: TracebackType | None,
+    ) -> None:
+        if issubclass(exception_type, KeyboardInterrupt):
+            sys.__excepthook__(exception_type, msg, traceback)
+            return
+
+        logger.critical(
+            "Uncaught exception",
+            exc_info=(exception_type, msg, traceback),
+        )
+
+    sys.excepthook = handle_uncaught_exception
+
+
+def init_logging(preset: _DictConfigArgs | None = None) -> None:
+    logging.config.dictConfig(preset or PRODUCT_LOGGING)
+    init_uncaught_exception_logging()
+
+
+__all__ = [
+    "DATE_FORMAT",
+    "PRODUCT_LOGGING",
+    "init_logging",
+    "init_uncaught_exception_logging",
+    "set_commit_ref_name",
+    "set_commit_sha",
+    "set_product_environment",
+    "set_product_id",
+    "set_product_version",
+    "set_telemetry_metadata",
+]

fluidattacks_core/logging/filters.py

@@ -0,0 +1,23 @@
+import logging
+
+from fluidattacks_core.logging.sources.utils import get_env_var, get_environment
+
+
+class NoProductionFilter(logging.Filter):
+    def filter(self, _record: logging.LogRecord) -> bool:
+        return get_environment() != "production"
+
+
+class ProductionOnlyFilter(logging.Filter):
+    def filter(self, _record: logging.LogRecord) -> bool:
+        return get_environment() == "production"
+
+
+class ErrorOnlyFilter(logging.Filter):
+    def filter(self, _record: logging.LogRecord) -> bool:
+        return _record.levelno >= logging.ERROR
+
+
+class EnabledTelemetryFilter(logging.Filter):
+    def filter(self, _record: logging.LogRecord) -> bool:
+        return str(get_env_var("TELEMETRY_OPT_OUT")).lower() != "true"

fluidattacks_core/logging/formatters.py

@@ -0,0 +1,173 @@
+import logging
+import traceback
+from datetime import UTC, datetime
+from decimal import Decimal
+from typing import TYPE_CHECKING, Any
+
+import simplejson as json
+from pythonjsonlogger.json import JsonFormatter
+
+from fluidattacks_core.logging.sources import (
+    BatchSource,
+    ContainerSource,
+    DefaultSource,
+    LambdaSource,
+    PipelineSource,
+)
+from fluidattacks_core.logging.utils import get_telemetry_metadata
+
+if TYPE_CHECKING:
+    from fluidattacks_core.logging.sources.types import SourceStrategy
+
+
+class ColorfulFormatter(logging.Formatter):
+    grey: str = "\x1b[38;1m"
+    yellow: str = "\x1b[33;1m"
+    red: str = "\x1b[31;1m"
+    reset: str = "\x1b[0m"
+    msg_format: str = "{asctime} [{levelname}] [{name}] {message}"
+
+    FORMATS = {  # noqa: RUF012
+        logging.DEBUG: grey + msg_format + reset,
+        logging.INFO: msg_format,
+        logging.WARNING: yellow + msg_format + reset,
+        logging.ERROR: red + msg_format + reset,
+        logging.CRITICAL: red + msg_format + reset,
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(
+            log_fmt,
+            datefmt=self.datefmt,
+            style="{",
+        )
+        return formatter.format(record)
+
+
+class CustomJsonFormatter(JsonFormatter):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
+        def json_default(object_: object) -> Any:  # noqa: ANN401
+            if isinstance(object_, set):
+                return list(object_)
+            if isinstance(object_, datetime):
+                return object_.astimezone(tz=UTC).isoformat()
+            if isinstance(object_, float):
+                return Decimal(str(object_))
+
+            if hasattr(object_, "__dict__"):
+                try:
+                    return {k: v for k, v in object_.__dict__.items() if not k.startswith("_")}
+                except (TypeError, ValueError, RecursionError):
+                    return f"<{type(object_).__name__} object>"
+
+            return object_
+
+        super().__init__(*args, **kwargs, json_serializer=json.dumps, json_default=json_default)
+
+    def add_fields(
+        self,
+        log_record: dict[str, Any],
+        record: logging.LogRecord,
+        message_dict: dict[str, Any],
+    ) -> None:
+        super().add_fields(log_record, record, message_dict)
+
+        log_record["timestamp"] = self._get_timestamp(log_record)
+        log_record["level"] = log_record.get("level") or record.levelname
+        log_record["name"] = record.name
+        log_record["file_location"] = f"{record.filename}:{record.lineno}"
+        log_record["lineno"] = record.lineno
+
+        self._add_source_fields(log_record)
+
+        self._add_default_telemetry_fields(log_record)
+        self._add_error_fields(log_record, record)
+        self._add_tracing_fields(log_record)
+        self._add_extra_fields(log_record)
+
+    def _get_timestamp(self, log_record: dict[str, Any]) -> int:
+        if timestamp := log_record.get("timestamp"):
+            if isinstance(timestamp, int):
+                return timestamp
+            if isinstance(timestamp, str) and timestamp.isdigit():
+                return int(timestamp)
+        return round(datetime.now(tz=UTC).timestamp() * 1000)
+
+    def _add_source_fields(self, log_record: dict[str, Any]) -> None:
+        """Add source information to the log record.
+
+        It includes:
+        - Source
+        - Service
+        - Version
+        - Deployment environment
+        - Other metadata according to the source
+        """
+        supported_sources: list[type[SourceStrategy]] = [
+            LambdaSource,
+            BatchSource,
+            PipelineSource,
+            ContainerSource,
+            DefaultSource,
+        ]
+        for source in supported_sources:
+            if source.detect():
+                log_record.update(source.log_metadata())
+                break
+
+    def _add_default_telemetry_fields(self, log_record: dict[str, Any]) -> None:
+        """Add default metadata fields to the log record.
+
+        Added fields via `set_telemetry_metadata` are included in this step.
+
+        """
+        for key, value in get_telemetry_metadata().items():
+            log_record[key] = value  # noqa: PERF403
+
+    def _add_error_fields(self, log_record: dict[str, Any], record: logging.LogRecord) -> None:
+        """Add error fields to the log record.
+
+        It includes:
+        - `error.kind`
+        - `error.message`
+        - `error.stack`
+        """
+        if record.exc_info:
+            if exc_type := record.exc_info[0]:
+                log_record["error.kind"] = exc_type.__name__
+            if exc_value := record.exc_info[1]:
+                log_record["error.message"] = str(exc_value)
+            if exc_tb := record.exc_info[2]:
+                log_record["error.stack"] = "".join(traceback.format_tb(exc_tb))
+
+            # Remove duplicated info
+            log_record.pop("exc_info", None)
+
+    def _add_tracing_fields(self, log_record: dict[str, Any]) -> None:
+        """Add tracing fields (by OpenTelemetry) to the log record.
+
+        It includes:
+        - `trace_id`
+        - `span_id`
+        - `trace_sampled`
+        """
+        if log_record.get("otelTraceID") is not None:
+            log_record["trace_id"] = log_record.pop("otelTraceID")
+
+        if log_record.get("otelSpanID") is not None:
+            log_record["span_id"] = log_record.pop("otelSpanID")
+
+        if log_record.get("otelTraceSampled") is not None:
+            log_record["trace_sampled"] = log_record.pop("otelTraceSampled")
+
+    def _add_extra_fields(self, log_record: dict[str, Any]) -> None:
+        """Add fields from `extra` to the log record.
+
+        It adds fields at the top level, allowing them to override existing fields.
+        """
+        if log_record.get("extra") is None:
+            log_record.pop("extra", None)
+        elif isinstance(log_record.get("extra"), dict):
+            log_record.update(log_record["extra"])
+            log_record.pop("extra", None)

fluidattacks_core/logging/handlers.py

@@ -0,0 +1,186 @@
+import copy
+import logging
+import sys
+from logging.handlers import HTTPHandler, QueueHandler, QueueListener
+from queue import Queue
+from typing import TextIO
+
+import simplejson as json
+
+from fluidattacks_core.logging.filters import (
+    EnabledTelemetryFilter,
+    ErrorOnlyFilter,
+    NoProductionFilter,
+    ProductionOnlyFilter,
+)
+from fluidattacks_core.logging.formatters import ColorfulFormatter, CustomJsonFormatter
+
+
+class CustomQueueHandler(QueueHandler):
+    """Class to fix QueueHandler missing exc_info field."""
+
+    # Defaults must exist before __init__ runs: Handler.__init__ already
+    # registers the instance, so a concurrent logging.shutdown() may see it
+    # before its listener is attached.
+    listener: QueueListener | None = None
+    shutting_down: bool = False
+
+    def _attach_listener(self, listener: QueueListener) -> None:
+        """Install and start `listener`, which must happen after `__init__`.
+
+        Private: it only orders initialization for subclasses in this module,
+        so it is not part of the package's public API.
+
+        `QueueHandler.__init__` assigns `listener = None` since Python 3.12, so a
+        subclass that builds its listener before delegating upwards loses it.
+        Handing the listener over here instead makes the order safe by
+        construction: this reads `self.queue`, which only exists once
+        `QueueHandler.__init__` has run.
+        """
+        self.listener = listener
+        listener.start()
+
+    def prepare(self, record: logging.LogRecord) -> logging.LogRecord:
+        original_exc_info = record.exc_info
+
+        # Avoid duplicate exc_text in the log message
+        no_exc_record = copy.copy(record)
+        no_exc_record.exc_info = None
+        prepared = super().prepare(no_exc_record)
+
+        prepared.exc_info = original_exc_info
+
+        return prepared
+
+
+class DebuggingHandler(logging.StreamHandler[TextIO]):
+    """Logging handler for console environments implemented with `QueueHandler`.
+
+    Includes:
+    - Filters: `NoProductionFilter`
+    - Formatter: `ColorfulFormatter`
+    """
+
+    def __init__(self, stream: TextIO = sys.stderr) -> None:
+        super().__init__(stream)
+        self.addFilter(NoProductionFilter())
+        self.setFormatter(ColorfulFormatter())
+
+
+class ProductionSyncHandler(logging.StreamHandler[TextIO]):
+    """Logging handler for production environments implemented with `logging.StreamHandler`.
+
+    Includes:
+    - Filters: `ProductionOnlyFilter`
+    - Formatter: `CustomJsonFormatter`
+    """
+
+    def __init__(self, stream: TextIO = sys.stderr) -> None:
+        super().__init__(stream)
+        self.addFilter(ProductionOnlyFilter())
+        self.setFormatter(CustomJsonFormatter())
+
+
+class ProductionAsyncHandler(CustomQueueHandler):
+    """Logging handler for production environments implemented with `QueueHandler`.
+
+    Includes:
+    - Filters: `NoBatchFilter`, `ProductionOnlyFilter`
+    - Formatter: `CustomJsonFormatter`
+    """
+
+    def __init__(self, stream: TextIO = sys.stderr) -> None:
+        handler = logging.StreamHandler(stream)
+        handler.addFilter(ProductionOnlyFilter())
+        handler.setFormatter(CustomJsonFormatter())
+
+        super().__init__(Queue())
+        self.shutting_down = False
+
+        self._attach_listener(QueueListener(self.queue, handler))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if self.shutting_down:
+            return
+        super().emit(record)
+
+    def close(self) -> None:
+        if self.shutting_down:
+            return
+
+        self.shutting_down = True
+        if self.listener:
+            self.listener.stop()
+        super().close()
+
+
+class DatadogLogsHandler(HTTPHandler):
+    """Logging handler for sending logs to Datadog using `HTTPHandler` from Python logging."""
+
+    def __init__(self, service: str, source: str, client_token: str) -> None:
+        self.host = "http-intake.logs.datadoghq.com"
+        self.url = f"/api/v2/logs?dd-api-key={client_token}&ddsource={source}&service={service}"
+
+        super().__init__(host=self.host, url=self.url, method="POST", secure=True)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            log_data = self.format(record)
+            json_string = json.dumps([log_data])
+
+            h = self.getConnection(self.host, self.secure)
+            h.putrequest(self.method, self.url)
+
+            h.putheader("Content-Type", "application/json")
+            h.putheader("Content-Length", str(len(json_string)))
+            h.endheaders()
+
+            h.send(json_string.encode("utf-8"))
+            h.getresponse()
+        except Exception:  # noqa: BLE001
+            self.handleError(record)
+
+
+class TelemetryAsyncHandler(CustomQueueHandler):
+    """Logging handler for sending logs to telemetry services asynchronously.
+
+    To enable telemetry, set the `TELEMETRY_OPT_OUT` environment variable different from `true`.
+
+    Includes:
+    - Filters: `ErrorOnlyFilter`, `EnabledTelemetryFilter`
+    - Formatter: `CustomJsonFormatter`
+    """
+
+    def __init__(self, service: str, source: str, dd_client_token: str) -> None:
+        """Initialize the TelemetryAsyncHandler.
+
+        Args:
+            service: The service name.
+            source: The source name.
+            dd_client_token: The Datadog Client Token.
+
+        """
+        handler = DatadogLogsHandler(service, source, dd_client_token)
+        handler.setFormatter(CustomJsonFormatter())
+
+        super().__init__(Queue())
+        self.shutting_down = False
+
+        self._attach_listener(QueueListener(self.queue, handler))
+
+        self.addFilter(ErrorOnlyFilter())
+        self.addFilter(EnabledTelemetryFilter())
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if self.shutting_down:
+            return
+        super().emit(record)
+
+    def close(self) -> None:
+        if self.shutting_down:
+            return
+
+        self.shutting_down = True
+        if self.listener:
+            self.listener.stop()
+        super().close()

fluidattacks_core/logging/presets.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from logging.config import _DictConfigArgs
+
+# Main formats
+DATE_FORMAT = "%Y-%m-%dT%H:%M:%S%z"
+"""
+Default date format for logs.
+"""
+
+
+PRODUCT_LOGGING: _DictConfigArgs = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "handlers": {
+        "production_handler": {
+            "class": "fluidattacks_core.logging.handlers.ProductionSyncHandler",
+            "stream": "ext://sys.stderr",
+        },
+        "debugging_handler": {
+            "class": "fluidattacks_core.logging.handlers.DebuggingHandler",
+            "stream": "ext://sys.stderr",
+        },
+    },
+    "root": {
+        "handlers": ["production_handler", "debugging_handler"],
+        "level": "INFO",
+    },
+}
+"""
+Default logging configuration dict for all the products.
+
+Required environment variables:
+- `PRODUCT_ID`
+- `CI_COMMIT_REF_NAME`
+- `CI_COMMIT_SHA`
+"""

fluidattacks_core/logging/sources/__init__.py

@@ -0,0 +1,180 @@
+from fluidattacks_core.logging.sources.types import SourceStrategy
+from fluidattacks_core.logging.sources.utils import get_env_var, get_environment, get_version
+
+
+class DefaultSource(SourceStrategy):
+    @staticmethod
+    def detect() -> bool:
+        return True
+
+    @staticmethod
+    def log_metadata() -> dict[str, str]:
+        return {
+            "ddsource": "python",
+            "dd.service": get_env_var("PRODUCT_ID") or "unknown",
+            "dd.version": get_version(),
+            "deployment.environment": get_environment(),
+        }
+
+
+class LambdaSource(SourceStrategy):
+    @staticmethod
+    def detect() -> bool:
+        return get_env_var("AWS_LAMBDA_FUNCTION_NAME") is not None
+
+    @staticmethod
+    def log_metadata() -> dict[str, str]:
+        product_id = get_env_var("PRODUCT_ID")
+        function_name = get_env_var("AWS_LAMBDA_FUNCTION_NAME")
+        service = product_id or function_name or "unknown"
+
+        trace_header = get_env_var("_X_AMZN_TRACE_ID")
+
+        return {
+            "ddsource": "lambda",
+            "dd.service": service,
+            "dd.version": get_version(),
+            "deployment.environment": get_environment(),
+            "lambda_metadata.function_name": function_name or "unknown",
+            "lambda_metadata.trace_header": trace_header or "unknown",
+        }
+
+
+class BatchSource(SourceStrategy):
+    @staticmethod
+    def detect() -> bool:
+        return get_env_var("AWS_BATCH_JOB_ID") is not None
+
+    @staticmethod
+    def log_metadata() -> dict[str, str]:
+        job_id = get_env_var("AWS_BATCH_JOB_ID")
+        attempt = get_env_var("AWS_BATCH_JOB_ATTEMPT")
+        compute_environment = get_env_var("AWS_BATCH_CE_NAME")
+
+        product_id = get_env_var("PRODUCT_ID")
+        job_definition_name = get_env_var("JOB_DEFINITION_NAME")
+        job_name = get_env_var("JOB_NAME")
+        job_queue = get_env_var("AWS_BATCH_JQ_NAME")
+        service = (
+            product_id
+            or job_definition_name
+            or job_name
+            or (f"from-{job_queue}" if job_queue else "unknown")
+        )
+
+        return {
+            "ddsource": "batch",
+            "dd.service": service,
+            "dd.version": get_version(),
+            "deployment.environment": get_environment(),
+            "job_metadata.id": job_id or "unknown",
+            "job_metadata.queue": job_queue or "unknown",
+            "job_metadata.definition_name": job_definition_name or "unknown",
+            "job_metadata.attempt": attempt or "unknown",
+            "job_metadata.compute_environment": compute_environment or "unknown",
+        }
+
+
+class PipelineSource(SourceStrategy):
+    @staticmethod
+    def detect() -> bool:
+        return PipelineSource._get_pipeline_metadata() is not None
+
+    @staticmethod
+    def log_metadata() -> dict[str, str]:
+        metadata = PipelineSource._get_pipeline_metadata()
+
+        return {
+            "ddsource": "ci",
+            "dd.service": get_env_var("PRODUCT_ID") or "unknown",
+            "dd.version": get_version(),
+            "deployment.environment": get_environment(),
+            **(metadata or {}),
+        }
+
+    @staticmethod
+    def _get_pipeline_metadata() -> dict[str, str] | None:
+        pipeline = None
+        if get_env_var("CI_JOB_ID"):
+            pipeline = "gitlab_ci"
+        elif get_env_var("CIRCLECI"):
+            pipeline = "circleci"
+        elif get_env_var("System.JobId"):
+            pipeline = "azure_devops"
+        elif get_env_var("BUILD_NUMBER"):
+            pipeline = "jenkins"
+
+        if pipeline is None:
+            return None
+
+        return {
+            "ddsource": f"ci/{pipeline}",
+            "pipeline_metadata.type": pipeline,
+            **(
+                {
+                    "pipeline_metadata.CI_JOB_ID": get_env_var("CI_JOB_ID") or "unknown",
+                    "pipeline_metadata.CI_JOB_URL": get_env_var("CI_JOB_URL") or "unknown",
+                }
+                if pipeline == "gitlab_ci"
+                else {}
+            ),
+            **(
+                {
+                    "pipeline_metadata.CIRCLE_BUILD_NUM": get_env_var("CIRCLE_BUILD_NUM")
+                    or "unknown",
+                    "pipeline_metadata.CIRCLE_BUILD_URL": get_env_var("CIRCLE_BUILD_URL")
+                    or "unknown",
+                }
+                if pipeline == "circleci"
+                else {}
+            ),
+            **(
+                {
+                    "pipeline_metadata.System.JobId": get_env_var("System.JobId") or "unknown",
+                }
+                if pipeline == "azure_devops"
+                else {}
+            ),
+            **(
+                {
+                    "pipeline_metadata.BUILD_NUMBER": get_env_var("BUILD_NUMBER") or "unknown",
+                    "pipeline_metadata.BUILD_ID": get_env_var("BUILD_ID") or "unknown",
+                    "pipeline_metadata.BUILD_URL": get_env_var("BUILD_URL") or "unknown",
+                }
+                if pipeline == "jenkins"
+                else {}
+            ),
+        }
+
+
+class ContainerSource(SourceStrategy):
+    @staticmethod
+    def detect() -> bool:
+        return (
+            get_env_var("CONTAINER_IMAGE") is not None
+            or get_env_var("CONTAINER_NAME") is not None
+            or get_env_var("CONTAINER_IMAGE_PATH") is not None
+        )
+
+    @staticmethod
+    def log_metadata() -> dict[str, str]:
+        product_id = get_env_var("PRODUCT_ID")
+        container_image = get_env_var("CONTAINER_IMAGE")
+        service = product_id or container_image or "unknown"
+
+        return {
+            "ddsource": "container",
+            "dd.service": service,
+            "dd.version": get_version(),
+            "deployment.environment": get_environment(),
+            "container_metadata.image": container_image or "unknown",
+        }
+
+
+__all__ = [
+    "BatchSource",
+    "ContainerSource",
+    "DefaultSource",
+    "LambdaSource",
+    "PipelineSource",
+]

fluidattacks_core/logging/sources/types.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+
+class SourceStrategy(ABC):
+    @staticmethod
+    @abstractmethod
+    def detect() -> bool:
+        """Detect if the current runtime is using this source."""
+
+    @staticmethod
+    @abstractmethod
+    def log_metadata() -> dict[str, str]:
+        """Get the metadata to be added to the log record."""

fluidattacks_core/logging/sources/utils.py

@@ -0,0 +1,37 @@
+import os
+
+
+def get_env_var(key: str) -> str | None:
+    return os.environ.get(key)
+
+
+def get_environment() -> str:
+    product_environment = os.environ.get("PRODUCT_ENVIRONMENT")
+    branch = os.environ.get("CI_COMMIT_REF_NAME", "default")
+    return product_environment or ("production" if branch == "trunk" else "development")
+
+
+def get_version() -> str:
+    product_version = os.environ.get("PRODUCT_VERSION")
+    short_commit_sha = os.environ["CI_COMMIT_SHA"][:8] if os.environ.get("CI_COMMIT_SHA") else None
+    return product_version or short_commit_sha or "00000000"
+
+
+def set_product_id(product_id: str) -> None:
+    os.environ["PRODUCT_ID"] = product_id
+
+
+def set_product_environment(product_environment: str) -> None:
+    os.environ["PRODUCT_ENVIRONMENT"] = product_environment
+
+
+def set_product_version(product_version: str) -> None:
+    os.environ["PRODUCT_VERSION"] = product_version
+
+
+def set_commit_sha(commit_sha: str) -> None:
+    os.environ["CI_COMMIT_SHA"] = commit_sha
+
+
+def set_commit_ref_name(commit_ref_name: str) -> None:
+    os.environ["CI_COMMIT_REF_NAME"] = commit_ref_name

fluidattacks_core/logging/utils.py

@@ -0,0 +1,37 @@
+import logging
+from typing import Any
+
+DEFAULT_TELEMETRY_METADATA: dict[str, Any] = {}
+
+
+def set_telemetry_metadata(config: dict[str, Any]) -> None:
+    DEFAULT_TELEMETRY_METADATA.update(config)
+
+
+def get_telemetry_metadata() -> dict[str, Any]:
+    return DEFAULT_TELEMETRY_METADATA
+
+
+def debug_logs() -> None:
+    """Test all the log levels in the root logger and a custom logger."""
+    root_logger = logging.getLogger()
+
+    root_logger.debug("This is a debug log")
+    root_logger.info("This is an info log")
+    root_logger.warning("This is a warning log")
+    root_logger.error("This is an error log")
+    root_logger.critical("This is a critical log")
+
+    logger = logging.getLogger("test-logger")
+    logger.debug("This is a debug log")
+    logger.info("This is an info log")
+    logger.warning("This is a warning log")
+    logger.error("This is an error log")
+    logger.critical("This is a critical log")
+
+    try:
+        msg = "Missing key"
+        raise KeyError(msg)  # noqa: TRY301
+    except KeyError as e:
+        root_logger.exception(e)  # noqa:TRY401
+        logger.exception(e)  # noqa:TRY401

fluidattacks_core_logging-12.0.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.5
+Name: fluidattacks_core_logging
+Version: 12.0.0
+Summary: Fluid Attacks Core Logging Library
+Author-email: Development <development@fluidattacks.com>
+License: MPL-2.0
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: python-json-logger>=3.3.0
+Requires-Dist: simplejson>=3.20.1

fluidattacks_core_logging-12.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fluidattacks_core/logging/__init__.py,sha256=y6D12LrvrsMwaveQn5C4Em3RyeS6mP6E9fRpq7gqS4o,1546
+fluidattacks_core/logging/filters.py,sha256=jEJkrvFeoQxCJ9vI8rd4N1FWXTbPdiTlv-7kriB8dQ0,725
+fluidattacks_core/logging/formatters.py,sha256=SCA4k9XvHJknmkTv63uiCBU31VrWOsgA7llEXYYj1uQ,6063
+fluidattacks_core/logging/handlers.py,sha256=NkJjz-y9iVtX8702sXUHPWOsPaEfpua53C_8CVxFNUU,6003
+fluidattacks_core/logging/presets.py,sha256=KU6d6PI61kklJ_o7NgAzU1DahEPM0KwwjTYHo2naHv8,939
+fluidattacks_core/logging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluidattacks_core/logging/utils.py,sha256=jbAcwr0L6iPsId3dYEp-vAbtFex2UUU2l2iIk1F60BE,1115
+fluidattacks_core/logging/sources/__init__.py,sha256=bUOsNhmBq9WHLvPxCW3G0Az4D8Wunp0mCCqEYlCsjsI,5937
+fluidattacks_core/logging/sources/types.py,sha256=ial-ASN6e0EV7XeetDknjcMx_HjqL6ilFwzNwqw5YyY,338
+fluidattacks_core/logging/sources/utils.py,sha256=tMoEVqrkVtqMuYtjgG6ih0HOjHyN3tn9G7nZhNoo6IU,1102
+fluidattacks_core_logging-12.0.0.dist-info/METADATA,sha256=k00Ej-sw9ti9g8Ar6dS63fA7IanoMeoKxc3uT0GRqBU,608
+fluidattacks_core_logging-12.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+fluidattacks_core_logging-12.0.0.dist-info/RECORD,,

fluidattacks_core_logging-12.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any