structlog doesn't care at all; people use it to send dicts to servers. All that'd be needed is a BytesLogger or something in https://github.com/hynek/structlog/blob/master/src/structlog/_loggers.py

Hm I think I was hitting https://github.com/hynek/structlog/blob/master/src/structlog/_base.py#L174?

Returning strings is just a shortcut for ((string,),{}) IIRC.

Ah I see, so there's nothing stopping me from playing with this. Thanks!

So do I understand this correctly that to make it work at the moment without decoding the bytes to a string (and this indeed loses some performance according to a small benchmark I did) I need to do something like the following:

class BytesLoggerFactory(structlog.PrintLoggerFactory):
    """Produce `BytesLogger`."""
    def __init__(self, file=None):
        super().__init__(file)

    def __call__(self, *args):
        return BytesLogger(self._file)


class BytesLogger(structlog.PrintLogger):
    """Print events as bytes into a file."""
    def __init__(self, file=None):
        super().__init__(file)

        self._write = self._file.buffer.write
        self._flush = self._file.buffer.flush

    def __setstate__(self, state):
        super().__setstate__(state)

        self._write = self._file.buffer.write
        self._flush = self._file.buffer.flush

    def msg(self, message):
        """
        Print *message*.
        """
        with self._lock:
            until_not_interrupted(self._write, message + b"\n")
            until_not_interrupted(self._flush)

    log = debug = info = warn = warning = msg
    fatal = failure = err = error = critical = exception = msg

and for serialization use something like

def serializer(event_dict, **kwargs):
    """Serialize with orjson.

    Args:
        event_dict: Context.
        **kwargs: Serialization keyword arguments.

    """
    return (orjson.dumps(event_dict, option=orjson.OPT_NON_STR_KEYS, **kwargs),), {}

to avoid exceptions from the structlog.stdlib.BoundLogger? :)

You tell us, if you tested/benchmarked it. :D

Do you have any numbers on vs stdlib json and simplejson? Please use https://pypi.org/project/pyperf/

We might fold it into the docs if it's significant enough.

I only did a basic benchmark of orjson (with and without decoding of bytes to string) vs stdlib json and rapidjson on an "average event dict" that I send to structlog. I also compared orjson vs stdlib on dumps and loads on a fairly large (~500 KB) JSON file. The numbers on my machine are promising, but I would have to redo the benchmark to make it presentable. :)

There are quite a few results on the orjson page though.

I am not really sure if or how it would be possible to benchmark the integration of orjson and structlog however.

Yeah I know orjson is very fast, the question is if it makes any difference in the context of small dicts that go thru I/O.