@@ -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()
 
@@ -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)
 
@@ -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 = {}