Add NIF-based logging and tracing for Python-Erlang integration

Implement fire-and-forget logging from Python's logging module to Erlang's
logger, plus distributed tracing with span support.

Features:
- py:configure_logging/0,1 - Forward Python logs to Erlang logger
- py:enable_tracing/0, py:disable_tracing/0 - Control span collection
- py:get_traces/0, py:clear_traces/0 - Retrieve collected spans
- Python erlang.Span context manager for tracing
- Python @erlang.trace() decorator for function tracing
- Level filtering at NIF level for performance

Architecture:
- Uses enif_send() for non-blocking message delivery
- py_logger gen_server receives log messages
- py_tracer gen_server collects trace spans
- Both added to supervision tree

Files:
- c_src/py_logging.c - NIF implementations
- src/py_logger.erl - Log message receiver
- src/py_tracer.erl - Span collector
- test/py_logging_SUITE.erl - 9 tests
- docs/logging.md - Documentation
- examples/logging_example.erl - Working example

Author: benoitc

README.md

@@ -29,6 +29,8 @@ Key features:
 - **Streaming** - Iterate over Python generators chunk-by-chunk
 - **Virtual environments** - Activate venvs for dependency isolation
 - **AI/ML ready** - Examples for embeddings, semantic search, RAG, and LLMs
+- **Logging integration** - Python logging forwarded to Erlang logger
+- **Distributed tracing** - Span-based tracing from Python code
 
 ## Requirements
 
@@ -320,6 +322,71 @@ ok = py:activate_venv(<<"/path/to/venv">>).
 ok = py:deactivate_venv().
 ```
 
+## Logging and Tracing
+
+### Python Logging to Erlang Logger
+
+Forward Python `logging` messages to Erlang's `logger`:
+
+```erlang
+%% Configure Python logging
+ok = py:configure_logging(#{level => info}).
+
+%% Python logs now appear in Erlang logger
+ok = py:exec(<<"
+import logging
+logging.info('Hello from Python!')
+logging.warning('Something needs attention')
+">>).
+```
+
+From Python, you can also set up logging explicitly:
+
+```python
+import erlang
+erlang.setup_logging(level=20)  # 20 = INFO
+```
+
+### Distributed Tracing
+
+Collect trace spans from Python code:
+
+```erlang
+%% Enable tracing
+ok = py:enable_tracing().
+
+%% Run Python code with spans
+ok = py:exec(<<"
+import erlang
+
+with erlang.Span('process-request', user_id=123):
+    with erlang.Span('query-database'):
+        pass  # database work
+    with erlang.Span('format-response'):
+        pass  # formatting work
+">>).
+
+%% Retrieve collected spans
+{ok, Spans} = py:get_traces().
+%% Spans = [#{name => <<"query-database">>, status => ok, duration_us => 42, ...}, ...]
+
+%% Clean up
+ok = py:clear_traces().
+ok = py:disable_tracing().
+```
+
+Use the `@erlang.trace()` decorator for automatic function tracing:
+
+```python
+import erlang
+
+@erlang.trace()
+def my_function():
+    return compute_something()
+```
+
+See [docs/logging.md](docs/logging.md) for details.
+
 ## Examples
 
 The `examples/` directory contains runnable demonstrations:
@@ -360,6 +427,11 @@ escript examples/erlang_concurrency.erl
 elixir --erl "-pa _build/default/lib/erlang_python/ebin" examples/elixir_example.exs
 ```
 
+### Logging and Tracing
+```bash
+escript examples/logging_example.erl
+```
+
 ## API Reference
 
 ### Function Calls
@@ -407,6 +479,22 @@ ok = py:tracemalloc_start().
 ok = py:tracemalloc_stop().
 ```
 
+### Logging
+
+```erlang
+ok = py:configure_logging().
+ok = py:configure_logging(#{level => info, format => <<"%(name)s: %(message)s">>}).
+```
+
+### Tracing
+
+```erlang
+ok = py:enable_tracing().
+ok = py:disable_tracing().
+{ok, Spans} = py:get_traces().
+ok = py:clear_traces().
+```
+
 ## Type Mappings
 
 ### Erlang to Python
@@ -482,6 +570,8 @@ py:execution_mode().  %% => free_threaded | subinterp | multi_executor
 - [Scalability](docs/scalability.md)
 - [Streaming](docs/streaming.md)
 - [Threading](docs/threading.md)
+- [Logging and Tracing](docs/logging.md)
+- [Sandbox](docs/sandbox.md)
 - [Changelog](https://github.com/benoitc/erlang-python/releases)
 
 ## License

c_src/py_callback.c

@@ -1300,6 +1300,19 @@ static PyMethodDef ErlangModuleMethods[] = {
     {"_register_async_future", register_async_future, METH_VARARGS,
      "Register a Future for an async callback.\n"
      "Usage: erlang._register_async_future(callback_id, future)"},
+    /* Logging and tracing (from py_logging.c) */
+    {"_log", erlang_log_impl, METH_VARARGS,
+     "Log message to Erlang logger (fire-and-forget).\n"
+     "Usage: erlang._log(level, logger_name, message, metadata)"},
+    {"_trace_start", erlang_trace_start_impl, METH_VARARGS,
+     "Start a trace span.\n"
+     "Usage: erlang._trace_start(name, span_id, parent_id, attrs)"},
+    {"_trace_end", erlang_trace_end_impl, METH_VARARGS,
+     "End a trace span.\n"
+     "Usage: erlang._trace_end(span_id, status, attrs)"},
+    {"_trace_event", erlang_trace_event_impl, METH_VARARGS,
+     "Add event to a span.\n"
+     "Usage: erlang._trace_event(span_id, name, attrs)"},
     {NULL, NULL, 0, NULL}
 };
 
@@ -1452,6 +1465,126 @@ static int create_erlang_module(void) {
         Py_DECREF(globals);
     }
 
+    /* Inject logging and tracing Python code */
+    const char *erlang_logging_code =
+        "import logging\n"
+        "import threading\n"
+        "import random\n"
+        "\n"
+        "class ErlangHandler(logging.Handler):\n"
+        "    '''Logging handler that forwards log records to Erlang logger.'''\n"
+        "    def emit(self, record):\n"
+        "        try:\n"
+        "            msg = self.format(record)\n"
+        "            meta = {'module': record.module, 'lineno': record.lineno,\n"
+        "                    'funcName': record.funcName}\n"
+        "            erlang._log(record.levelno, record.name, msg, meta)\n"
+        "        except:\n"
+        "            pass\n"
+        "\n"
+        "def setup_logging(level=10, format=None):\n"
+        "    '''Set up Python logging to forward to Erlang.\n"
+        "    \n"
+        "    Args:\n"
+        "        level: Minimum log level (10=DEBUG, 20=INFO, 30=WARNING, etc.)\n"
+        "        format: Optional format string\n"
+        "    \n"
+        "    Returns:\n"
+        "        The created ErlangHandler instance\n"
+        "    '''\n"
+        "    handler = ErlangHandler()\n"
+        "    if format:\n"
+        "        handler.setFormatter(logging.Formatter(format))\n"
+        "    else:\n"
+        "        handler.setFormatter(logging.Formatter('%(message)s'))\n"
+        "    root = logging.getLogger()\n"
+        "    root.addHandler(handler)\n"
+        "    root.setLevel(level)\n"
+        "    return handler\n"
+        "\n"
+        "# Thread-local span context for tracing\n"
+        "_span_ctx = threading.local()\n"
+        "\n"
+        "class Span:\n"
+        "    '''Context manager for tracing spans.\n"
+        "    \n"
+        "    Usage:\n"
+        "        with erlang.Span('operation-name', key='value') as span:\n"
+        "            do_work()\n"
+        "            span.event('checkpoint', items=10)\n"
+        "    '''\n"
+        "    def __init__(self, name, **attrs):\n"
+        "        self.name = name\n"
+        "        self.span_id = random.getrandbits(64)\n"
+        "        self.attrs = attrs\n"
+        "        self._prev = None\n"
+        "\n"
+        "    def __enter__(self):\n"
+        "        self._prev = getattr(_span_ctx, 'current', None)\n"
+        "        _span_ctx.current = self.span_id\n"
+        "        erlang._trace_start(self.name, self.span_id, self._prev, self.attrs)\n"
+        "        return self\n"
+        "\n"
+        "    def __exit__(self, et, ev, tb):\n"
+        "        status = 'error' if et else 'ok'\n"
+        "        attrs = {}\n"
+        "        if et:\n"
+        "            attrs['exception'] = str(ev)\n"
+        "        erlang._trace_end(self.span_id, status, attrs)\n"
+        "        _span_ctx.current = self._prev\n"
+        "        return False\n"
+        "\n"
+        "    def event(self, name, **attrs):\n"
+        "        '''Add an event to this span.'''\n"
+        "        erlang._trace_event(self.span_id, name, attrs)\n"
+        "\n"
+        "def trace(name=None):\n"
+        "    '''Decorator to trace a function.\n"
+        "    \n"
+        "    Usage:\n"
+        "        @erlang.trace()\n"
+        "        def my_function():\n"
+        "            pass\n"
+        "    '''\n"
+        "    def decorator(fn):\n"
+        "        span_name = name or f'{fn.__module__}.{fn.__qualname__}'\n"
+        "        def wrapper(*a, **kw):\n"
+        "            with Span(span_name):\n"
+        "                return fn(*a, **kw)\n"
+        "        return wrapper\n"
+        "    return decorator\n"
+        "\n"
+        "# Add to erlang module\n"
+        "erlang.ErlangHandler = ErlangHandler\n"
+        "erlang.setup_logging = setup_logging\n"
+        "erlang.Span = Span\n"
+        "erlang.trace = trace\n";
+
+    PyObject *log_globals = PyDict_New();
+    if (log_globals != NULL) {
+        PyObject *builtins = PyEval_GetBuiltins();
+        PyDict_SetItemString(log_globals, "__builtins__", builtins);
+
+        /* Import erlang module into globals so the code can reference it */
+        PyObject *sys_modules = PySys_GetObject("modules");
+        if (sys_modules != NULL) {
+            PyObject *erlang_mod = PyDict_GetItemString(sys_modules, "erlang");
+            if (erlang_mod != NULL) {
+                PyDict_SetItemString(log_globals, "erlang", erlang_mod);
+            }
+        }
+
+        PyObject *result = PyRun_String(erlang_logging_code, Py_file_input, log_globals, log_globals);
+        if (result == NULL) {
+            /* Non-fatal - logging features just won't be available */
+            PyErr_Print();
+            PyErr_Clear();
+        } else {
+            Py_DECREF(result);
+        }
+        Py_DECREF(log_globals);
+    }
+
     return 0;
 }