Address review comments: add docstring, default max_baggage_attributes=128, multiple predicates test and README example

Author: Manvi2402

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))

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 <https://opentelemetry.io/>`_

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
+        return True
+    

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()
+    unittest.main()
+