Logging - websockets 10.4 documentation
Description: Logs contents: When you run a WebSocket client, your code calls coroutines provided by websockets. If an error occurs, websockets tells you by raising an exception. For example, it raises a Connect...

Hide navigation sidebar
Hide table of contents sidebar
Back to top
Toggle table of contents sidebar

# Logging

## Logs contents

When you run a WebSocket client, your code calls coroutines provided by websockets.

If an error occurs, websockets tells you by raising an exception. For example, it raises a `ConnectionClosed` exception if the other side closes the connection.

When you run a WebSocket server, websockets accepts connections, performs the opening handshake, runs the connection handler coroutine that you provided, and performs the closing handshake.

Given this inversion of control, if an error happens in the opening handshake or if the connection handler crashes, there is no way to raise an exception that you can handle.

Logs tell you about these errors.

Besides errors, you may want to record the activity of the server.

In a request/response protocol such as HTTP, there’s an obvious way to record activity: log one event per request/response. Unfortunately, this solution doesn’t work well for a bidirectional protocol such as WebSocket.

Instead, when running as a server, websockets logs one event when a connection is established and another event when a connection is closed.

By default, websockets doesn’t log an event for every message. That would be excessive for many applications exchanging small messages at a fast rate. If you need this level of detail, you could add logging in your own code.

Finally, you can enable debug logs to get details about everything websockets is doing. This can be useful when developing clients as well as servers.

See log levels below for a list of events logged by websockets logs at each log level.

## Configure logging

websockets relies on the `logging` module from the standard library in order to maximize compatibility and integrate nicely with other libraries:

    import logging

websockets logs to the `"websockets.client"` and `"websockets.server"` loggers.

websockets doesn’t provide a default logging configuration because requirements vary a lot depending on the environment.

Here’s a basic configuration for a server in production:

    logging.basicConfig(
        format="%(asctime)s %(message)s",
        level=logging.INFO,
    )

Here’s how to enable debug logs for development:

    logging.basicConfig(
        format="%(message)s",
        level=logging.DEBUG,
    )

Furthermore, websockets adds a `websocket` attribute to log records, so you can include additional information about the current connection in logs.

You could attempt to add information with a formatter:

    # this doesn't work!
    logging.basicConfig(
        format="{asctime} {websocket.id} {websocket.remote_address[0]} {message}",
        level=logging.INFO,
        style="{",
    )

However, this technique runs into two problems:

- The formatter applies to all records. It will crash if it receives a record without a `websocket` attribute. For example, this happens when logging that the server starts because there is no current connection.

- Even with `str.format()` style, you’re restricted to attribute and index lookups, which isn’t enough to implement some fairly simple requirements.

There’s a better way. `connect()` and `serve()` accept a `logger` argument to override the default `Logger`. You can set `logger` to a `LoggerAdapter` that enriches logs.

For example, if the server is behind a reverse proxy, `remote_address` gives the IP address of the proxy, which isn’t useful. IP addresses of clients are provided in a HTTP header set by the proxy.

Here’s how to include them in logs, assuming they’re in the `X-Forwarded-For` header:

    logging.basicConfig(
        format="%(asctime)s %(message)s",
        level=logging.INFO,
    )

    class LoggerAdapter(logging.LoggerAdapter):
        """Add connection ID and client IP address to websockets logs."""
        def process(self, msg, kwargs):
            try:
                websocket = kwargs["extra"]["websocket"]
            except KeyError:
                return msg, kwargs
            xff = websocket.request_headers.get("X-Forwarded-For")
            return f"{websocket.id} {xff} {msg}", kwargs

    async with websockets.serve(
        ...,
        # Python < 3.10 requires passing None as the second argument.
        logger=LoggerAdapter(logging.getLogger("websockets.server"), None),
    ):
        ...

## Logging to JSON

Even though `logging` predates structured logging, it’s still possible to output logs as JSON with a bit of effort.

First, we need a `Formatter` that renders JSON:

    import json
    import logging
    import datetime

    class JSONFormatter(logging.Formatter):
        """
        Render logs as JSON.

        To add details to a log record, store them in a ``event_data``
        custom attribute. This dict is merged into the event.

        """
        def __init__(self):
            pass  # override logging.Formatter constructor

        def format(self, record):
            event = {
                "timestamp": self.getTimestamp(record.created),
                "message": record.getMessage(),
                "level": record.levelname,
                "logger": record.name,
            }
            event_data = getattr(record, "event_data", None)
            if event_data:
                event.update(event_data)
            if record.exc_info:
                event["exc_info"] = self.formatException(record.exc_info)
            if record.stack_info:
                event["stack_info"] = self.formatStack(record.stack_info)
            return json.dumps(event)

        def getTimestamp(self, created):
            return datetime.datetime.utcfromtimestamp(created).isoformat()

Then, we configure logging to apply this formatter:

    handler = logging.StreamHandler()
    handler.setFormatter(formatter)

    logger = logging.getLogger()
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)

Finally, we populate the `event_data` custom attribute in log records with a `LoggerAdapter`:

    class LoggerAdapter(logging.LoggerAdapter):
        """Add connection ID and client IP address to websockets logs."""
        def process(self, msg, kwargs):
            try:
                websocket = kwargs["extra"]["websocket"]
            except KeyError:
                return msg, kwargs
            kwargs["extra"]["event_data"] = {
                "connection_id": str(websocket.id),
                "remote_addr": websocket.request_headers.get("X-Forwarded-For"),
            }
            return msg, kwargs

    async with websockets.serve(
        ...,
        # Python < 3.10 requires passing None as the second argument.
        logger=LoggerAdapter(logging.getLogger("websockets.server"), None),
    ):
        ...

## Disable logging

If your application doesn’t configure `logging`, Python outputs messages of severity `WARNING` and higher to `stderr`. As a consequence, you will see a message and a stack trace if a connection handler coroutine crashes or if you hit a bug in websockets.

If you want to disable this behavior for websockets, you can add a `NullHandler`:

    logging.getLogger("websockets").addHandler(logging.NullHandler())

Additionally, if your application configures `logging`, you must disable propagation to the root logger, or else its handlers could output logs:

    logging.getLogger("websockets").propagate = False

Alternatively, you could set the log level to `CRITICAL` for the `"websockets"` logger, as the highest level currently used is `ERROR`:

    logging.getLogger("websockets").setLevel(logging.CRITICAL)

Or you could configure a filter to drop all messages:

    logging.getLogger("websockets").addFilter(lambda record: None)

## Log levels

Here’s what websockets logs at each level.

### `ERROR`

- Exceptions raised by connection handler coroutines in servers

- Exceptions resulting from bugs in websockets

### `INFO`

- Server starting and stopping

- Server establishing and closing connections

- Client reconnecting automatically

### `DEBUG`

- Changes to the state of connections

- Handshake requests and responses

- All frames sent and received

- Steps to close a connection

- Keepalive pings and pongs

- Errors handled transparently

Debug messages have cute prefixes that make logs easier to scan:

- `>` - send something

- `<` - receive something

- `=` - set connection state

- `x` - shut down connection

- `%` - manage pings and pongs

- `!` - handle errors and timeouts