From 3449a3d9a2067c2923433d7fd4d293eafe855d11 Mon Sep 17 00:00:00 2001 From: manvi Date: Tue, 31 Mar 2026 08:45:43 +0530 Subject: [PATCH 1/9] Add BaggageLogProcessor and address review comments --- CHANGELOG.md | 2 + .../README.rst | 35 ++++++ .../processor/baggage/__init__.py | 5 +- .../processor/baggage/log_processor.py | 70 +++++++++++ .../tests/test_baggage_log_processor.py | 117 ++++++++++++++++++ 5 files changed, 226 insertions(+), 3 deletions(-) create mode 100644 processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py create mode 100644 processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c9c67be4bb..3049706c2f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## Unreleased ### Added +- Add `BaggageLogProcessor` to `opentelemetry-processor-baggage` + ([#4062](https://github.com/open-telemetry/opentelemetry-python-contrib/issues/4062)) - `opentelemetry-instrumentation-confluent-kafka`: Loosen confluent-kafka upper bound to <3.0.0 ([#4289](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/4289)) diff --git a/processor/opentelemetry-processor-baggage/README.rst b/processor/opentelemetry-processor-baggage/README.rst index 9c49a6ff758..4371d6975f9 100644 --- a/processor/opentelemetry-processor-baggage/README.rst +++ b/processor/opentelemetry-processor-baggage/README.rst @@ -65,6 +65,41 @@ For example, to only copy baggage entries that match the regex `^key.+`: regex_predicate = lambda baggage_key: baggage_key.startswith("^key.+") tracer_provider.add_span_processor(BaggageSpanProcessor(regex_predicate)) +BaggageLogProcessor +------------------- + +The BaggageLogProcessor reads entries stored in Baggage +from the current context and adds the baggage entries' keys and +values to the log record as attributes on emit. + +Add this log processor to a logger provider. + +To configure the log processor to copy all baggage entries: + +:: + + from opentelemetry.processor.baggage import BaggageLogProcessor, ALLOW_ALL_BAGGAGE_KEYS + + logger_provider = LoggerProvider() + logger_provider.add_log_record_processor(BaggageLogProcessor(ALLOW_ALL_BAGGAGE_KEYS)) + + +Alternatively, you can provide a custom baggage key predicate to select which baggage keys you want to copy. + +For example, to only copy baggage entries that start with `my-key`: + +:: + + starts_with_predicate = lambda baggage_key: baggage_key.startswith("my-key") + logger_provider.add_log_record_processor(BaggageLogProcessor(starts_with_predicate)) + + +For example, to only copy baggage entries that match the regex `^key.+`: + +:: + + regex_predicate = lambda baggage_key: re.match(r"^key.+", baggage_key) is not None + logger_provider.add_log_record_processor(BaggageLogProcessor(regex_predicate)) References ---------- diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py index fcff749d644..99b764bad8b 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py @@ -13,8 +13,7 @@ # limitations under the License. # pylint: disable=import-error - from .processor import ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor +from .log_processor import BaggageLogProcessor from .version import __version__ - -__all__ = ["ALLOW_ALL_BAGGAGE_KEYS", "BaggageSpanProcessor", "__version__"] +__all__ = ["ALLOW_ALL_BAGGAGE_KEYS", "BaggageSpanProcessor", "BaggageLogProcessor", "__version__"] \ No newline at end of file diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py new file mode 100644 index 00000000000..b5b09a6f4b9 --- /dev/null +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py @@ -0,0 +1,70 @@ +# Copyright The OpenTelemetry Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Callable, Optional, Sequence, Union + +from opentelemetry.baggage import get_all as get_all_baggage +from opentelemetry.sdk._logs import LogRecordProcessor, ReadWriteLogRecord + +from opentelemetry.processor.baggage.processor import BaggageKeyPredicateT + +BaggageKeyPredicatesT = Union[BaggageKeyPredicateT, Sequence[BaggageKeyPredicateT]] + + +class BaggageLogProcessor(LogRecordProcessor): + """ + The BaggageLogProcessor reads entries stored in Baggage + from the current context and adds the baggage entries' keys and + values to the log record as attributes on emit. + + Add this log processor to a logger provider. + + ⚠ Warning ⚠️ + + Do not put sensitive information in Baggage. + + To repeat: a consequence of adding data to Baggage is that the keys and + values will appear in all outgoing HTTP headers from the application. + """ + + def __init__( + self, + baggage_key_predicate: BaggageKeyPredicatesT, + max_baggage_attributes: Optional[int] = None, + ) -> None: + if callable(baggage_key_predicate): + self._predicates = [baggage_key_predicate] + else: + self._predicates = list(baggage_key_predicate) + self._max_baggage_attributes = max_baggage_attributes + + def _matches(self, key: str) -> bool: + return any(predicate(key) for predicate in self._predicates) + + def on_emit(self, log_record: ReadWriteLogRecord) -> None: + baggage = get_all_baggage() + count = 0 + for key, value in baggage.items(): + if self._max_baggage_attributes is not None and count >= self._max_baggage_attributes: + break + if self._matches(key): + if key not in log_record.log_record.attributes: + log_record.log_record.attributes[key] = value + count += 1 + + def shutdown(self) -> None: + pass + + def force_flush(self, timeout_millis: int = 30000) -> bool: + return True \ No newline at end of file diff --git a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py new file mode 100644 index 00000000000..186d7b0026c --- /dev/null +++ b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py @@ -0,0 +1,117 @@ +# Copyright The OpenTelemetry Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import re +import unittest + +from opentelemetry.baggage import set_baggage +from opentelemetry.context import attach, detach +from opentelemetry.processor.baggage import ( + ALLOW_ALL_BAGGAGE_KEYS, + BaggageLogProcessor, +) +from opentelemetry.sdk._logs import LoggerProvider, LogRecordProcessor +from opentelemetry.sdk._logs.export import ( + InMemoryLogRecordExporter, + BatchLogRecordProcessor, +) + + +class BaggageLogProcessorTest(unittest.TestCase): + def setUp(self): + self.exporter = InMemoryLogRecordExporter() + self.logger_provider = LoggerProvider() + self.logger_provider.add_log_record_processor( + BaggageLogProcessor(ALLOW_ALL_BAGGAGE_KEYS) + ) + self.logger_provider.add_log_record_processor( + BatchLogRecordProcessor(self.exporter) + ) + self.logger = self.logger_provider.get_logger("test-logger") + + def _get_attributes(self): + self.logger_provider.force_flush() + logs = self.exporter.get_finished_logs() + self.assertTrue(len(logs) > 0) + return logs[-1].log_record.attributes + + def test_check_the_baggage(self): + self.assertIsInstance( + BaggageLogProcessor(ALLOW_ALL_BAGGAGE_KEYS), LogRecordProcessor + ) + + def test_baggage_added_to_log_record(self): + token = attach(set_baggage("queen", "bee")) + self.logger.emit(None) + attributes = self._get_attributes() + self.assertEqual(attributes.get("queen"), "bee") + detach(token) + + def test_baggage_with_prefix(self): + token = attach(set_baggage("queen", "bee")) + logger_provider = LoggerProvider() + logger_provider.add_log_record_processor( + BaggageLogProcessor(lambda key: key.startswith("que")) + ) + exporter = InMemoryLogRecordExporter() + logger_provider.add_log_record_processor( + BatchLogRecordProcessor(exporter) + ) + logger = logger_provider.get_logger("test-logger") + logger.emit(None) + logger_provider.force_flush() + logs = exporter.get_finished_logs() + attributes = logs[-1].log_record.attributes + self.assertEqual(attributes.get("queen"), "bee") + detach(token) + + def test_baggage_with_regex(self): + token = attach(set_baggage("queen", "bee")) + logger_provider = LoggerProvider() + logger_provider.add_log_record_processor( + BaggageLogProcessor( + lambda key: re.match(r"que.*", key) is not None + ) + ) + exporter = InMemoryLogRecordExporter() + logger_provider.add_log_record_processor( + BatchLogRecordProcessor(exporter) + ) + logger = logger_provider.get_logger("test-logger") + logger.emit(None) + logger_provider.force_flush() + logs = exporter.get_finished_logs() + attributes = logs[-1].log_record.attributes + self.assertEqual(attributes.get("queen"), "bee") + detach(token) + + def test_no_baggage_not_added(self): + self.logger.emit(None) + self.logger_provider.force_flush() + logs = self.exporter.get_finished_logs() + self.assertTrue(len(logs) > 0) + attributes = logs[-1].log_record.attributes + self.assertNotIn("queen", attributes) + + @staticmethod + def has_prefix(baggage_key: str) -> bool: + return baggage_key.startswith("que") + + @staticmethod + def matches_regex(baggage_key: str) -> bool: + return re.match(r"que.*", baggage_key) is not None + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 391c2dde84ac8924c5480554a67f3fe9d20d1f2c Mon Sep 17 00:00:00 2001 From: manvi Date: Wed, 1 Apr 2026 08:29:40 +0530 Subject: [PATCH 2/9] Address review comments: add docstring, default max_baggage_attributes=128, multiple predicates test and README example --- CHANGELOG.md | 2 +- .../README.rst | 10 +++++++ .../processor/baggage/log_processor.py | 22 +++++++++++----- .../tests/test_baggage_log_processor.py | 26 ++++++++++++++++++- 4 files changed, 52 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3049706c2f5..90a696ffa67 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Add `BaggageLogProcessor` to `opentelemetry-processor-baggage` - ([#4062](https://github.com/open-telemetry/opentelemetry-python-contrib/issues/4062)) + ([#4371](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/4371)) - `opentelemetry-instrumentation-confluent-kafka`: Loosen confluent-kafka upper bound to <3.0.0 ([#4289](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/4289)) diff --git a/processor/opentelemetry-processor-baggage/README.rst b/processor/opentelemetry-processor-baggage/README.rst index 4371d6975f9..f8dfe4e9f5a 100644 --- a/processor/opentelemetry-processor-baggage/README.rst +++ b/processor/opentelemetry-processor-baggage/README.rst @@ -101,6 +101,16 @@ For example, to only copy baggage entries that match the regex `^key.+`: regex_predicate = lambda baggage_key: re.match(r"^key.+", baggage_key) is not None logger_provider.add_log_record_processor(BaggageLogProcessor(regex_predicate)) +For example, to copy baggage entries matching multiple predicates: + +:: + + multiple_predicates = [ + lambda baggage_key: baggage_key.startswith("my-key"), + lambda baggage_key: baggage_key.startswith("other-key"), + ] + logger_provider.add_log_record_processor(BaggageLogProcessor(multiple_predicates)) + References ---------- * `OpenTelemetry Project `_ diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py index b5b09a6f4b9..cf0b1af1440 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py @@ -12,14 +12,14 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Callable, Optional, Sequence, Union +from typing import Sequence, Union from opentelemetry.baggage import get_all as get_all_baggage from opentelemetry.sdk._logs import LogRecordProcessor, ReadWriteLogRecord from opentelemetry.processor.baggage.processor import BaggageKeyPredicateT -BaggageKeyPredicatesT = Union[BaggageKeyPredicateT, Sequence[BaggageKeyPredicateT]] +_BaggageKeyPredicatesT = Union[BaggageKeyPredicateT, Sequence[BaggageKeyPredicateT]] class BaggageLogProcessor(LogRecordProcessor): @@ -40,8 +40,8 @@ class BaggageLogProcessor(LogRecordProcessor): def __init__( self, - baggage_key_predicate: BaggageKeyPredicatesT, - max_baggage_attributes: Optional[int] = None, + baggage_key_predicate: _BaggageKeyPredicatesT, + max_baggage_attributes: int = 128, ) -> None: if callable(baggage_key_predicate): self._predicates = [baggage_key_predicate] @@ -53,10 +53,19 @@ def _matches(self, key: str) -> bool: return any(predicate(key) for predicate in self._predicates) def on_emit(self, log_record: ReadWriteLogRecord) -> None: + """Add baggage entries as log record attributes on emit. + + Baggage keys are filtered using the provided predicate(s). + If a baggage key already exists in the log record attributes, + it will not be overwritten to avoid collisions with attributes + added by stdlib logging, calls to logging.emit, or custom + LogRecordProcessors. At most max_baggage_attributes baggage + entries will be added. + """ baggage = get_all_baggage() count = 0 for key, value in baggage.items(): - if self._max_baggage_attributes is not None and count >= self._max_baggage_attributes: + if count >= self._max_baggage_attributes: break if self._matches(key): if key not in log_record.log_record.attributes: @@ -67,4 +76,5 @@ def shutdown(self) -> None: pass def force_flush(self, timeout_millis: int = 30000) -> bool: - return True \ No newline at end of file + return True + \ No newline at end of file diff --git a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py index 186d7b0026c..267e5f73888 100644 --- a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py +++ b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py @@ -111,7 +111,31 @@ def has_prefix(baggage_key: str) -> bool: @staticmethod def matches_regex(baggage_key: str) -> bool: return re.match(r"que.*", baggage_key) is not None + def test_multiple_predicates(self): + token1 = attach(set_baggage("queen", "bee")) + token2 = attach(set_baggage("king", "cobra")) + logger_provider = LoggerProvider() + logger_provider.add_log_record_processor( + BaggageLogProcessor([ + lambda key: key.startswith("que"), + lambda key: key.startswith("kin"), + ]) + ) + exporter = InMemoryLogRecordExporter() + logger_provider.add_log_record_processor( + BatchLogRecordProcessor(exporter) + ) + logger = logger_provider.get_logger("test-logger") + logger.emit(None) + logger_provider.force_flush() + logs = exporter.get_finished_logs() + attributes = logs[-1].log_record.attributes + self.assertEqual(attributes.get("queen"), "bee") + self.assertEqual(attributes.get("king"), "cobra") + detach(token2) + detach(token1) if __name__ == "__main__": - unittest.main() \ No newline at end of file + unittest.main() + \ No newline at end of file From 992c5065ba219ba74ba2d979c7937eb51c87c686 Mon Sep 17 00:00:00 2001 From: manvi Date: Fri, 3 Apr 2026 12:42:57 +0530 Subject: [PATCH 3/9] Add test for max_baggage_attributes limit --- .../tests/test_baggage_log_processor.py | 38 +++++++++++++++---- 1 file changed, 30 insertions(+), 8 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py index 267e5f73888..1b3f3f185e1 100644 --- a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py +++ b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py @@ -104,13 +104,6 @@ def test_no_baggage_not_added(self): attributes = logs[-1].log_record.attributes self.assertNotIn("queen", attributes) - @staticmethod - def has_prefix(baggage_key: str) -> bool: - return baggage_key.startswith("que") - - @staticmethod - def matches_regex(baggage_key: str) -> bool: - return re.match(r"que.*", baggage_key) is not None def test_multiple_predicates(self): token1 = attach(set_baggage("queen", "bee")) token2 = attach(set_baggage("king", "cobra")) @@ -135,7 +128,36 @@ def test_multiple_predicates(self): detach(token2) detach(token1) + def test_max_baggage_attributes_limit(self): + token1 = attach(set_baggage("key1", "val1")) + token2 = attach(set_baggage("key2", "val2")) + token3 = attach(set_baggage("key3", "val3")) + logger_provider = LoggerProvider() + logger_provider.add_log_record_processor( + BaggageLogProcessor(ALLOW_ALL_BAGGAGE_KEYS, max_baggage_attributes=2) + ) + exporter = InMemoryLogRecordExporter() + logger_provider.add_log_record_processor( + BatchLogRecordProcessor(exporter) + ) + logger = logger_provider.get_logger("test-logger") + logger.emit(None) + logger_provider.force_flush() + logs = exporter.get_finished_logs() + attributes = logs[-1].log_record.attributes + self.assertEqual(len(attributes), 2) + detach(token3) + detach(token2) + detach(token1) + + @staticmethod + def has_prefix(baggage_key: str) -> bool: + return baggage_key.startswith("que") + + @staticmethod + def matches_regex(baggage_key: str) -> bool: + return re.match(r"que.*", baggage_key) is not None + if __name__ == "__main__": unittest.main() - \ No newline at end of file From 51e977426ed7010899f39dbcfb7c70f89873765f Mon Sep 17 00:00:00 2001 From: manvi Date: Wed, 8 Apr 2026 18:31:21 +0530 Subject: [PATCH 4/9] Fix precommit and pylint issues in BaggageLogProcessor --- .../processor/baggage/log_processor.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py index cf0b1af1440..d9fa7676c1d 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py @@ -15,11 +15,12 @@ from typing import Sequence, Union from opentelemetry.baggage import get_all as get_all_baggage -from opentelemetry.sdk._logs import LogRecordProcessor, ReadWriteLogRecord - from opentelemetry.processor.baggage.processor import BaggageKeyPredicateT +from opentelemetry.sdk._logs import LogRecordProcessor, ReadWriteLogRecord -_BaggageKeyPredicatesT = Union[BaggageKeyPredicateT, Sequence[BaggageKeyPredicateT]] +BaggageKeyPredicate = Union[ + BaggageKeyPredicateT, Sequence[BaggageKeyPredicateT] +] class BaggageLogProcessor(LogRecordProcessor): @@ -40,7 +41,7 @@ class BaggageLogProcessor(LogRecordProcessor): def __init__( self, - baggage_key_predicate: _BaggageKeyPredicatesT, + baggage_key_predicate: BaggageKeyPredicate, max_baggage_attributes: int = 128, ) -> None: if callable(baggage_key_predicate): @@ -75,6 +76,6 @@ def on_emit(self, log_record: ReadWriteLogRecord) -> None: def shutdown(self) -> None: pass - def force_flush(self, timeout_millis: int = 30000) -> bool: + @staticmethod + def force_flush(timeout_millis: int = 30000) -> bool: return True - \ No newline at end of file From f90ab6c7852e5d90c65d0e03306f2ee927fb9d51 Mon Sep 17 00:00:00 2001 From: manvi Date: Thu, 9 Apr 2026 21:10:41 +0530 Subject: [PATCH 5/9] Update BaggageSpanProcessor to support multiple predicates for consistency --- .../opentelemetry/processor/baggage/processor.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/processor.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/processor.py index 7e09e591e05..dd3e2a0e533 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/processor.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/processor.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Callable, Optional +from typing import Callable, Optional, Sequence, Union from opentelemetry.baggage import get_all as get_all_baggage from opentelemetry.context import Context @@ -21,6 +21,9 @@ # A BaggageKeyPredicate is a function that takes a baggage key and returns a boolean BaggageKeyPredicateT = Callable[[str], bool] +BaggageKeyPredicates = Union[ + BaggageKeyPredicateT, Sequence[BaggageKeyPredicateT] +] # A BaggageKeyPredicate that always returns True, allowing all baggage keys to be added to spans ALLOW_ALL_BAGGAGE_KEYS: BaggageKeyPredicateT = lambda _: True # noqa: E731 @@ -50,13 +53,16 @@ class BaggageSpanProcessor(SpanProcessor): """ - def __init__(self, baggage_key_predicate: BaggageKeyPredicateT) -> None: - self._baggage_key_predicate = baggage_key_predicate + def __init__(self, baggage_key_predicate: BaggageKeyPredicates) -> None: + if callable(baggage_key_predicate): + self._predicates = [baggage_key_predicate] + else: + self._predicates = list(baggage_key_predicate) def on_start( self, span: "Span", parent_context: Optional[Context] = None ) -> None: baggage = get_all_baggage(parent_context) for key, value in baggage.items(): - if self._baggage_key_predicate(key): + if any(predicate(key) for predicate in self._predicates): span.set_attribute(key, value) From 2e2e42d31a114c4d5df3127d2180035e977da67c Mon Sep 17 00:00:00 2001 From: manvi Date: Tue, 14 Apr 2026 17:37:09 +0530 Subject: [PATCH 6/9] Fix unsorted imports and missing newlines --- .../opentelemetry/processor/baggage/__init__.py | 10 ++++++++-- .../tests/test_baggage_log_processor.py | 16 ++++++++++------ 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py index 99b764bad8b..2941bdeb8f1 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/__init__.py @@ -13,7 +13,13 @@ # limitations under the License. # pylint: disable=import-error -from .processor import ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor from .log_processor import BaggageLogProcessor +from .processor import ALLOW_ALL_BAGGAGE_KEYS, BaggageSpanProcessor from .version import __version__ -__all__ = ["ALLOW_ALL_BAGGAGE_KEYS", "BaggageSpanProcessor", "BaggageLogProcessor", "__version__"] \ No newline at end of file + +__all__ = [ + "ALLOW_ALL_BAGGAGE_KEYS", + "BaggageSpanProcessor", + "BaggageLogProcessor", + "__version__", +] diff --git a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py index 1b3f3f185e1..44fe768adc4 100644 --- a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py +++ b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py @@ -23,8 +23,8 @@ ) from opentelemetry.sdk._logs import LoggerProvider, LogRecordProcessor from opentelemetry.sdk._logs.export import ( - InMemoryLogRecordExporter, BatchLogRecordProcessor, + InMemoryLogRecordExporter, ) @@ -109,10 +109,12 @@ def test_multiple_predicates(self): token2 = attach(set_baggage("king", "cobra")) logger_provider = LoggerProvider() logger_provider.add_log_record_processor( - BaggageLogProcessor([ - lambda key: key.startswith("que"), - lambda key: key.startswith("kin"), - ]) + BaggageLogProcessor( + [ + lambda key: key.startswith("que"), + lambda key: key.startswith("kin"), + ] + ) ) exporter = InMemoryLogRecordExporter() logger_provider.add_log_record_processor( @@ -134,7 +136,9 @@ def test_max_baggage_attributes_limit(self): token3 = attach(set_baggage("key3", "val3")) logger_provider = LoggerProvider() logger_provider.add_log_record_processor( - BaggageLogProcessor(ALLOW_ALL_BAGGAGE_KEYS, max_baggage_attributes=2) + BaggageLogProcessor( + ALLOW_ALL_BAGGAGE_KEYS, max_baggage_attributes=2 + ) ) exporter = InMemoryLogRecordExporter() logger_provider.add_log_record_processor( From 51a39fc2e8f6dc607fb6005b9652b85049d0e4b0 Mon Sep 17 00:00:00 2001 From: manvi Date: Wed, 15 Apr 2026 10:35:29 +0530 Subject: [PATCH 7/9] Fix force_flush signature to match base class --- .../src/opentelemetry/processor/baggage/log_processor.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py index d9fa7676c1d..3fa09c44538 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py @@ -76,6 +76,5 @@ def on_emit(self, log_record: ReadWriteLogRecord) -> None: def shutdown(self) -> None: pass - @staticmethod - def force_flush(timeout_millis: int = 30000) -> bool: + def force_flush(self, timeout_millis: int = 30000) -> bool: return True From 953f1d4abb5a38c2ac6862d6d72da0148f495c8c Mon Sep 17 00:00:00 2001 From: Leighton Chen Date: Thu, 7 May 2026 14:28:01 -0500 Subject: [PATCH 8/9] Update license comments in log_processor.py Replaced Apache License comments with SPDX identifier. --- .../processor/baggage/log_processor.py | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py index 3fa09c44538..1150a9a427c 100644 --- a/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py +++ b/processor/opentelemetry-processor-baggage/src/opentelemetry/processor/baggage/log_processor.py @@ -1,16 +1,5 @@ # Copyright The OpenTelemetry Authors -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. +# SPDX-License-Identifier: Apache-2.0 from typing import Sequence, Union From 46578e0ef6e8baca09b25ac949c3902489a4bb1d Mon Sep 17 00:00:00 2001 From: Leighton Chen Date: Thu, 7 May 2026 14:28:31 -0500 Subject: [PATCH 9/9] Update license header to SPDX format Replaced Apache License header with SPDX identifier. --- .../tests/test_baggage_log_processor.py | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py index 44fe768adc4..00ee9586262 100644 --- a/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py +++ b/processor/opentelemetry-processor-baggage/tests/test_baggage_log_processor.py @@ -1,16 +1,5 @@ # Copyright The OpenTelemetry Authors -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. +# SPDX-License-Identifier: Apache-2.0 import re import unittest