trigerr-logging 0.4.1__tar.gz

trigerr_logging-0.4.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anurag Singh Kushwah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trigerr_logging-0.4.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: trigerr-logging
+Version: 0.4.1
+Summary: Structured JSON-line logging for Trigerr services and the Trigerr SDK.
+Author: Anurag Singh Kushwah
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/trigerr/trigerr-logging
+Project-URL: Repository, https://gitlab.com/trigerr/trigerr-logging
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# trigerr-logging
+
+Structured (JSON-line) logging for Trigerr services and SDK.
+
+Extracted from `trigerr/trigerr/logging_utils.py` as a standalone, zero-dependency package matching `sysstra-logging`'s architecture.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from trigerr_logging import get_logger, bind, bound, clear_context
+
+logger = get_logger("oms", log_file="logs/oms.jsonl", service="trigerr-oms")
+bind(request_id="req-123", tenant="trigerr")
+logger.info("order placed", extra={"order_id": "ord-456"})
+```

trigerr_logging-0.4.1/README.md

@@ -0,0 +1,21 @@
+# trigerr-logging
+
+Structured (JSON-line) logging for Trigerr services and SDK.
+
+Extracted from `trigerr/trigerr/logging_utils.py` as a standalone, zero-dependency package matching `sysstra-logging`'s architecture.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from trigerr_logging import get_logger, bind, bound, clear_context
+
+logger = get_logger("oms", log_file="logs/oms.jsonl", service="trigerr-oms")
+bind(request_id="req-123", tenant="trigerr")
+logger.info("order placed", extra={"order_id": "ord-456"})
+```

trigerr_logging-0.4.1/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trigerr-logging"
+# Version is single-sourced from trigerr_logging/__init__.py's __version__ —
+# bump it there only; the build reads it via the dynamic attr below. Same
+# arrangement as the trigerr package, so the two cannot drift in how they are
+# released.
+dynamic = ["version"]
+description = "Structured JSON-line logging for Trigerr services and the Trigerr SDK."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Anurag Singh Kushwah" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: System :: Logging",
+]
+# Deliberately empty: this module is imported by every trigerr-* service and is
+# shipped inside the SDK, so it must not drag a dependency tree behind it.
+# tests/test_stdlib_only.py enforces that.
+dependencies = []
+
+[project.urls]
+Homepage = "https://gitlab.com/trigerr/trigerr-logging"
+Repository = "https://gitlab.com/trigerr/trigerr-logging"
+
+[project.optional-dependencies]
+dev = [
+    "build>=1.2",
+    "pytest>=7.0",
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "trigerr_logging.__version__"}
+
+[tool.setuptools.packages.find]
+include = ["trigerr_logging*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

trigerr_logging-0.4.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trigerr_logging-0.4.1/tests/test_logging_utils.py

@@ -0,0 +1,319 @@
+import concurrent.futures
+import json
+import logging
+import os
+import threading
+
+import pytest
+
+import trigerr_logging as lu
+
+
+@pytest.fixture(autouse=True)
+def _clean_context():
+    lu.clear_context()
+    yield
+    lu.clear_context()
+
+
+# --------------------------------------------------------------------------
+# Context propagation
+# --------------------------------------------------------------------------
+
+def test_bind_merges_and_drops_none_values():
+    lu.bind(request_id="r1", user_id=None)
+    assert lu.get_context() == {"request_id": "r1"}
+
+
+def test_bind_is_copy_on_write_across_calls():
+    lu.bind(request_id="r1")
+    ctx1 = lu.get_context()
+    lu.bind(order_id="o1")
+    assert ctx1 == {"request_id": "r1"}
+    assert lu.get_context() == {"request_id": "r1", "order_id": "o1"}
+
+
+def test_clear_context_resets():
+    lu.bind(request_id="r1")
+    lu.clear_context()
+    assert lu.get_context() == {}
+
+
+def test_bound_restores_prior_context_on_exit():
+    lu.bind(request_id="outer")
+    with lu.bound(request_id="inner", order_id="o1"):
+        assert lu.get_context() == {"request_id": "inner", "order_id": "o1"}
+    assert lu.get_context() == {"request_id": "outer"}
+
+
+def test_bound_restores_on_exception():
+    lu.bind(request_id="outer")
+    with pytest.raises(ValueError):
+        with lu.bound(request_id="inner"):
+            raise ValueError("boom")
+    assert lu.get_context() == {"request_id": "outer"}
+
+
+def test_context_isolated_across_threads():
+    seen = {}
+
+    def worker():
+        lu.bind(request_id="thread-local")
+        seen["thread"] = lu.get_context()
+
+    lu.bind(request_id="main-thread")
+    t = threading.Thread(target=worker)
+    t.start()
+    t.join()
+
+    assert seen["thread"] == {"request_id": "thread-local"}
+    assert lu.get_context() == {"request_id": "main-thread"}
+
+
+def test_context_isolated_across_thread_pool_executor():
+    # Proxy for Celery prefork workers: each task should see its own bound
+    # context, not one leaked from a previous task on the same worker.
+    def worker(rid):
+        lu.clear_context()
+        lu.bind(request_id=rid)
+        return lu.get_context()["request_id"]
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
+        results = list(pool.map(worker, [f"r{i}" for i in range(8)]))
+
+    assert sorted(results) == sorted(f"r{i}" for i in range(8))
+
+
+# --------------------------------------------------------------------------
+# Scrubbing
+# --------------------------------------------------------------------------
+
+def test_scrub_redacts_top_level_extra_key():
+    record = logging.makeLogRecord({"msg": "hello", "api_key": "sk-live-123"})
+    lu.ScrubFilter().filter(record)
+    assert record.api_key == "[REDACTED]"
+
+
+def test_scrub_redacts_nested_dict_values():
+    creds = {"broker": "zerodha", "credentials": {"access_token": "abc123", "user_id": "AB1234"}}
+    record = logging.makeLogRecord({"msg": "resolved", "context": creds})
+    lu.ScrubFilter().filter(record)
+    assert record.context["credentials"]["access_token"] == "[REDACTED]"
+    assert record.context["credentials"]["user_id"] == "AB1234"
+    assert record.context["broker"] == "zerodha"
+
+
+def test_scrub_redacts_dicts_inside_lists():
+    payload = [{"password": "hunter2"}, {"note": "ok"}]
+    record = logging.makeLogRecord({"msg": "batch", "items": payload})
+    lu.ScrubFilter().filter(record)
+    assert record.items[0]["password"] == "[REDACTED]"
+    assert record.items[1]["note"] == "ok"
+
+
+def test_scrub_redacts_key_value_pairs_in_message_string():
+    record = logging.makeLogRecord({"msg": "request_dict : {'api_key': 'sk-live-999', 'symbol': 'INFY'}"})
+    lu.ScrubFilter().filter(record)
+    rendered = record.getMessage()
+    assert "sk-live-999" not in rendered
+    assert "[REDACTED]" in rendered
+    assert "INFY" in rendered
+
+
+def test_scrub_redacts_equals_style_message_pairs():
+    record = logging.makeLogRecord({"msg": "auth failed token=abcdef123456 path=/place_order"})
+    lu.ScrubFilter().filter(record)
+    rendered = record.getMessage()
+    assert "abcdef123456" not in rendered
+    assert "path=/place_order" in rendered
+
+
+def test_scrub_does_not_mutate_callers_original_dict():
+    creds = {"password": "hunter2"}
+    record = logging.makeLogRecord({"msg": "x", "creds": creds})
+    lu.ScrubFilter().filter(record)
+    assert creds["password"] == "hunter2"
+
+
+# --------------------------------------------------------------------------
+# JSON formatting / schema
+# --------------------------------------------------------------------------
+
+def _format_one(logger, formatter, level=logging.INFO, message="hello", extra=None):
+    record = logger.makeRecord(logger.name, level, __file__, 1, message, (), None, extra=extra)
+    return json.loads(formatter.format(record))
+
+
+def test_json_formatter_emits_required_keys():
+    logger = logging.getLogger("test-schema")
+    formatter = lu.JsonFormatter("oms")
+    payload = _format_one(logger, formatter)
+    assert payload["level"] == "INFO"
+    assert payload["service"] == "oms"
+    assert payload["logger"] == "test-schema"
+    assert payload["message"] == "hello"
+    assert payload["ts"].endswith("Z")
+
+
+def test_json_formatter_omits_unset_domain_keys():
+    """ Domain fields stay absent when unset — padding them would make "the
+    OMS has no such concept" indistinguishable from "this line failed to
+    populate it".
+
+    `tenant` used to be asserted here too. It is now part of the identity
+    block, so it is present-but-blank instead: a consumer can select it
+    without first knowing whether the writing service is tenant-aware. """
+    logger = logging.getLogger("test-schema-2")
+    formatter = lu.JsonFormatter("oms")
+    payload = _format_one(logger, formatter)
+    for key in ("request_id", "order_id", "credential_id"):
+        assert key not in payload
+    assert payload["tenant"] == ""
+
+
+def test_json_formatter_includes_bound_context_and_extra():
+    lu.bind(request_id="r1", tenant="acme")
+    logger = logging.getLogger("test-schema-3")
+    formatter = lu.JsonFormatter("oms")
+    payload = _format_one(logger, formatter, extra={"order_id": "o1"})
+    assert payload["request_id"] == "r1"
+    assert payload["tenant"] == "acme"
+    assert payload["order_id"] == "o1"
+
+
+def test_json_formatter_reads_tenant_from_env(monkeypatch):
+    monkeypatch.setenv("TENANT", "env-tenant")
+    logger = logging.getLogger("test-schema-4")
+    formatter = lu.JsonFormatter("oms")
+    payload = _format_one(logger, formatter)
+    assert payload["tenant"] == "env-tenant"
+
+
+def test_json_formatter_serializes_non_json_native_extra_values():
+    class Weird:
+        def __str__(self):
+            return "weird-repr"
+
+    logger = logging.getLogger("test-schema-5")
+    formatter = lu.JsonFormatter("oms")
+    payload = _format_one(logger, formatter, extra={"thing": Weird()})
+    assert payload["thing"] == "weird-repr"
+
+
+def test_json_formatter_includes_exc_info():
+    logger = logging.getLogger("test-schema-6")
+    formatter = lu.JsonFormatter("oms")
+    try:
+        raise RuntimeError("boom")
+    except RuntimeError:
+        record = logger.makeRecord(logger.name, logging.ERROR, __file__, 1, "failed", (), __import__("sys").exc_info())
+    payload = json.loads(formatter.format(record))
+    assert "RuntimeError: boom" in payload["exc"]
+
+
+# --------------------------------------------------------------------------
+# get_logger / handlers
+# --------------------------------------------------------------------------
+
+def test_get_logger_is_idempotent_no_duplicate_handlers(tmp_path):
+    log_file = str(tmp_path / "svc.jsonl")
+    logger1 = lu.get_logger("idempotent-svc", log_file=log_file, stream=False)
+    handler_count = len(logger1.handlers)
+    logger2 = lu.get_logger("idempotent-svc", log_file=log_file, stream=False)
+    assert logger1 is logger2
+    assert len(logger2.handlers) == handler_count
+
+
+def test_get_logger_writes_json_lines_to_file(tmp_path):
+    log_file = str(tmp_path / "svc2.jsonl")
+    logger = lu.get_logger("file-svc", log_file=log_file, stream=False)
+    logger.info("order placed", extra={"order_id": "o1"})
+    for handler in logger.handlers:
+        handler.flush()
+
+    with open(log_file) as f:
+        lines = [line for line in f.read().splitlines() if line]
+    assert len(lines) == 1
+    payload = json.loads(lines[0])
+    assert payload["message"] == "order placed"
+    assert payload["order_id"] == "o1"
+
+
+def test_get_logger_creates_parent_directories(tmp_path):
+    log_file = str(tmp_path / "nested" / "dir" / "svc.jsonl")
+    lu.get_logger("nested-dir-svc", log_file=log_file, stream=False)
+    assert os.path.isdir(os.path.dirname(log_file))
+
+
+def test_get_logger_file_handler_applies_scrub_filter(tmp_path):
+    log_file = str(tmp_path / "svc3.jsonl")
+    logger = lu.get_logger("scrub-svc", log_file=log_file, stream=False)
+    logger.info("resolved", extra={"api_key": "sk-live-123"})
+    for handler in logger.handlers:
+        handler.flush()
+
+    with open(log_file) as f:
+        content = f.read()
+    assert "sk-live-123" not in content
+    assert "[REDACTED]" in content
+
+
+# --------------------------------------------------------------------------
+# stdout redirection
+# --------------------------------------------------------------------------
+
+def test_redirect_stdout_to_logs_print_output(monkeypatch, tmp_path):
+    log_file = str(tmp_path / "stdout.jsonl")
+    logger = lu.get_logger("stdout-svc", log_file=log_file, stream=False)
+
+    import sys
+    original_stdout = sys.stdout
+    try:
+        lu.redirect_stdout_to(logger)
+        print("hello from print")
+    finally:
+        sys.stdout = original_stdout
+
+    for handler in logger.handlers:
+        handler.flush()
+    with open(log_file) as f:
+        lines = [line for line in f.read().splitlines() if line]
+    assert any(json.loads(line)["message"] == "hello from print" for line in lines)
+
+
+def test_redirect_stdout_to_shim_supports_isatty(tmp_path):
+    # Real regression: uvicorn's default log formatter calls
+    # sys.stdout.isatty() at Config() construction time to decide whether to
+    # color output; a plain object without this method raises AttributeError
+    # and uvicorn fails to start under redirect_stdout_to().
+    log_file = str(tmp_path / "isatty.jsonl")
+    logger = lu.get_logger("isatty-svc", log_file=log_file, stream=False)
+
+    import sys
+    original_stdout = sys.stdout
+    try:
+        lu.redirect_stdout_to(logger)
+        assert sys.stdout.isatty() is False
+    finally:
+        sys.stdout = original_stdout
+
+
+def test_redirect_stdout_to_drops_whitespace_only_writes(tmp_path):
+    log_file = str(tmp_path / "stdout2.jsonl")
+    logger = lu.get_logger("stdout-svc-2", log_file=log_file, stream=False)
+
+    import sys
+    original_stdout = sys.stdout
+    try:
+        lu.redirect_stdout_to(logger)
+        print()
+        print("real message")
+    finally:
+        sys.stdout = original_stdout
+
+    for handler in logger.handlers:
+        handler.flush()
+    with open(log_file) as f:
+        lines = [line for line in f.read().splitlines() if line]
+    assert len(lines) == 1
+    assert json.loads(lines[0])["message"] == "real message"

trigerr_logging-0.4.1/tests/test_schema_parity.py

@@ -0,0 +1,99 @@
+""" Pins the log envelope against tests/fixtures/envelope.golden.json.
+
+That fixture is the SAME FILE in project-sysstra's sysstra-logging and
+project-trigerr's trigerr-logging. Both projects push into one Loki, so a dashboard
+or alert written against one has to work against the other — and the two
+copies of logging_utils.py have drifted before, while a comment in CLAUDE.md
+asked politely for them to stay in sync. This test is that comment with
+teeth: change the envelope in one project and its own suite fails until the
+fixture is updated in both.
+
+Changing the envelope on purpose = edit the fixture in BOTH repos and bump
+SCHEMA_VERSION so mid-rollout lines stay distinguishable in Loki.
+"""
+import io
+import json
+import logging
+import os
+
+import pytest
+
+import trigerr_logging as lu
+
+GOLDEN = os.path.join(os.path.dirname(__file__), "fixtures", "envelope.golden.json")
+
+
+@pytest.fixture(scope="module")
+def golden():
+    with open(GOLDEN) as f:
+        return json.load(f)
+
+
+@pytest.fixture(autouse=True)
+def _clean_context():
+    lu.clear_context()
+    yield
+    lu.clear_context()
+
+
+def _render(service="svc", extra=None):
+    logger = logging.getLogger("parity")
+    logger.handlers.clear()
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    buf = io.StringIO()
+    handler = logging.StreamHandler(buf)
+    handler.setFormatter(lu.JsonFormatter(service))
+    logger.addHandler(handler)
+    logger.info("hello", extra=extra or {})
+    return json.loads(buf.getvalue().strip().splitlines()[-1])
+
+
+def test_schema_version_matches_golden(golden):
+    assert lu.SCHEMA_VERSION == golden["schema_version"]
+
+
+def test_identity_fields_match_golden(golden):
+    assert list(lu.IDENTITY_FIELDS) == golden["identity"]
+
+
+def test_intrinsic_fields_match_golden(golden):
+    assert sorted(lu._INTRINSIC_FIELDS) == sorted(golden["intrinsic"])
+
+
+def test_env_backed_fields_match_golden(golden):
+    assert lu._ENV_FIELDS == golden["env_backed"]
+
+
+def test_domain_field_order_matches_golden(golden):
+    assert list(lu._DOMAIN_ORDER) == golden["domain"]
+
+
+def test_env_default_matches_golden(golden):
+    assert lu._DEFAULT_ENV == golden["defaults"]["env"]
+
+
+def test_rendered_line_starts_with_the_golden_identity_block(golden, monkeypatch):
+    """ The fixture lists names; this asserts the formatter actually emits
+    them, in order, ahead of everything else. """
+    for var in ("SERVICE", "ENVIRONMENT", "TENANT", "MARKET"):
+        monkeypatch.delenv(var, raising=False)
+    rec = _render()
+    assert list(rec)[:len(golden["identity"])] == golden["identity"]
+
+
+def test_domain_fields_are_never_padded(golden):
+    """ The counterpart to the identity block: a repo that has no concept of
+    a field must not emit it blank, or a consumer cannot tell that apart
+    from a repo that has the concept and failed to populate it. """
+    rec = _render()
+    for field in golden["domain"]:
+        assert field not in rec, f"domain field {field} was padded: {rec}"
+
+
+def test_domain_fields_render_in_golden_order_when_supplied(golden):
+    supplied = {"order_id": "o1", "request_id": "r1", "mode": "lt", "job": "j1"}
+    rec = _render(extra=supplied)
+    emitted = [k for k in rec if k in supplied]
+    expected = [f for f in golden["domain"] if f in supplied]
+    assert emitted == expected

trigerr_logging-0.4.1/tests/test_stdlib_only.py

@@ -0,0 +1,54 @@
+""" This package must not drag a dependency tree behind it.
+
+It is imported by every trigerr-* service and is also shipped inside the
+pip-installable SDK, so anything it depends on becomes a transitive dependency
+of every client of the platform. The module docstring states that as a design
+rule; this is what holds it, because the failure mode otherwise is silent -- a
+convenient import gets added, the declared dependency list stays empty, and the
+package is broken only for whoever installs it somewhere clean.
+"""
+import ast
+import sys
+from pathlib import Path
+
+import pytest
+
+PACKAGE = Path(__file__).resolve().parent.parent / "trigerr_logging"
+
+# Everything the package is allowed to import: the standard library, and itself.
+LOCAL = {"trigerr_logging"}
+
+
+def _top_level_imports(path):
+    tree = ast.parse(path.read_text())
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                yield alias.name.split(".")[0]
+        elif isinstance(node, ast.ImportFrom):
+            if node.level:            # relative import, inside the package
+                continue
+            if node.module:
+                yield node.module.split(".")[0]
+
+
+@pytest.mark.skipif(not hasattr(sys, "stdlib_module_names"),
+                    reason="sys.stdlib_module_names needs Python 3.10+")
+@pytest.mark.parametrize("source", sorted(PACKAGE.rglob("*.py")), ids=lambda p: p.name)
+def test_module_imports_only_stdlib(source):
+    allowed = set(sys.stdlib_module_names) | LOCAL
+    offenders = sorted({name for name in _top_level_imports(source) if name not in allowed})
+
+    assert not offenders, (
+        f"{source.name} imports {offenders}, which are not in the standard library. "
+        f"Anything imported here becomes a transitive dependency of every service "
+        f"and of the SDK -- declare it in pyproject.toml deliberately, or drop it.")
+
+
+def test_declared_dependencies_stay_empty():
+    """ The other half: an empty import list is only meaningful if the metadata
+    agrees, since pip installs from the metadata rather than from the imports. """
+    pyproject = (PACKAGE.parent / "pyproject.toml").read_text()
+    block = pyproject.split("dependencies = [", 1)[1].split("]", 1)[0]
+
+    assert block.strip() == "", f"dependencies is no longer empty: {block.strip()!r}"