fluidattacks_core_logging 12.0.0__tar.gz

fluidattacks_core_logging-12.0.0/.envrc

@@ -0,0 +1 @@
+use_flake ".#python311.devShell"

fluidattacks_core_logging-12.0.0/.gitignore

@@ -0,0 +1,5 @@
+target/
+.direnv/
+.venv/
+.vscode/settings.json
+.zed/settings.json

fluidattacks_core_logging-12.0.0/PKG-INFO

@@ -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/build/default.nix

@@ -0,0 +1,19 @@
+{ src, workspace_root }:
+{
+  inherit src workspace_root;
+  root_path = "develops/fluidattacks-core/python/logging";
+  module_name = "fluidattacks_core";
+  pypi_token = {
+    method = "oidc";
+  };
+  override = {
+    checks = {
+      basedpyright = false;
+    };
+    configs = {
+      import_linter = ../import-linter.cfg;
+      mypy = ../mypy.ini;
+      ruff = ../ruff.toml;
+    };
+  };
+}

fluidattacks_core_logging-12.0.0/build/filter.nix

@@ -0,0 +1,13 @@
+path_filter: src:
+path_filter {
+  root = src;
+  include = [
+    "fluidattacks_core"
+    "tests"
+    "import-linter.cfg"
+    "mypy.ini"
+    "pyproject.toml"
+    "ruff.toml"
+    "uv.lock"
+  ];
+}

fluidattacks_core_logging-12.0.0/flake.lock

@@ -0,0 +1,303 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1762810396,
+        "narHash": "sha256-dxFVgQPG+R72dkhXTtqUm7KpxElw3u6E+YlQ2WaDgt8=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "0bdadb1b265fb4143a75bd1ec7d8c915898a9923",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "nix_filter": {
+      "locked": {
+        "lastModified": 1757882181,
+        "narHash": "sha256-+cCxYIh2UNalTz364p+QYmWHs0P+6wDhiWR4jDIKQIU=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "59c44d1909c72441144b93cf0f054be7fe764de5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1758690382,
+        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1761765539,
+        "narHash": "sha256-b0yj6kfvO8ApcSE+QmA6mUfu8IYG6/uU28OFn4PaC8M=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "719359f4562934ae99f5443f20aa06c2ffff91fc",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1758690382,
+        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1761373498,
+        "narHash": "sha256-Q/uhWNvd7V7k1H1ZPMy/vkx3F8C13ZcdrKjO7Jv7v0c=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "6a08e6bb4e46ff7fcbb53d409b253f6bad8a28ce",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_flake": {
+      "locked": {
+        "lastModified": 1778253243,
+        "narHash": "sha256-KkH2QvU6iRLDTGGEwH5jnMqHWj4zMTuHxi1S1zdr01w=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "4fcda7103530b23c5ca44286344912082aad4220",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "pyproject-build-systems": {
+      "inputs": {
+        "nixpkgs": "nixpkgs",
+        "pyproject-nix": "pyproject-nix",
+        "uv2nix": "uv2nix"
+      },
+      "locked": {
+        "lastModified": 1761781027,
+        "narHash": "sha256-YDvxPAm2WnxrznRqWwHLjryBGG5Ey1ATEJXrON+TWt8=",
+        "owner": "pyproject-nix",
+        "repo": "build-system-pkgs",
+        "rev": "795a980d25301e5133eca37adae37283ec3c8e66",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "build-system-pkgs",
+        "type": "github"
+      }
+    },
+    "pyproject-nix": {
+      "inputs": {
+        "nixpkgs": [
+          "python_builder",
+          "pyproject-build-systems",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1758265079,
+        "narHash": "sha256-amLaLNwKSZPShQHzfgmc/9o76dU8xzN0743dWgvYlr8=",
+        "owner": "nix-community",
+        "repo": "pyproject.nix",
+        "rev": "02e9418fd4af638447dca4b17b1280da95527fc9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "pyproject-nix_2": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1762427963,
+        "narHash": "sha256-CkPlAbIQ87wmjy5qHibfzk4DmMGBNqFer+lLfXjpP5M=",
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "rev": "4540ea004e04fcd12dd2738d51383d10f956f7b9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "pyproject-nix_3": {
+      "inputs": {
+        "nixpkgs": [
+          "python_builder",
+          "uv2nix",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1760402624,
+        "narHash": "sha256-jF6UKLs2uGc2rtved8Vrt58oTWjTQoAssuYs/0578Z4=",
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "rev": "84c4ea102127c77058ea1ed7be7300261fafc7d2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "python_builder": {
+      "inputs": {
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": "nixpkgs_flake",
+        "pyproject-build-systems": "pyproject-build-systems",
+        "pyproject-nix": "pyproject-nix_2",
+        "shell-helpers": "shell-helpers",
+        "uv2nix": "uv2nix_2"
+      },
+      "locked": {
+        "dir": "common/utils/python-builder",
+        "lastModified": 1787078362,
+        "narHash": "sha256-HYL7Rn6SuNjYxkt/PwFLksZjsauCiY+ENbOWryLsIlw=",
+        "ref": "refs/heads/trunk",
+        "rev": "09fd25a13309eb5e3b5b2a061bb340df3ae5d281",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      },
+      "original": {
+        "dir": "common/utils/python-builder",
+        "rev": "09fd25a13309eb5e3b5b2a061bb340df3ae5d281",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      }
+    },
+    "root": {
+      "inputs": {
+        "python_builder": "python_builder"
+      }
+    },
+    "shell-helpers": {
+      "inputs": {
+        "flake-parts": "flake-parts",
+        "nixpkgs": [
+          "python_builder",
+          "nixpkgs_flake"
+        ]
+      },
+      "locked": {
+        "dir": "common/utils/shell-helpers",
+        "lastModified": 1762806066,
+        "narHash": "sha256-Wz99Fl7SpPU1NkTHJ36XOo6DjOEAMXCw3ThRABOS2Hs=",
+        "ref": "refs/heads/trunk",
+        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      },
+      "original": {
+        "dir": "common/utils/shell-helpers",
+        "rev": "d73cfdc7ae9e7f547e22a4481d4c2ccce38b26a8",
+        "shallow": true,
+        "type": "git",
+        "url": "ssh://git@gitlab.com/fluidattacks/universe"
+      }
+    },
+    "uv2nix": {
+      "inputs": {
+        "nixpkgs": [
+          "python_builder",
+          "pyproject-build-systems",
+          "nixpkgs"
+        ],
+        "pyproject-nix": [
+          "python_builder",
+          "pyproject-build-systems",
+          "pyproject-nix"
+        ]
+      },
+      "locked": {
+        "lastModified": 1758933732,
+        "narHash": "sha256-HAmm1GBS1myZCFuog0DC2ZLaynvZtiUI2Crmo+cdQI0=",
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "rev": "273ce18f913d8559e0d04f820d724308966d7c4d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "type": "github"
+      }
+    },
+    "uv2nix_2": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_3",
+        "pyproject-nix": "pyproject-nix_3"
+      },
+      "locked": {
+        "lastModified": 1761872265,
+        "narHash": "sha256-i25GRgp2vUOebY70L3NTAgkd+Pr1hnn5xM3qHxH0ONU=",
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "rev": "74dfb62871be152ad3673b143b0cc56105a4f3c5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

fluidattacks_core_logging-12.0.0/flake.nix

@@ -0,0 +1,29 @@
+{
+  description = "Fluid Attacks Core logging package.";
+
+  inputs = {
+    python_builder = {
+      url = "git+ssh://git@gitlab.com/fluidattacks/universe?shallow=1&rev=09fd25a13309eb5e3b5b2a061bb340df3ae5d281&dir=common/utils/python-builder";
+    };
+  };
+
+  outputs =
+    { self, ... }@inputs:
+    let
+      build_args =
+        {
+          system,
+          python_version,
+          nixpkgs,
+          builders,
+          scripts,
+        }:
+        import ./build {
+          src = import ./build/filter.nix nixpkgs.nix-filter self;
+          workspace_root = ./.;
+        };
+    in
+    {
+      packages = inputs.python_builder.outputs.build build_args;
+    };
+}

fluidattacks_core_logging-12.0.0/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-12.0.0/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-12.0.0/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)