structguru 1.2.0__tar.gz → 1.2.2__tar.gz

{structguru-1.2.0 → structguru-1.2.2}/Cargo.lock

@@ -26,32 +26,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
-[[package]]
-name = "cfg-if"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
-
-[[package]]
-name = "chacha20"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "rand_core",
-]
-
-[[package]]
-name = "cpufeatures"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "deranged"
 version = "0.5.8"
@@ -70,16 +44,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "getrandom"
-version = "0.4.3"
+name = "fastrand"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
-dependencies = [
- "cfg-if",
- "libc",
- "r-efi",
- "rand_core",
-]
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
 [[package]]
 name = "heck"
@@ -204,29 +172,6 @@ dependencies = [
  "proc-macro2",
 ]
 
-[[package]]
-name = "r-efi"
-version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
-
-[[package]]
-name = "rand"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
-dependencies = [
- "chacha20",
- "getrandom",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
-
 [[package]]
 name = "regex"
 version = "1.13.1"
@@ -300,10 +245,10 @@ dependencies = [
 
 [[package]]
 name = "structguru-core"
-version = "1.2.0"
+version = "1.2.2"
 dependencies = [
  "fancy-regex",
- "rand",
+ "fastrand",
  "regex",
  "serde",
  "serde_json",
@@ -312,7 +257,7 @@ dependencies = [
 
 [[package]]
 name = "structguru-py"
-version = "1.2.0"
+version = "1.2.2"
 dependencies = [
  "pyo3",
  "regex",

{structguru-1.2.0 → structguru-1.2.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/structguru-core", "crates/structguru-py"]
 resolver = "2"
 
 [workspace.package]
-version = "1.2.0"
+version = "1.2.2"
 edition = "2024"
 rust-version = "1.89"
 license = "MIT"
@@ -25,7 +25,7 @@ codegen-units = 1
 strip = true
 
 [workspace.dependencies]
-pyo3 = { version = "0.29.0" }
+pyo3 = { version = "0.29.2" }
 serde = { version = "1.0" }
 serde_json = { version = "1.0", features = ["raw_value"] }
 time = { version = "0.3", features = ["macros", "formatting"] }
@@ -35,11 +35,8 @@ regex = { version = "1", default-features = false, features = ["std", "unicode"]
 # Backtracking engine for opt-in look-around/backreference redaction patterns
 # (`allow_backtracking_patterns=True`); never used unless explicitly requested.
 fancy-regex = { version = "0.19", default-features = false, features = ["std", "unicode"] }
-# Only `rand::random` is used (sampling filter); `thread_rng` pulls in the
-# std/sys_rng machinery it needs.
-rand = { version = "0.10", default-features = false, features = [
-    "std",
-    "std_rng",
-    "thread_rng",
-] }
+# Only a per-thread `f64` draw is needed (sampling filter). fastrand's WyRand
+# generator has no transitive dependencies on the wheel targets, unlike rand's
+# ChaCha-based thread RNG.
+fastrand = { version = "2.5" }
 structguru-core = { path = "crates/structguru-core" }

{structguru-1.2.0 → structguru-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structguru
-Version: 1.2.0
+Version: 1.2.2
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -141,16 +141,16 @@ logger.info("User {user_id} logged in", user_id=42, ip="10.0.0.1")
 
 ```python
 log = logger.bind(request_id="abc-123", user="alice")
-log.info("Processing request")   # includes request_id and user
-log.info("Request complete")     # same context carried through
+log.info("Processing request")  # includes request_id and user
+log.info("Request complete")  # same context carried through
 ```
 
 ### Request-scoped context
 
 ```python
 with logger.contextualize(request_id="abc-123"):
-    logger.info("Handling request")   # includes request_id
-    do_work()                         # any logging inside also gets request_id
+    logger.info("Handling request")  # includes request_id
+    do_work()  # any logging inside also gets request_id
 # request_id removed automatically
 ```
 
@@ -200,7 +200,7 @@ been written:
 import structguru
 
 logger.info("checkpoint")
-structguru.flush()   # returns once the line has reached its sink
+structguru.flush()  # returns once the line has reached its sink
 ```
 
 ### Console vs JSON output
@@ -454,6 +454,7 @@ bridge = install_stdlib_bridge(
 )
 
 import logging
+
 logging.getLogger("sqlalchemy.engine").info("SELECT 1")
 # → {"logger":"sqlalchemy.engine","level":"INFO",...,"message":"SELECT 1"}
 ```

{structguru-1.2.0 → structguru-1.2.2}/README.md

@@ -97,16 +97,16 @@ logger.info("User {user_id} logged in", user_id=42, ip="10.0.0.1")
 
 ```python
 log = logger.bind(request_id="abc-123", user="alice")
-log.info("Processing request")   # includes request_id and user
-log.info("Request complete")     # same context carried through
+log.info("Processing request")  # includes request_id and user
+log.info("Request complete")  # same context carried through
 ```
 
 ### Request-scoped context
 
 ```python
 with logger.contextualize(request_id="abc-123"):
-    logger.info("Handling request")   # includes request_id
-    do_work()                         # any logging inside also gets request_id
+    logger.info("Handling request")  # includes request_id
+    do_work()  # any logging inside also gets request_id
 # request_id removed automatically
 ```
 
@@ -156,7 +156,7 @@ been written:
 import structguru
 
 logger.info("checkpoint")
-structguru.flush()   # returns once the line has reached its sink
+structguru.flush()  # returns once the line has reached its sink
 ```
 
 ### Console vs JSON output
@@ -410,6 +410,7 @@ bridge = install_stdlib_bridge(
 )
 
 import logging
+
 logging.getLogger("sqlalchemy.engine").info("SELECT 1")
 # → {"logger":"sqlalchemy.engine","level":"INFO",...,"message":"SELECT 1"}
 ```

{structguru-1.2.0 → structguru-1.2.2}/crates/structguru-core/Cargo.toml

@@ -19,4 +19,4 @@ serde_json.workspace = true
 time.workspace = true
 regex.workspace = true
 fancy-regex.workspace = true
-rand.workspace = true
+fastrand.workspace = true

{structguru-1.2.0 → structguru-1.2.2}/crates/structguru-core/src/filter.rs

@@ -8,8 +8,6 @@ use std::collections::{HashMap, VecDeque};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
-use rand::random;
-
 /// Outcome of a pre-render filter check.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Decision {
@@ -71,7 +69,7 @@ impl RecordFilter for Sampler {
         if self.rate <= 0.0 {
             return Decision::Drop;
         }
-        if random::<f64>() < self.rate {
+        if fastrand::f64() < self.rate {
             Decision::Keep
         } else {
             Decision::Drop

{structguru-1.2.0 → structguru-1.2.2}/crates/structguru-core/src/render.rs

@@ -183,21 +183,22 @@ fn redact_patterns(value: &mut Value, patterns: &[RedactionPattern], replacement
     }
 }
 
-fn redact_message(
-    message: &str,
+fn redact_text(
+    key: &str,
+    text: &str,
     sensitive_keys: Option<&Vec<String>>,
     sensitive_patterns: Option<&[RedactionPattern]>,
     pattern_replacement: Option<&str>,
 ) -> String {
-    let message_is_sensitive = match sensitive_keys {
-        Some(custom) => is_sensitive("message", custom),
-        None => is_sensitive("message", DEFAULT_SENSITIVE_KEYS),
+    let key_is_sensitive = match sensitive_keys {
+        Some(custom) => is_sensitive(key, custom),
+        None => is_sensitive(key, DEFAULT_SENSITIVE_KEYS),
     };
-    if message_is_sensitive {
+    if key_is_sensitive {
         return REDACTED.to_owned();
     }
 
-    let mut value = Value::String(message.to_owned());
+    let mut value = Value::String(text.to_owned());
     if let Some(patterns) = sensitive_patterns {
         redact_patterns(
             &mut value,
@@ -206,7 +207,7 @@ fn redact_message(
         );
     }
     let Value::String(redacted) = value else {
-        unreachable!("message redaction preserves the string value variant");
+        unreachable!("text redaction preserves the string value variant");
     };
     redacted
 }
@@ -238,7 +239,8 @@ pub fn render_line(
     sensitive_patterns: Option<&[RedactionPattern]>,
     pattern_replacement: Option<&str>,
 ) -> Result<String, serde_json::Error> {
-    let redacted_message = redact_message(
+    let redacted_message = redact_text(
+        "message",
         message,
         sensitive_keys.as_ref(),
         sensitive_patterns,
@@ -285,7 +287,14 @@ pub fn render_line(
     // "stack" sits between "service" and "message": StackInfoRenderer runs
     // after add_service and before EventRenamer in the shared chain.
     if let Some(stack) = stack {
-        upsert(&mut entries, "stack", Value::String(stack.to_owned()));
+        let redacted_stack = redact_text(
+            "stack",
+            stack,
+            sensitive_keys.as_ref(),
+            sensitive_patterns,
+            pattern_replacement,
+        );
+        upsert(&mut entries, "stack", Value::String(redacted_stack));
     }
     upsert(&mut entries, "message", Value::String(redacted_message));
 
@@ -380,7 +389,8 @@ pub fn render_line_console(
     pattern_replacement: Option<&str>,
     stack: Option<&str>,
 ) -> String {
-    let redacted_message = redact_message(
+    let redacted_message = redact_text(
+        "message",
         message,
         sensitive_keys.as_ref(),
         sensitive_patterns,
@@ -440,8 +450,15 @@ pub fn render_line_console(
     let _ = (logger, service);
 
     if let Some(stack) = stack {
+        let redacted_stack = redact_text(
+            "stack",
+            stack,
+            sensitive_keys.as_ref(),
+            sensitive_patterns,
+            pattern_replacement,
+        );
         out.push('\n');
-        out.push_str(stack);
+        out.push_str(&redacted_stack);
     }
     out
 }
@@ -519,6 +536,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn stack_redaction_applies_patterns_and_custom_keys_in_both_formats() {
+        let patterns = vec![RedactionPattern::linear(r"(token=)\w+").unwrap()];
+        for keys in [None, Some(vec!["STACK".to_owned()])] {
+            let expected = if keys.is_some() {
+                "[REDACTED]"
+            } else {
+                "frame\ntoken=[MASKED]"
+            };
+            let json = render_line(
+                vec![],
+                "l",
+                "info",
+                "svc",
+                "trace",
+                "TS",
+                Some("frame\ntoken=REVIEW_SENTINEL"),
+                keys.clone(),
+                Some(&patterns),
+                Some("$1[MASKED]"),
+            )
+            .unwrap();
+            let record: serde_json::Value = serde_json::from_str(&json).unwrap();
+            assert_eq!(record["stack"], expected);
+            let console = render_line_console(
+                vec![],
+                "l",
+                "info",
+                "svc",
+                "trace",
+                false,
+                "TS",
+                keys,
+                Some(&patterns),
+                Some("$1[MASKED]"),
+                Some("frame\ntoken=REVIEW_SENTINEL"),
+            );
+            assert_eq!(console, format!("TS [INFO    ] trace\n{expected}"));
+        }
+    }
+
     #[test]
     fn redacts_sensitive_keys_including_nested_and_case_insensitive() {
         let fields = vec![

{structguru-1.2.0 → structguru-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "structguru"
-version = "1.2.0"
+version = "1.2.2"
 description = "Native structured logging with a loguru-style Python API"
 readme = "README.md"
 license = "MIT"
@@ -54,35 +54,35 @@ dev = [
     { include-group = "bench" },
 ]
 test = [
-    "pytest>=8.0",
-    "pytest-asyncio>=0.23",
-    "pytest-cov>=7.0.0",
-    "pytest-httpserver>=1.0.0",
-    "responses>=0.25.0",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "pytest-cov>=7.1.0",
+    "pytest-httpserver>=1.1.5",
+    "responses>=0.26.3",
     # structlog + orjson are kept as test-only deps for the golden parity suite
     # (which compares native output against the standard structlog/orjson path).
-    "structlog>=24.1.0",
-    "orjson>=3.9.0",
+    "structlog>=26.1.0",
+    "orjson>=3.12.0",
     # fastapi drives the full-stack example smoke test (examples/full_stack_fastapi);
     # celery/sqlalchemy/httpx it also needs come from the integration extras.
-    "fastapi>=0.110",
+    "fastapi>=0.141.1",
 ]
 lint = [
-    "mypy>=1.8",
-    "ruff>=0.4",
+    "mypy>=2.3.1",
+    "ruff>=0.16.6",
 ]
 docs = [
     "mkdocs>=1.6.1",
-    "mkdocs-material>=9.7.6",
-    "mkdocstrings[python]>=1.0.4",
+    "mkdocs-material>=9.7.7",
+    "mkdocstrings[python]>=1.0.6",
 ]
 bench = [
-    "pytest-benchmark>=5.2.3",
+    "pytest-benchmark>=5.3.0",
     "loguru>=0.7.3",
 ]
 free-threaded = [
-    "pytest>=8.0",
-    "pytest-benchmark>=5.2.3",
+    "pytest>=9.1.1",
+    "pytest-benchmark>=5.3.0",
 ]
 
 [tool.maturin]

{structguru-1.2.0 → structguru-1.2.2}/src/structguru/__init__.py

@@ -19,7 +19,7 @@ from structguru.metrics import MetricProcessor
 from structguru.otel import add_otel_context
 from structguru.redaction import DEFAULT_SENSITIVE_KEYS
 
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 
 __all__ = [
     "DEFAULT_SENSITIVE_KEYS",

{structguru-1.2.0 → structguru-1.2.2}/src/structguru/_native_dispatch.py

@@ -26,13 +26,11 @@ class _DispatchChannel:
     """One queue generation with producer-aware shutdown semantics."""
 
     def __init__(self, maxsize: int) -> None:
-        self.queue: queue.Queue[_Record | object] = queue.Queue(maxsize=maxsize)
+        self.queue: queue.Queue[_Record] = queue.Queue(maxsize=maxsize)
         self.maxsize = maxsize
         self._condition = threading.Condition()
         self._accepting = True
         self._producers = 0
-        self._close_from_worker = False
-        self._stop_token = object()
         self.thread = threading.Thread(target=self._loop, daemon=True)
         self.thread.start()
 
@@ -68,34 +66,40 @@ class _DispatchChannel:
             while self._producers:
                 self._condition.wait()
         self.queue.join()
+        with self._condition:
+            retired = not self._accepting
+        if retired:
+            self.thread.join()
 
-    def close(self, *, drain: bool) -> None:
-        """Reject new producers and stop after every accepted producer finishes."""
-        is_worker = threading.current_thread() is self.thread
+    def retire(self) -> None:
+        """Reject new producers without waiting for callbacks or queue space."""
         with self._condition:
             self._accepting = False
             self._condition.notify_all()
-            if is_worker:
-                # The callback currently running on the worker may itself disable
-                # logging. Let the loop drain accepted producers and exit naturally;
-                # blocking here would deadlock a producer waiting for queue space.
-                self._close_from_worker = True
-                return
-            while self._producers:
-                self._condition.wait()
 
+    def close(self, *, drain: bool) -> None:
+        """Reject new producers and stop after every accepted producer finishes."""
+        self.retire()
+        if threading.current_thread() is self.thread:
+            return
         if drain:
-            self.queue.join()
-        self.queue.put(self._stop_token)
+            self.flush()
         self.thread.join()
 
     def _loop(self) -> None:
         while True:
-            item = self.queue.get()
-            if item is self._stop_token:
-                self.queue.task_done()
-                return
-            assert isinstance(item, _Record)
+            with self._condition:
+                # Producers notify after insertion, including when a reserved
+                # producer finishes after retirement. No stop token can be left
+                # behind if several callers close the same generation.
+                self._condition.wait_for(
+                    lambda: (
+                        not self.queue.empty() or (not self._accepting and self._producers == 0)
+                    )
+                )
+                if self.queue.empty():
+                    return
+                item = self.queue.get_nowait()
             for sink in item.sinks:
                 try:
                     sink.callback(item.line)
@@ -103,50 +107,40 @@ class _DispatchChannel:
                     pass
             self.queue.task_done()
 
-            with self._condition:
-                should_exit = (
-                    self._close_from_worker and self._producers == 0 and self.queue.empty()
-                )
-            if should_exit:
-                return
-
 
 class CallableSinkDispatcher:
     """Own callable-sink registration, queueing, lifecycle, and metrics."""
 
     def __init__(self) -> None:
         self._lock = threading.Lock()
-        self._transition_lock = threading.RLock()
         self._configured: list[_Sink] = []
         self._runtime: dict[int, _Sink] = {}
         self._tokens = itertools.count(1)
         self._maxsize = 1024
         self._channel: _DispatchChannel | None = None
+        # Retired generations remain visible until drained, so concurrent
+        # remove/flush/shutdown cannot overlook callbacks still using a sink.
+        self._channels: set[_DispatchChannel] = set()
         self._dropped = 0
 
     def add(self, callback: Callable[[str], None], min_level: int, *, enabled: bool) -> int:
         """Register a runtime sink, starting dispatch when logging is enabled."""
         token = next(self._tokens)
-        with self._transition_lock, self._lock:
+        with self._lock:
             self._runtime[token] = _Sink(token, callback, min_level)
             if enabled and self._channel is None:
                 self._channel = _DispatchChannel(self._maxsize)
+                self._channels.add(self._channel)
         return token
 
     def remove(self, token: int) -> bool:
         """Remove one sink, then drain every record that captured it."""
-        with self._transition_lock:
-            with self._lock:
-                removed = self._runtime.pop(token, None) is not None
-                channel = self._channel
-                should_stop = not (self._configured or self._runtime)
-                if should_stop:
-                    self._channel = None
-            if channel is not None:
-                if should_stop:
-                    channel.close(drain=True)
-                else:
-                    channel.flush()
+        with self._lock:
+            removed = self._runtime.pop(token, None) is not None
+            if not (self._configured or self._runtime):
+                self._retire_active()
+            channels = tuple(self._channels)
+        self._drain(channels)
         return removed
 
     def configure(
@@ -159,27 +153,44 @@ class CallableSinkDispatcher:
         new_configured = [
             _Sink(-index, callback, 0) for index, callback in enumerate(callbacks, 1)
         ]
-        with self._transition_lock:
-            with self._lock:
-                old_channel = self._channel
-                self._configured = new_configured
-                self._maxsize = maxsize
-                self._dropped = 0
-                self._channel = (
-                    _DispatchChannel(maxsize) if self._configured or self._runtime else None
-                )
-            if old_channel is not None:
-                old_channel.close(drain=True)
+        with self._lock:
+            self._retire_active()
+            channels = tuple(self._channels)
+            self._configured = new_configured
+            self._maxsize = maxsize
+            self._dropped = 0
+            if self._configured or self._runtime:
+                self._channel = _DispatchChannel(maxsize)
+                self._channels.add(self._channel)
+        self._drain(channels)
 
     def disable(self) -> None:
         """Stop dispatch and remove configured sinks while preserving runtime registrations."""
-        with self._transition_lock:
-            with self._lock:
-                channel = self._channel
-                self._channel = None
-                self._configured = []
-            if channel is not None:
-                channel.close(drain=True)
+        with self._lock:
+            self._retire_active()
+            self._configured = []
+            channels = tuple(self._channels)
+        self._drain(channels)
+
+    def _retire_active(self) -> None:
+        """Retire the active generation; caller must hold ``_lock``."""
+        if self._channel is not None:
+            self._channel.retire()
+            self._channel = None
+
+    def _drain(self, channels: tuple[_DispatchChannel, ...]) -> None:
+        """Wait outside state locks, except when invoked by a sink callback."""
+        current = threading.current_thread()
+        # A callback cannot wait for itself, or for another generation whose
+        # callback may be waiting for this one. An external lifecycle call will
+        # still find and drain every retired generation in _channels.
+        if not any(current is channel.thread for channel in channels):
+            for channel in channels:
+                channel.flush()
+        with self._lock:
+            self._channels.difference_update(
+                channel for channel in channels if not channel.thread.is_alive()
+            )
 
     def enqueue(self, line: str, level: int, *, overflow: str) -> bool:
         """Queue one rendered record; return false when delivery is rejected."""
@@ -204,28 +215,26 @@ class CallableSinkDispatcher:
     def flush(self) -> None:
         """Block until all queued deliveries have completed."""
         with self._lock:
-            channel = self._channel
-        if channel is not None:
-            channel.flush()
+            channels = tuple(self._channels)
+        self._drain(channels)
 
     def stop(self, *, drain: bool) -> None:
         """Stop the active dispatch queue while preserving registrations."""
-        with self._transition_lock:
-            with self._lock:
-                channel = self._channel
-                self._channel = None
-            if channel is not None:
-                channel.close(drain=drain)
+        with self._lock:
+            self._retire_active()
+            channels = tuple(self._channels)
+        # Even drain=False previously joined behind all accepted queue entries.
+        self._drain(channels)
 
     def after_fork(self, *, enabled: bool) -> None:
         """Replace inherited synchronization state and restart in a forked child."""
         self._lock = threading.Lock()
-        self._transition_lock = threading.RLock()
         self._channel = (
             _DispatchChannel(self._maxsize)
             if enabled and (self._configured or self._runtime)
             else None
         )
+        self._channels = {self._channel} if self._channel is not None else set()
 
     def metrics(self) -> dict[str, int]:
         """Return callable dispatch queue and drop metrics."""

{structguru-1.2.0 → structguru-1.2.2}/src/structguru/integrations/celery.py

@@ -67,11 +67,6 @@ def setup_celery_logging(
     ) -> None:
         clear_contextvars()
 
-        if task_id:
-            bind_contextvars(task_id=task_id)
-        if task:
-            bind_contextvars(task_name=task.name)
-
         if propagate_context and task:
             request = task.request
             ctx: dict[str, Any] | None = None
@@ -82,6 +77,13 @@ def setup_celery_logging(
             if isinstance(ctx, dict):
                 bind_contextvars(**ctx)
 
+        # A producer may itself be a task. Its propagated identity must never
+        # replace the consumer's identity; correlation fields still propagate.
+        if task_id:
+            bind_contextvars(task_id=task_id)
+        if task:
+            bind_contextvars(task_name=task.name)
+
     @task_postrun.connect(weak=False)  # type: ignore[untyped-decorator]
     def _clear_context(**_kw: Any) -> None:
         clear_contextvars()

{structguru-1.2.0 → structguru-1.2.2}/src/structguru/integrations/sentry.py

@@ -104,17 +104,18 @@ class SentryProcessor:
             return event_dict
 
         level = _METHOD_TO_LEVEL.get(method_name.lower(), logging.INFO)
+        # Raw exceptions are reserved for capture_exception. The SDK serializes
+        # arbitrary objects in breadcrumbs/extras, which would bypass redaction.
+        payload = {
+            k: v for k, v in event_dict.items() if k not in ("exc_info", REDACTED_MARKER_KEY)
+        }
 
         if level >= self._breadcrumb_level:
             _sentry_sdk.add_breadcrumb(
                 message=str(event_dict.get("event", "")),
                 category="structguru",
                 level=method_name,
-                data={
-                    k: v
-                    for k, v in event_dict.items()
-                    if k != "event" and k != REDACTED_MARKER_KEY
-                },
+                data={k: v for k, v in payload.items() if k != "event"},
             )
 
         if level < self._event_level:
@@ -122,12 +123,11 @@ class SentryProcessor:
 
         with _sentry_sdk.new_scope() as scope:
             for key in self._tag_keys:
-                if key in event_dict:
-                    scope.set_tag(key, str(event_dict[key]))
+                if key in payload:
+                    scope.set_tag(key, str(payload[key]))
 
             if not self._require_redaction or event_dict.get(REDACTED_MARKER_KEY):
-                extras = {k: v for k, v in event_dict.items() if k != REDACTED_MARKER_KEY}
-                scope.set_extra("structlog_event", extras)
+                scope.set_extra("structlog_event", payload)
 
             exc_info = event_dict.get("exc_info")
             if exc_info: