Revert "Drop deprecated logging handler (elastic#2348)"

This reverts commit 4b0c8e9.

Author: xrmx

elasticapm/conf/__init__.py

@@ -883,6 +883,10 @@ def setup_logging(handler):
 
     For a typical Python install:
 
+    >>> from elasticapm.handlers.logging import LoggingHandler
+    >>> client = ElasticAPM(...)
+    >>> setup_logging(LoggingHandler(client))
+
     Returns a boolean based on if logging was configured or not.
     """
     # TODO We should probably revisit this. Does it make more sense as

elasticapm/contrib/flask/__init__.py

@@ -82,9 +82,6 @@ def __init__(self, app=None, client=None, client_cls=Client, **defaults) -> None
         self.client = client or get_client()
         self.client_cls = client_cls
 
-        if "logging" in defaults:
-            raise ValueError("Flask log shipping has been removed, drop the ElasticAPM logging parameter")
-
         if app:
             self.init_app(app, **defaults)
 

elasticapm/handlers/logging.py

@@ -32,11 +32,181 @@
 from __future__ import absolute_import
 
 import logging
+import sys
+import traceback
+import warnings
 
 import wrapt
 
 from elasticapm import get_client
+from elasticapm.base import Client
 from elasticapm.traces import execution_context
+from elasticapm.utils.stacks import iter_stack_frames
+
+
+class LoggingHandler(logging.Handler):
+    def __init__(self, *args, **kwargs) -> None:
+        warnings.warn(
+            "The LoggingHandler is deprecated and will be removed in v7.0 of "
+            "the agent. Please use `log_ecs_reformatting` and ship the logs "
+            "with Elastic Agent or Filebeat instead. "
+            "https://www.elastic.co/guide/en/apm/agent/python/current/logs.html",
+            DeprecationWarning,
+        )
+        self.client = None
+        if "client" in kwargs:
+            self.client = kwargs.pop("client")
+        elif len(args) > 0:
+            arg = args[0]
+            if isinstance(arg, Client):
+                self.client = arg
+
+        if not self.client:
+            client_cls = kwargs.pop("client_cls", None)
+            if client_cls:
+                self.client = client_cls(*args, **kwargs)
+            else:
+                warnings.warn(
+                    "LoggingHandler requires a Client instance. No Client was received.",
+                    DeprecationWarning,
+                )
+                self.client = Client(*args, **kwargs)
+        logging.Handler.__init__(self, level=kwargs.get("level", logging.NOTSET))
+
+    def emit(self, record):
+        self.format(record)
+
+        # Avoid typical config issues by overriding loggers behavior
+        if record.name.startswith(("elasticapm.errors",)):
+            sys.stderr.write(record.getMessage() + "\n")
+            return
+
+        try:
+            return self._emit(record)
+        except Exception:
+            sys.stderr.write("Top level ElasticAPM exception caught - failed creating log record.\n")
+            sys.stderr.write(record.getMessage() + "\n")
+            sys.stderr.write(traceback.format_exc() + "\n")
+
+            try:
+                self.client.capture("Exception")
+            except Exception:
+                pass
+
+    def _emit(self, record, **kwargs):
+        data = {}
+
+        for k, v in record.__dict__.items():
+            if "." not in k and k not in ("culprit",):
+                continue
+            data[k] = v
+
+        stack = getattr(record, "stack", None)
+        if stack is True:
+            stack = iter_stack_frames(config=self.client.config)
+
+        if stack:
+            frames = []
+            started = False
+            last_mod = ""
+            for item in stack:
+                if isinstance(item, (list, tuple)):
+                    frame, lineno = item
+                else:
+                    frame, lineno = item, item.f_lineno
+
+                if not started:
+                    f_globals = getattr(frame, "f_globals", {})
+                    module_name = f_globals.get("__name__", "")
+                    if last_mod.startswith("logging") and not module_name.startswith("logging"):
+                        started = True
+                    else:
+                        last_mod = module_name
+                        continue
+                frames.append((frame, lineno))
+            stack = frames
+
+        custom = getattr(record, "data", {})
+        # Add in all of the data from the record that we aren't already capturing
+        for k in record.__dict__.keys():
+            if k in (
+                "stack",
+                "name",
+                "args",
+                "msg",
+                "levelno",
+                "exc_text",
+                "exc_info",
+                "data",
+                "created",
+                "levelname",
+                "msecs",
+                "relativeCreated",
+            ):
+                continue
+            if k.startswith("_"):
+                continue
+            custom[k] = record.__dict__[k]
+
+        # If there's no exception being processed,
+        # exc_info may be a 3-tuple of None
+        # http://docs.python.org/library/sys.html#sys.exc_info
+        if record.exc_info and all(record.exc_info):
+            handler = self.client.get_handler("elasticapm.events.Exception")
+            exception = handler.capture(self.client, exc_info=record.exc_info)
+        else:
+            exception = None
+
+        return self.client.capture(
+            "Message",
+            param_message={"message": str(record.msg), "params": record.args},
+            stack=stack,
+            custom=custom,
+            exception=exception,
+            level=record.levelno,
+            logger_name=record.name,
+            **kwargs,
+        )
+
+
+class LoggingFilter(logging.Filter):
+    """
+    This filter doesn't actually do any "filtering" -- rather, it just adds
+    three new attributes to any "filtered" LogRecord objects:
+
+    * elasticapm_transaction_id
+    * elasticapm_trace_id
+    * elasticapm_span_id
+    * elasticapm_service_name
+
+    These attributes can then be incorporated into your handlers and formatters,
+    so that you can tie log messages to transactions in elasticsearch.
+
+    This filter also adds these fields to a dictionary attribute,
+    `elasticapm_labels`, using the official tracing fields names as documented
+    here: https://www.elastic.co/guide/en/ecs/current/ecs-tracing.html
+
+    Note that if you're using Python 3.2+, by default we will add a
+    LogRecordFactory to your root logger which will add these attributes
+    automatically.
+    """
+
+    def __init__(self, name=""):
+        super().__init__(name=name)
+        warnings.warn(
+            "The LoggingFilter is deprecated and will be removed in v7.0 of "
+            "the agent. On Python 3.2+, by default we add a LogRecordFactory to "
+            "your root logger automatically"
+            "https://www.elastic.co/guide/en/apm/agent/python/current/logs.html",
+            DeprecationWarning,
+        )
+
+    def filter(self, record):
+        """
+        Add elasticapm attributes to `record`.
+        """
+        _add_attributes_to_log_record(record)
+        return True
 
 
 @wrapt.decorator

tests/contrib/flask/flask_tests.py

@@ -50,11 +50,6 @@
 pytestmark = pytest.mark.flask
 
 
-def test_logging_parameter_raises_exception():
-    with pytest.raises(ValueError, match="Flask log shipping has been removed, drop the ElasticAPM logging parameter"):
-        ElasticAPM(config=None, logging=True)
-
-
 def test_error_handler(flask_apm_client):
     client = flask_apm_client.app.test_client()
     response = client.get("/an-error/")