fluidattacks_utils_logger 1.0.0__tar.gz

fluidattacks_utils_logger-1.0.0/.envrc

@@ -0,0 +1,2 @@
+ln -f ../mypy.ini ./mypy.ini
+use_flake ".#python311.devShell"

fluidattacks_utils_logger-1.0.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: fluidattacks_utils_logger
+Version: 1.0.0
+Summary: Common logger handlers
+Author-email: Product Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: bugsnag >=4.7.0, <5.0.0
+Requires-Dist: fa-purity >=2.1.0, <3.0.0

fluidattacks_utils_logger-1.0.0/build/default.nix

@@ -0,0 +1,22 @@
+{ nixpkgs, pynix, src, }:
+let
+  deps = import ./deps { inherit nixpkgs pynix; };
+  requirements = python_pkgs: {
+    runtime_deps = with deps.python_pkgs; [ bugsnag fa-purity ];
+    build_deps = with deps.python_pkgs; [ flit-core ];
+    test_deps = with deps.python_pkgs; [
+      arch-lint
+      mypy
+      pytest
+      pytest-cov
+      ruff
+    ];
+  };
+in {
+  inherit src requirements;
+  root_path = "observes/common/utils-logger";
+  module_name = "fluidattacks_utils_logger";
+  pypi_token_var = "UTILS_LOGGER_TOKEN";
+  defaultDeps = deps.python_pkgs;
+  override = b: b;
+}

fluidattacks_utils_logger-1.0.0/build/deps/arch_lint.nix

@@ -0,0 +1,17 @@
+{ nixpkgs, pynix, python_pkgs }:
+let
+  commit = "43aa33ef4cfa12c37148f4653dd89233c585c368"; # v4.0.4
+  sha256 = "06r2xfj50rn9m87i3vwa9bilhnrz3njhmfd992vzp4a5x937rfq2";
+  bundle = let
+    src = builtins.fetchTarball {
+      inherit sha256;
+      url =
+        "https://gitlab.com/dmurciaatfluid/arch_lint/-/archive/${commit}/arch_lint-${commit}.tar";
+    };
+  in import "${src}/build" {
+    inherit src;
+    inherit nixpkgs pynix;
+  };
+  extended_python_pkgs = python_pkgs // { inherit (bundle.deps) grimp; };
+in bundle.builders.pkgBuilder
+(bundle.builders.requirements extended_python_pkgs)

fluidattacks_utils_logger-1.0.0/build/deps/default.nix

@@ -0,0 +1,18 @@
+{ nixpkgs, pynix, }:
+let
+  python_overlay = final: prev: {
+    arch-lint = import ./arch_lint.nix {
+      inherit nixpkgs pynix;
+      python_pkgs = prev;
+    };
+    fa-purity = import ./fa_purity.nix {
+      inherit nixpkgs pynix;
+      python_pkgs = final;
+    };
+  };
+  python = pynix.lib.python.override {
+    packageOverrides = python_overlay;
+    self = python;
+  };
+  python_pkgs = python.pkgs;
+in { inherit python_pkgs; }

fluidattacks_utils_logger-1.0.0/build/deps/fa_purity.nix

@@ -0,0 +1,19 @@
+{ nixpkgs, pynix, python_pkgs }:
+let
+  commit = "e669114103b334e532aec34dc5b2ec06dfd24247"; # v2.5.0+1
+  sha256 = "1x0ipsklpsxyrzy8j6agkqppj4n2x67kaz7zsi3mkycan9z9z3f8";
+  bundle = let
+    src = builtins.fetchTarball {
+      inherit sha256;
+      url =
+        "https://gitlab.com/dmurciaatfluid/purity/-/archive/${commit}/purity-${commit}.tar";
+    };
+  in import "${src}/build" {
+    inherit src;
+    inherit nixpkgs pynix;
+  };
+  extended_python_pkgs = python_pkgs // {
+    inherit (bundle.deps) types-simplejson;
+  };
+in bundle.builders.pkgBuilder
+(bundle.builders.requirements extended_python_pkgs)

fluidattacks_utils_logger-1.0.0/build/filter.nix

@@ -0,0 +1,11 @@
+path_filter: src:
+path_filter {
+  root = src;
+  include = [
+    "fluidattacks_utils_logger"
+    "tests"
+    "pyproject.toml"
+    "mypy.ini"
+    "ruff.toml"
+  ];
+}

fluidattacks_utils_logger-1.0.0/flake.lock

@@ -0,0 +1,172 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1754487366,
+        "narHash": "sha256-pHYj8gUBapuUzKV/kN/tR3Zvqc7o6gdFB9XKXIp1SQ8=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "af66ad14b28a127c5c0f3bbb298218fc63528a18",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "nix_filter": {
+      "locked": {
+        "lastModified": 1731533336,
+        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nix_filter_2": {
+      "locked": {
+        "lastModified": 1731533336,
+        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1736441877,
+        "narHash": "sha256-m3+PhBFkDwqo9lBplG4AyMW8P4/KcioJRS1UG8N7okM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "ce3899414dab3297cf025bfa356dc2da426feefd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1753579242,
+        "narHash": "sha256-zvaMGVn14/Zz8hnp4VWT9xVnhc8vuL3TStRqwk22biA=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "0f36c44e01a6129be94e3ade315a5883f0228a6e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
+    "nixpkgs_flake": {
+      "locked": {
+        "lastModified": 1756313514,
+        "narHash": "sha256-3Xbak0pXR8ziNv1ghHyJ5a5Ti2kt/LWq6hKZVJTvjBs=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "181464235b2daff8725773fef43ffc9d6b02e1c2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "observes_flake_builder": {
+      "inputs": {
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": "nixpkgs_flake",
+        "pynix_flake": "pynix_flake",
+        "shell-helpers": "shell-helpers"
+      },
+      "locked": {
+        "dir": "observes/common/std_flake",
+        "lastModified": 1761069772,
+        "narHash": "sha256-7usoyA5DPHs1H0yI6goVDInqy1lUChLHHKt2u1t6GFk=",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "eff07528e7f89f6ea1a626c74dfeb14d86244dfe",
+        "type": "github"
+      },
+      "original": {
+        "dir": "observes/common/std_flake",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "eff07528e7f89f6ea1a626c74dfeb14d86244dfe",
+        "type": "github"
+      }
+    },
+    "pynix_flake": {
+      "inputs": {
+        "nix_filter": "nix_filter_2",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1758642502,
+        "narHash": "sha256-PD/bQMz2dqZSkydHyvRh+jS/0qoV8SdcIVs6sassteQ=",
+        "owner": "dmurciaatfluid",
+        "repo": "python_nix_builder",
+        "rev": "809aafe2e1995e72c15378d099bf251b78f04a20",
+        "type": "gitlab"
+      },
+      "original": {
+        "owner": "dmurciaatfluid",
+        "repo": "python_nix_builder",
+        "type": "gitlab"
+      }
+    },
+    "root": {
+      "inputs": {
+        "observes_flake_builder": "observes_flake_builder"
+      }
+    },
+    "shell-helpers": {
+      "inputs": {
+        "flake-parts": "flake-parts",
+        "nixpkgs": [
+          "observes_flake_builder",
+          "nixpkgs_flake"
+        ]
+      },
+      "locked": {
+        "dir": "common/utils/shell-helpers",
+        "lastModified": 1752896460,
+        "narHash": "sha256-AsyTatXMx839cGsF6knwTrDZHk3Eue2QD3eSP7bkmpg=",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "27749d2c3a2b018eb010a322e5e1352f993c9e86",
+        "type": "github"
+      },
+      "original": {
+        "dir": "common/utils/shell-helpers",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "27749d2c3a2b018eb010a322e5e1352f993c9e86",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

fluidattacks_utils_logger-1.0.0/flake.nix

@@ -0,0 +1,19 @@
+{
+  description = "Log utils for observes packages";
+
+  inputs = {
+    observes_flake_builder = {
+      url =
+        "github:fluidattacks/universe/eff07528e7f89f6ea1a626c74dfeb14d86244dfe?shallow=1&dir=observes/common/std_flake";
+    };
+  };
+
+  outputs = { self, ... }@inputs:
+    let
+      build_args = { system, python_version, nixpkgs, pynix }:
+        import ./build {
+          inherit nixpkgs pynix;
+          src = import ./build/filter.nix nixpkgs.nix-filter self;
+        };
+    in { packages = inputs.observes_flake_builder.outputs.build build_args; };
+}

fluidattacks_utils_logger-1.0.0/fluidattacks_utils_logger/__init__.py

@@ -0,0 +1,45 @@
+import sys
+
+import bugsnag
+from fa_purity import (
+    Cmd,
+)
+
+from . import (
+    handlers,
+    logger,
+)
+from .env import (
+    current_app_env,
+)
+from .levels import (
+    LoggingLvl,
+)
+
+__version__ = "1.0.0"
+
+
+def set_main_log(
+    name: str,
+    conf: handlers.LoggingConf,
+    debug: bool,
+    show_time: bool,
+) -> Cmd[None]:
+    _bug_handler = handlers.bug_handler(conf, LoggingLvl.ERROR)
+    _log_handler = handlers.logger_handler(debug, show_time, sys.stderr)
+    _handlers = (_log_handler, _bug_handler)
+    env = current_app_env()
+    display_env = logger.get_logger(name).bind(
+        lambda log: env.bind(lambda e: log.info("%s@%s", (name, e.value))),  # noqa: PLE1206
+    )
+    return (
+        logger.set_logger(name, LoggingLvl.DEBUG if debug else LoggingLvl.INFO, _handlers)
+        + display_env
+    )
+
+
+def start_session() -> Cmd[None]:
+    def _action() -> None:
+        bugsnag.start_session()  # type: ignore[no-untyped-call]
+
+    return Cmd.wrap_impure(_action)

fluidattacks_utils_logger-1.0.0/fluidattacks_utils_logger/env.py

@@ -0,0 +1,37 @@
+from enum import (
+    Enum,
+)
+from os import (
+    environ,
+)
+
+from fa_purity import (
+    Cmd,
+)
+
+
+class Envs(Enum):
+    PROD = "production"
+    DEV = "development"
+
+
+def current_app_env() -> Cmd[Envs]:
+    def _action() -> Envs:
+        return Envs(environ.get("OBSERVES_ENV", "production"))
+
+    return Cmd.wrap_impure(_action)
+
+
+def observes_debug() -> Cmd[bool]:
+    def _action() -> bool:
+        _debug = environ.get("OBSERVES_DEBUG", "")
+        return _debug.lower() == "true"
+
+    return Cmd.wrap_impure(_action)
+
+
+def notifier_key() -> Cmd[str]:
+    def _action() -> str:
+        return environ.get("bugsnag_notifier_key", "")  # noqa: SIM112
+
+    return Cmd.wrap_impure(_action)

fluidattacks_utils_logger-1.0.0/fluidattacks_utils_logger/handlers.py

@@ -0,0 +1,67 @@
+import logging
+from dataclasses import (
+    dataclass,
+)
+from logging import (
+    Formatter,
+    Handler,
+)
+from typing import (
+    IO,
+)
+
+import bugsnag
+from bugsnag.handlers import (
+    BugsnagHandler,
+)
+from fa_purity import (
+    Cmd,
+)
+
+from fluidattacks_utils_logger.env import (
+    Envs,
+)
+from fluidattacks_utils_logger.levels import (
+    LoggingLvl,
+)
+
+
+@dataclass(frozen=True)
+class LoggingConf:
+    app_type: str
+    app_version: str
+    project_root: str
+    auto_capture_sessions: bool
+    api_key: str
+    release_stage: Envs
+    app_name: str
+
+
+def bug_handler(conf: LoggingConf, min_lvl: LoggingLvl) -> Cmd[Handler]:
+    def _action() -> Handler:
+        bugsnag.configure(  # type: ignore[no-untyped-call]
+            app_type=conf.app_type,
+            app_version=conf.app_version,
+            project_root=conf.project_root,
+            auto_capture_sessions=conf.auto_capture_sessions,
+            api_key=conf.api_key,
+            release_stage=conf.release_stage.value,
+        )
+        handler = BugsnagHandler()  # type: ignore[no-untyped-call]
+        handler.setLevel(min_lvl.value)
+        return handler
+
+    return Cmd.wrap_impure(_action)
+
+
+def logger_handler(debug: bool, show_time: bool, target: IO[str]) -> Cmd[Handler]:
+    def _action() -> Handler:
+        prefix = "%(name)s> " if debug else ""
+        _time = "%(asctime)s " if show_time else ""
+        _format = _time + prefix + "[%(levelname)s] %(message)s"
+        formatter = Formatter(_format)
+        handler = logging.StreamHandler(target)
+        handler.setFormatter(formatter)
+        return handler
+
+    return Cmd.wrap_impure(_action)

fluidattacks_utils_logger-1.0.0/fluidattacks_utils_logger/levels.py

@@ -0,0 +1,12 @@
+import logging
+from enum import (
+    Enum,
+)
+
+
+class LoggingLvl(Enum):
+    CRITICAL = logging.CRITICAL
+    ERROR = logging.ERROR
+    WARNING = logging.WARNING
+    INFO = logging.INFO
+    DEBUG = logging.DEBUG

fluidattacks_utils_logger-1.0.0/fluidattacks_utils_logger/logger.py

@@ -0,0 +1,54 @@
+import logging
+from dataclasses import (
+    dataclass,
+)
+
+from fa_purity import (
+    Cmd,
+    CmdUnwrapper,
+    FrozenList,
+)
+
+from fluidattacks_utils_logger.levels import (
+    LoggingLvl,
+)
+
+
+@dataclass(frozen=True)
+class _Logger:
+    logger: logging.Logger
+
+
+@dataclass(frozen=True)
+class Logger:
+    _inner: _Logger
+
+    def critical(self, formatted_msg: str, values: FrozenList[str]) -> Cmd[None]:
+        return Cmd.wrap_impure(lambda: self._inner.logger.critical(formatted_msg, *values))
+
+    def debug(self, formatted_msg: str, values: FrozenList[str]) -> Cmd[None]:
+        return Cmd.wrap_impure(lambda: self._inner.logger.debug(formatted_msg, *values))
+
+    def info(self, formatted_msg: str, values: FrozenList[str]) -> Cmd[None]:
+        return Cmd.wrap_impure(lambda: self._inner.logger.info(formatted_msg, *values))
+
+    def warning(self, formatted_msg: str, values: FrozenList[str]) -> Cmd[None]:
+        return Cmd.wrap_impure(lambda: self._inner.logger.warning(formatted_msg, *values))
+
+
+def get_logger(name: str) -> Cmd[Logger]:
+    def _action() -> Logger:
+        log = _Logger(logging.getLogger(name))
+        return Logger(log)
+
+    return Cmd.wrap_impure(_action)
+
+
+def set_logger(name: str, lvl: LoggingLvl, handlers: FrozenList[Cmd[logging.Handler]]) -> Cmd[None]:
+    def _action(unwrapper: CmdUnwrapper) -> None:
+        log = logging.getLogger(name)
+        log.setLevel(lvl.value)
+        for item in handlers:
+            log.addHandler(unwrapper.act(item))
+
+    return Cmd.new_cmd(_action)

fluidattacks_utils_logger-1.0.0/mypy.ini

@@ -0,0 +1,30 @@
+[mypy]
+disallow_any_decorated = True
+disallow_any_expr = True
+disallow_any_explicit = True
+disallow_any_generics = True
+disallow_any_unimported = True
+disallow_incomplete_defs = True
+disallow_subclassing_any = True
+disallow_untyped_calls = True
+disallow_untyped_decorators = True
+disallow_untyped_defs = True
+
+check_untyped_defs = True
+no_implicit_optional = True
+strict = True
+strict_equality = True
+strict_optional = True
+
+warn_redundant_casts = True
+warn_unused_ignores = True
+warn_no_return = True
+warn_return_any = True
+warn_unreachable = True
+
+ignore_errors = False
+ignore_missing_imports = False
+allow_untyped_globals = False
+allow_redefinition = False
+local_partial_types = False
+implicit_reexport = False

fluidattacks_utils_logger-1.0.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "fluidattacks_utils_logger"
+authors = [{ name = "Product Team", email = "development@fluidattacks.com" }]
+classifiers = ["License :: OSI Approved :: MIT License"]
+requires-python = ">=3.11"
+dependencies = [
+    "bugsnag >=4.7.0, <5.0.0",
+    "fa-purity >=2.1.0, <3.0.0",
+]
+description = "Common logger handlers"
+dynamic = ["version"]
+
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"

fluidattacks_utils_logger-1.0.0/ruff.toml

@@ -0,0 +1,37 @@
+cache-dir = ".ruff_cache"
+line-length = 100
+indent-width = 4
+target-version = "py311"
+
+[lint]
+select = ["ALL"]
+ignore = [
+  "FBT001", # debatable
+  "FBT003",  # conflict with the convention of denying kwargs
+  "RET503", # raises false positives
+  "N818", # semantics on names, the type already has the semantics
+  "TC001",  # import cycles can be hidden
+  "TC002",  # import cycles can be hidden
+  "TC003",  # technical debt!
+  "FLY002", # f-string is not type safe: implicit str conversion can hide codification issues
+  "D203",  # conflict with D211 one must be ignored
+  "D212",  # conflict with D213 one must be ignored
+  "D104",  # missing docs; technical debt!
+  "D103",  # missing docs; technical debt!
+  "D102",  # missing docs; technical debt!
+  "D101",  # missing docs; technical debt!
+  "D100",  # missing docs; technical debt!
+]
+fixable = ["ALL"]
+unfixable = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[lint.per-file-ignores]
+"tests/**/*" = ["S101", "D100", "D103", "D104"]
+"tests_fx/**/*" = ["S101", "D100", "D103", "D104"]
+
+[format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "lf"

fluidattacks_utils_logger-1.0.0/tests/arch/arch.py

@@ -0,0 +1,39 @@
+from typing import (
+    TypeVar,
+)
+
+from arch_lint.dag import (
+    DagMap,
+)
+from arch_lint.graph import (
+    FullPathModule,
+)
+
+_T = TypeVar("_T")
+
+
+def raise_or_return(item: _T | Exception) -> _T:
+    if isinstance(item, Exception):
+        raise item
+    return item
+
+
+def _module(path: str) -> FullPathModule:
+    return raise_or_return(FullPathModule.from_raw(path))
+
+
+_dag: dict[str, tuple[tuple[str, ...] | str, ...]] = {
+    "fluidattacks_utils_logger": (
+        ("logger", "handlers"),
+        ("levels", "env"),
+    ),
+}
+
+
+def project_dag() -> DagMap:
+    return raise_or_return(DagMap.new(_dag))
+
+
+def forbidden_allowlist() -> dict[FullPathModule, frozenset[FullPathModule]]:
+    _raw: dict[str, frozenset[str]] = {}
+    return {_module(k): frozenset(_module(i) for i in v) for k, v in _raw.items()}

fluidattacks_utils_logger-1.0.0/tests/arch/test_arch.py

@@ -0,0 +1,43 @@
+from arch_lint.dag.check import (
+    dag_map_completeness,
+)
+from arch_lint.forbidden import (
+    check_forbidden,
+)
+from arch_lint.graph import (
+    ImportGraph,
+)
+from arch_lint.private import (
+    check_private,
+)
+
+from .arch import (
+    forbidden_allowlist,
+    project_dag,
+)
+
+root = "fluidattacks_utils_logger"
+
+
+def test_dag_creation() -> None:
+    project_dag()
+
+
+def test_dag_completeness() -> None:
+    graph = ImportGraph.build_graph(root, True)
+    dag_map_completeness(project_dag(), graph, next(iter(graph.roots)))
+
+
+def test_forbidden_creation() -> None:
+    forbidden_allowlist()
+
+
+def test_forbidden() -> None:
+    graph = ImportGraph.build_graph(root, True)
+    allowlist_map = forbidden_allowlist()
+    check_forbidden(allowlist_map, graph)
+
+
+def test_private() -> None:
+    graph = ImportGraph.build_graph(root, False)
+    check_private(graph, next(iter(graph.roots)))

fluidattacks_utils_logger-1.0.0/uv.lock

@@ -0,0 +1,43 @@
+[[package]]
+name = "python3"
+version = "3.11.13"
+
+[[package]]
+name = "bugsnag"
+version = "4.8.0"
+
+[[package]]
+name = "deprecated"
+version = "1.2.18"
+
+[[package]]
+name = "fa_purity"
+version = "2.5.0"
+
+[[package]]
+name = "more-itertools"
+version = "10.7.0"
+
+[[package]]
+name = "simplejson"
+version = "3.20.1"
+
+[[package]]
+name = "six"
+version = "1.17.0"
+
+[[package]]
+name = "types-deprecated"
+version = "1.2.15.20250304"
+
+[[package]]
+name = "types-simplejson"
+version = "3.17.3"
+
+[[package]]
+name = "webob"
+version = "1.8.9"
+
+[[package]]
+name = "wrapt"
+version = "1.17.2"