Merge branch 'main' into renovate/first-party-cachekit

Author: 27Bslash6

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.18.0"
+  ".": "0.19.0"
 }

CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [0.19.0](https://github.com/cachekit-io/cachekit-py/compare/v0.18.0...v0.19.0) (2026-09-22)
+
+
+### ⚠ BREAKING CHANGES
+
+* **logging:** remove dead compat surface and Redis branding from StructuredLogger (LAB-4621) ([#316](https://github.com/cachekit-io/cachekit-py/issues/316))
+* **logging:** `cachekit.logging.UltraOptimizedStructuredLogger` is now `StructuredLogger`; the `cachekit.logging.StructuredRedisLogger` alias is removed; `cachekit.monitoring.pool_monitor.OptimizedPoolMonitor` is now `PoolMonitor`. No deprecation aliases are provided. `get_structured_logger()` is unchanged and remains the supported entry point.
+* **logging:** UltraOptimizedStructuredLogger.__init__ no longer accepts mask_sensitive; get_structured_logger() no longer accepts mask_sensitive and now keys _logger_instances on name alone; mask_sensitive_patterns is removed; ProfileConfig.mask_sensitive_data and ProfileConfig.lazy_pii_masking are removed. All were read by nothing and toggled no behavior. Constructors/callers passing them now raise TypeError instead of silently no-op'ing. Same removal shape as L1CacheConfig.namespace_index in v0.18.0 and L1CacheConfig.invalidation_enabled in v0.16.0 (LAB-520).
+
+### Features
+
+* **backend:** bound L1 backfill by the server's remaining freshness (LAB-557) ([#268](https://github.com/cachekit-io/cachekit-py/issues/268)) ([7bd5abf](https://github.com/cachekit-io/cachekit-py/commit/7bd5abf4ba838600b7ae333715a3575dc587143e))
+* **concurrency:** free-threaded CPython support — memory-ordering fixes, gil_used=false, CI lane (LAB-511) ([#265](https://github.com/cachekit-io/cachekit-py/issues/265)) ([bda770b](https://github.com/cachekit-io/cachekit-py/commit/bda770bce822d9a6eff98e555c5f6fd92e509a9c))
+
+
+### Bug Fixes
+
+* **ci:** fail loudly on attestation lookup failure; decide the codecov pair (LAB-2528) ([#270](https://github.com/cachekit-io/cachekit-py/issues/270)) ([2a8b941](https://github.com/cachekit-io/cachekit-py/commit/2a8b941043e8bc3d9a143428495e13226aed4901))
+* **ci:** make the Atheris fuzz job capable of failing + repair its dead targets (LAB-1140) ([#269](https://github.com/cachekit-io/cachekit-py/issues/269)) ([6ab0c28](https://github.com/cachekit-io/cachekit-py/commit/6ab0c289f8fe1e8891c30b94faed7a3501809e16))
+* **decorators:** async get hits record serializer/size/hit like the sync path (LAB-3765) ([#297](https://github.com/cachekit-io/cachekit-py/issues/297)) ([9b96fd2](https://github.com/cachekit-io/cachekit-py/commit/9b96fd2b90364bd36ef3268bca6ff4df2daafe40))
+* **decorators:** async lock double-check L2 hits record get telemetry (LAB-3769) ([#303](https://github.com/cachekit-io/cachekit-py/issues/303)) ([683b1c7](https://github.com/cachekit-io/cachekit-py/commit/683b1c7cc178948c922683551ae41e6c77beef24))
+* **decorators:** honour set_default_backend() when called after decoration (LAB-4457) ([#313](https://github.com/cachekit-io/cachekit-py/issues/313)) ([d20204c](https://github.com/cachekit-io/cachekit-py/commit/d20204c4f16270e75ffa69e601995bdcc51f700c))
+* **file:** guard eviction unlink against a concurrent rename (LAB-2685) ([#285](https://github.com/cachekit-io/cachekit-py/issues/285)) ([e917a57](https://github.com/cachekit-io/cachekit-py/commit/e917a57c4e6065eb161da8011a26d6805d49c327))
+* **file:** write every byte or fail; evict a payload that shrank under read (LAB-2682) ([#272](https://github.com/cachekit-io/cachekit-py/issues/272)) ([068adb2](https://github.com/cachekit-io/cachekit-py/commit/068adb276c2b1f552b527e4ba91fc2904cd75be5))
+* **logging:** redact raw cache keys on all log paths (LAB-304) ([#264](https://github.com/cachekit-io/cachekit-py/issues/264)) ([81f97fb](https://github.com/cachekit-io/cachekit-py/commit/81f97fb76245e3924bf91b61996e1b4e7639f702))
+* **logging:** sanitise error kwarg at the structured cache-operation sinks (LAB-3666) ([#301](https://github.com/cachekit-io/cachekit-py/issues/301)) ([d27ec29](https://github.com/cachekit-io/cachekit-py/commit/d27ec29e0dbdfdf64e253a6fb5665b4d30639869))
+* **redis:** stop lock waiters pinning executor threads (LAB-3596) ([#290](https://github.com/cachekit-io/cachekit-py/issues/290)) ([ddbeb91](https://github.com/cachekit-io/cachekit-py/commit/ddbeb910a9de7932ed93ebbcad4c8435278831e2))
+* **serializers:** bound forged-entry error echoes; retire columnar dead code (LAB-3131) ([#289](https://github.com/cachekit-io/cachekit-py/issues/289)) ([10a1049](https://github.com/cachekit-io/cachekit-py/commit/10a10498d406bce7b4fd8dff6cb2e88e80f9b0a2))
+* **serializers:** bound untrusted msgpack decode depth and header allocation (LAB-2503) ([#276](https://github.com/cachekit-io/cachekit-py/issues/276)) ([f7c087d](https://github.com/cachekit-io/cachekit-py/commit/f7c087dfbd7972bd711f32054949c1b739e00146))
+* **serializers:** fail closed on unverified DataFrame/Series envelopes (LAB-2736) ([#304](https://github.com/cachekit-io/cachekit-py/issues/304)) ([60da54f](https://github.com/cachekit-io/cachekit-py/commit/60da54fd614717735f831c27831ed4cfe758ea35))
+* **serializers:** take the format from the envelope, not the header; drop the header-gated fall-through (LAB-2736) ([#308](https://github.com/cachekit-io/cachekit-py/issues/308)) ([69db1c5](https://github.com/cachekit-io/cachekit-py/commit/69db1c5ef768195471c0e971965c73e77d2da9cd))
+* **serializers:** type ByteStorage.retrieve failures and collapse duplicated columnar decode (LAB-2736) ([#287](https://github.com/cachekit-io/cachekit-py/issues/287)) ([0aa78ca](https://github.com/cachekit-io/cachekit-py/commit/0aa78ca8dc0749492e6078cdcfe2330743bb202f))
+
+
+### Performance Improvements
+
+* **decorators:** backfill L1 on sync L2 hits; size stats by envelope length (LAB-348) ([#294](https://github.com/cachekit-io/cachekit-py/issues/294)) ([c019b26](https://github.com/cachekit-io/cachekit-py/commit/c019b2659eb964408facb6d7191b85a26177342a))
+
+
+### Code Refactoring
+
+* **logging:** remove dead compat surface and Redis branding from StructuredLogger (LAB-4621) ([#316](https://github.com/cachekit-io/cachekit-py/issues/316)) ([98d616e](https://github.com/cachekit-io/cachekit-py/commit/98d616e6e5f5aec79ba7fe285909f662e8722c00))
+* **logging:** remove dead PII-masking knobs (LAB-3797) ([#300](https://github.com/cachekit-io/cachekit-py/issues/300)) ([705640b](https://github.com/cachekit-io/cachekit-py/commit/705640bde14b73c249ed6d8b30733eb46752a9a2))
+* **logging:** rename UltraOptimizedStructuredLogger to StructuredLogger, OptimizedPoolMonitor to PoolMonitor (LAB-4617) ([#314](https://github.com/cachekit-io/cachekit-py/issues/314)) ([2f7c979](https://github.com/cachekit-io/cachekit-py/commit/2f7c9799d5f9aa46db4134febb6710b72c15d457))
+
 ## [0.18.0](https://github.com/cachekit-io/cachekit-py/compare/v0.17.1...v0.18.0) (2026-09-03)
 
 

Cargo.lock

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cachekit"
-version = "0.18.0"
+version = "0.19.0"
 description = "Backend-agnostic caching for Python — intent-based decorators with circuit breaker, distributed locking, Prometheus metrics, and optional zero-knowledge AES-256-GCM encryption, on a Rust-powered core. Zero-config L1 in-memory; scales to Redis, Memcached, File, or CachekitIO."
 readme = "README.md"
 license = {text = "MIT"}

pyproject.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cachekit-rs"
-version = "0.18.0"
+version = "0.19.0"
 edition = "2021"
 authors = ["cachekit Contributors"]
 description = "High-performance storage engine for caching with compression and encryption"

rust/Cargo.toml

@@ -68,7 +68,7 @@ def custom_function():
     ```
 """
 
-__version__ = "0.18.0"
+__version__ = "0.19.0"
 
 from collections.abc import Callable
 from typing import Any, TypeVar

src/cachekit/__init__.py

@@ -113,7 +113,7 @@ class AsyncLogWriter(threading.Thread):
     """Background thread for async log writing."""
 
     def __init__(self, buffer: LockFreeRingBuffer):
-        super().__init__(daemon=True, name="RedisCache-LogWriter")
+        super().__init__(daemon=True, name="cachekit-LogWriter")
         self.buffer = buffer
         self.running = True
         self._stop_event = threading.Event()
@@ -414,70 +414,12 @@ def _get_context(self) -> dict[str, Any]:
             context["correlation_id"] = self._context.correlation_id
         return context
 
-    # Compatibility methods for tests
-    def redis_operation_failed(self, operation: str, key: str, error: Exception, **kwargs):
-        """Log Redis operation failure. ``cache_operation`` renders the error key-free (CWE-532)."""
-        self.cache_operation(operation, key, error=error, error_type=type(error).__name__, **kwargs)
-
-    def cache_hit(self, key: str, **kwargs):
-        """Log cache hit."""
-        self.cache_operation("get", key, hit=True, **kwargs)
-
-    def cache_miss(self, key: str, **kwargs):
-        """Log cache miss."""
-        self.cache_operation("get", key, hit=False, **kwargs)
-
-    def cache_stored(self, key: str, **kwargs):
-        """Log cache store operation."""
-        self.cache_operation("set", key, **kwargs)
-
-    def serialization_fallback(self, from_serializer: str, to_serializer: str, reason: str, **kwargs):
-        """Log serialization fallback event."""
-
-        # Log the fallback
-        self.warning(
-            f"Serialization fallback: {from_serializer} -> {to_serializer}",
-            from_serializer=from_serializer,
-            to_serializer=to_serializer,
-            reason=reason,
-            **kwargs,
-        )
-
-    def create_span(self, name: str, **kwargs):
-        """Create a simple tracing span context manager."""
-        return SimpleSpan(self, name, **kwargs)
-
     def __del__(self):
         """Cleanup on deletion."""
         if hasattr(self, "writer"):
             self.writer.stop()
 
 
-class SimpleSpan:
-    """Simple span implementation for tracing integration."""
-
-    def __init__(self, logger: StructuredLogger, name: str, **kwargs):
-        self.logger = logger
-        self.name = name
-        self.kwargs = kwargs
-        self.start_time = None
-
-    def __enter__(self):
-        """Start the span."""
-        self.start_time = time.time()
-        # Generate a simple trace ID if not set
-        if not hasattr(self.logger._context, "trace_id") or not self.logger._context.trace_id:
-            trace_id = f"span-{int(time.time() * 1000000)}"
-            self.logger.set_trace_id(trace_id)
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """End the span."""
-        if self.start_time:
-            duration = time.time() - self.start_time
-            self.logger.debug(f"Span completed: {self.name}", span_name=self.name, duration_ms=duration * 1000, **self.kwargs)
-
-
 # Global logger instances cache
 _logger_instances: dict[str, StructuredLogger] = {}
 _logger_lock = threading.Lock()

src/cachekit/logging.py

@@ -285,10 +285,9 @@ async def test_async_get_failure_redacts_key_in_exception_text(self, caplog: pyt
 
 
 class TestStructuredLoggerCacheOperationRedaction:
-    """``StructuredLogger.cache_operation`` is a direct sink.
+    """``StructuredLogger.cache_operation`` is the only structured sink on the class.
 
-    ``cache_hit``/``cache_miss``/``cache_stored`` all funnel through it, so this
-    one method is the whole surface. It must apply the *same* pass-through policy
+    It must apply the *same* pass-through policy
     as the orchestrator sink: a value that arrives already redacted, or is a known
     sentinel, is emitted verbatim. Hashing it a second time would mint a different
     digest for the same key and break correlation between the two sinks
@@ -409,11 +408,13 @@ def test_arbitrary_exception_reduced_to_type_name(self) -> None:
 class TestErrorKwargSanitisedAtSink:
     """An ``error`` kwarg is sanitised once, at each structured sink (CWE-532, defence in depth).
 
-    Three in-tree callers, three shapes: ``handle_cache_error`` pre-renders to a str,
-    ``redis_operation_failed`` passes the exception object, and the circuit-breaker path
-    in ``wrapper.py`` passes a str literal. The sink must emit all three key-free, and a
-    str must pass through untouched (re-sanitising one would emit the literal ``"str"``).
-    The assertion runs over the whole payload, not the ``error`` field alone.
+    Two in-tree callers, both str: ``handle_cache_error`` pre-renders via
+    ``redact_error_for_log``, and the circuit-breaker path in ``wrapper.py`` passes a str
+    literal. The raw-exception shape is kept as defence in depth — ``cache_operation``
+    takes ``**kwargs``, so nothing stops a future caller handing it an exception object,
+    and the sink must render that key-free too. A str must pass through untouched
+    (re-sanitising one would emit the literal ``"str"``). The assertion runs over the
+    whole payload, not the ``error`` field alone.
     """
 
     @pytest.mark.parametrize(("error", "rendered"), ERROR_KWARGS)

tests/unit/test_error_path_key_redaction.py

@@ -8,7 +8,6 @@
 
 import pytest
 
-from cachekit.backends.errors import BackendError, BackendErrorType
 from cachekit.logging import (
     JsonFormatter,
     StructuredLogger,
@@ -116,61 +115,6 @@ def test_cache_operation_error_logging(self, mock_log, logger):
         assert extra["error"] == "Connection timeout"
         assert extra["error_type"] == "TimeoutError"
 
-    @pytest.mark.parametrize(
-        ("error", "rendered", "error_type"),
-        [
-            (ValueError("Test error"), "ValueError", "ValueError"),
-            (BackendError("Redis timeout", error_type=BackendErrorType.TIMEOUT), "BackendError(timeout)", "BackendError"),
-        ],
-        ids=["provider_exception", "backend_error"],
-    )
-    @patch("cachekit.logging.logging.Logger.log")
-    def test_redis_operation_failed_override(self, mock_log, logger, error, rendered, error_type):
-        """redis_operation_failed emits a key-free error representation (CWE-532).
-
-        A non-BackendError's str() has unknown provenance and may echo the raw cache
-        key, so only its type name reaches the log; a BackendError renders as
-        ``TypeName(error_type)``. error_type still carries the Python type.
-        """
-        logger.redis_operation_failed("get", "test_key", error)
-
-        mock_log.assert_called_once()
-        extra = mock_log.call_args[1]["extra"]["structured"]
-        assert extra["operation"] == "get"
-        assert extra["error"] == rendered  # never the raw message
-        assert extra["error_type"] == error_type
-
-    @patch("cachekit.logging.logging.Logger.log")
-    def test_cache_hit_override(self, mock_log, logger):
-        """Test cache_hit override."""
-        logger.cache_hit("test_key", source="memory")
-
-        mock_log.assert_called_once()
-        extra = mock_log.call_args[1]["extra"]["structured"]
-        assert extra["operation"] == "get"
-        assert extra["hit"] is True
-        assert extra["source"] == "memory"
-
-    @patch("cachekit.logging.logging.Logger.log")
-    def test_cache_miss_override(self, mock_log, logger):
-        """Test cache_miss override."""
-        logger.cache_miss("test_key")
-
-        mock_log.assert_called_once()
-        extra = mock_log.call_args[1]["extra"]["structured"]
-        assert extra["operation"] == "get"
-        assert extra["hit"] is False
-
-    @patch("cachekit.logging.logging.Logger.log")
-    def test_cache_stored_override(self, mock_log, logger):
-        """Test cache_stored override."""
-        logger.cache_stored("test_key", ttl=300)
-
-        mock_log.assert_called_once()
-        extra = mock_log.call_args[1]["extra"]["structured"]
-        assert extra["operation"] == "set"
-        assert extra["ttl"] == 300
-
     def test_thread_safety(self, logger):
         """Test thread-local context isolation."""
         results = {}