logly

Choose a codec based on your application's performance requirements:

Recommendations:

• gzip: Recommended default for most use cases.
• zstd: Best speed-to-ratio tradeoff for high-volume logging.
• xz: Best for long-term archival where disk space is critical.
• bz2: Higher compression than gzip at the cost of speed.

When using PostgresHandler in production:

• Schema Management: Set create_table=False if you prefer to manage the schema manually or if you need to add custom columns to the log table.
• Performance: Use connection pooling in production environments to avoid the overhead of opening a new connection for every log message.

When configuring RedisHandler, choose a mode based on your requirements:

• List Mode (mode="list"): Uses LPUSH. Best for simple log queuing.
• Stream Mode (mode="stream"): Uses XADD. Best if you require Redis consumer group support.

Tip: Use the max_stream_len argument to cap the length of the list or stream to prevent high-volume logs from consuming excessive memory.

from logly import logger
from logly.integrations.redis import RedisHandler

# List mode for simple queuing
handler = RedisHandler(
    "redis://localhost:6379/0",
    key="app:logs",
    mode="list",
    max_stream_len=5000,
)
logger.add(handler, level="WARNING")

# Stream mode for consumer groups
stream_handler = RedisHandler(
    "redis://localhost:6379/0",
    key="app:logs:stream",
    mode="stream",
    max_stream_len=10000,
)
logger.add(stream_handler, level="ERROR")

When using LoglyMiddleware, the following fields are automatically included in your log output:

Logly uses logger.start() and logger.stop() to manage background processing and application lifecycle hooks.

• logger.start(): Initializes background workers and starts processing. It accepts optional lifecycle hooks for compatibility with service startup code.
• logger.stop(): Flushes all sinks (including queued messages when enqueue=True) and stops background workers. This should be called during application shutdown to ensure no logs are lost.

These methods are thread-safe. When stop() is called, it drains the queues and waits for all messages to be processed, allowing multiple threads to continue logging safely until the drain is complete.

from logly import logger

# Configure logger
logger.add("app.log", level="INFO")

# Start background processing
logger.start()

# Application runs...

# Flush and stop on shutdown
logger.stop()

Exception handling works seamlessly with Logly's contextual features like bind() and contextualize().

• With bind(): Use a bound logger (e.g., containing service or endpoint info) inside a logger.catch() block to ensure all logs in that scope carry the same metadata.
• With contextualize(): Use with logger.contextualize(...) to add request-scoped metadata (like request_id) around a try/except block where logger.exception() is called.

from logly import logger

# Combined with bind
api_logger = logger.bind(service="api", endpoint="/users")

with logger.catch(level="ERROR"):
    response = api_client.get("/users")

# Combined with contextualize
with logger.contextualize(request_id="req-123"):
    try:
        risky_operation()
    except Exception:
        logger.exception("Request failed")

When a logging.Handler is passed to logger.add():

1. Logly wraps the handler as a callable sink.
2. Each log message is converted into a logging.LogRecord.
3. The handler's emit() method is called with that record.
4. Exception information is automatically forwarded if available.

You can create compound styles by combining a color with a text style. Logly supports two syntaxes for this:

1. Underscore-Separated: style_color (e.g., bold_blue, dim_cyan).
2. Space-Separated: style color (e.g., bold blue, underline yellow).

Available text styles: dim, bold, italic, underline, blink, reverse, strike.

from logly import logger

logger.remove()
logger.add("stderr", level="TRACE", colorize=True)

# Underscore syntax
logger.level("DEBUG", no=10, color="bold_blue")

# Space syntax
logger.level("WARNING", no=40, color="underline yellow")

logger.debug("bold blue debug")
logger.warning("underline yellow warning")

You can enhance exception output by enabling backtrace and diagnose modes when adding a logger handler.

• Backtrace Mode (backtrace=True): Includes the function call history (stack trace) in the exception output.
• Diagnose Mode (diagnose=True): Includes the values of local variables at the time of the exception in the output.

You can also override these settings for a single log call using .opt().

from logly import logger

# Enable both modes globally for a handler
logger.add(
    "app.log",
    backtrace=True,
    diagnose=True,
    format="{time} | {level} | {message}",
)

# Or override for a specific call
logger.opt(backtrace=True).error("This has backtrace")