docs: Clarify log processor error handling expectations

Add documentation to LogRecordProcessor, LogRecordExporter, and
SimpleLogRecordProcessor explaining error handling responsibilities:

- LogRecordProcessor: Clarifies that custom implementations must handle
  exceptions from exporter.export() to prevent application crashes
- LogRecordExporter: Documents that export() may raise exceptions and
  processors are responsible for handling them
- SimpleLogRecordProcessor: Highlights it as a reference implementation
  for proper error handling

This addresses confusion where custom LogRecordProcessor implementations
were not handling exceptions, causing unhandled exceptions to crash
applications when network errors or timeouts occurred during export.

Fixes #4724

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: cabaret-pro

CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+- `opentelemetry-sdk`: Clarify log processor error handling expectations in documentation
+  ([#4915](https://github.com/open-telemetry/opentelemetry-python/pull/4915))
 - `opentelemetry-sdk`: Clarify timeout units in environment variable documentation
   ([#4906](https://github.com/open-telemetry/opentelemetry-python/pull/4906))
 - `opentelemetry-exporter-otlp-proto-grpc`: Fix re-initialization of gRPC channel on UNAVAILABLE error

opentelemetry-sdk/src/opentelemetry/sdk/_logs/_internal/__init__.py

@@ -293,11 +293,43 @@ class LogRecordProcessor(abc.ABC):
     Log processors can be registered directly using
     :func:`LoggerProvider.add_log_record_processor` and they are invoked
     in the same order as they were registered.
+
+    Implementers of custom log processors should be aware of the following:
+
+    Error Handling
+    --------------
+    According to the OpenTelemetry error handling principles, the SDK should
+    not throw unhandled exceptions at runtime. When implementing a custom
+    ``LogRecordProcessor``, it is the **processor's responsibility** to handle
+    any exceptions that may be raised by the exporter's ``export()`` method.
+
+    The ``LogRecordExporter.export()`` method may raise exceptions (e.g.,
+    network errors, timeouts). If these exceptions are not caught, they will
+    propagate up and potentially crash the application.
+
+    Custom processor implementations should wrap exporter calls in a
+    try/except block. See ``SimpleLogRecordProcessor`` for a reference
+    implementation::
+
+        def on_emit(self, log_record: ReadWriteLogRecord):
+            try:
+                self._exporter.export((log_record,))
+            except Exception:  # pylint: disable=broad-exception-caught
+                logger.exception("Exception while exporting logs.")
+
+    The ``BatchLogRecordProcessor`` handles this implicitly since export
+    operations occur in a background thread where exceptions cannot bubble
+    up to the caller.
     """
 
     @abc.abstractmethod
     def on_emit(self, log_record: ReadWriteLogRecord):
-        """Emits the `ReadWriteLogRecord`"""
+        """Emits the ``ReadWriteLogRecord``.
+
+        Implementers should handle any exceptions raised during log processing
+        to prevent application crashes. See the class docstring for details
+        on error handling expectations.
+        """
 
     @abc.abstractmethod
     def shutdown(self):

opentelemetry-sdk/src/opentelemetry/sdk/_logs/_internal/export/__init__.py

@@ -73,21 +73,39 @@ class LogExportResult(enum.Enum):
 
 class LogRecordExporter(abc.ABC):
     """Interface for exporting logs.
+
     Interface to be implemented by services that want to export logs received
     in their own format.
-    To export data this MUST be registered to the :class`opentelemetry.sdk._logs.Logger` using a
-    log processor.
+
+    To export data this MUST be registered to the :class:`opentelemetry.sdk._logs.Logger`
+    using a log processor.
+
+    Important
+    ---------
+    The ``export()`` method may raise exceptions (e.g., network errors,
+    timeouts, serialization errors). It is the responsibility of the
+    ``LogRecordProcessor`` calling this exporter to handle these exceptions
+    appropriately to prevent application crashes. See ``LogRecordProcessor``
+    for guidance on implementing proper error handling.
     """
 
     @abc.abstractmethod
     def export(
         self, batch: Sequence[ReadableLogRecord]
     ) -> LogRecordExportResult:
         """Exports a batch of logs.
+
         Args:
-            batch: The list of `ReadableLogRecord` objects to be exported
+            batch: The list of ``ReadableLogRecord`` objects to be exported.
+
         Returns:
-            The result of the export
+            The result of the export.
+
+        Raises:
+            Exception: This method may raise exceptions on network errors,
+                timeouts, or other failures. Callers (i.e., log processors)
+                should handle these exceptions to comply with OpenTelemetry
+                error handling principles.
         """
 
     @abc.abstractmethod
@@ -141,8 +159,15 @@ class ConsoleLogExporter(ConsoleLogRecordExporter):
 
 
 class SimpleLogRecordProcessor(LogRecordProcessor):
-    """This is an implementation of LogRecordProcessor which passes
-    received logs directly to the configured LogRecordExporter, as soon as they are emitted.
+    """Implementation of LogRecordProcessor that exports logs synchronously.
+
+    This processor passes received logs directly to the configured
+    ``LogRecordExporter`` as soon as they are emitted.
+
+    This class serves as a reference implementation for custom log processors,
+    demonstrating proper error handling. Note how the ``on_emit`` method wraps
+    the exporter call in a try/except block to prevent exceptions from
+    propagating to the application.
     """
 
     def __init__(self, exporter: LogRecordExporter):