Utility Methods¶

from logly import logger

# Disable logging
logger.disable()
logger.info("This won't be logged")

# Re-enable logging
logger.enable()
logger.info("This will be logged")

# Enable logging
logger.enable()
logger.info("Logging is enabled")

# Temporarily disable
logger.disable()
logger.warning("This warning is suppressed")

# Re-enable
logger.enable()
logger.error("This error will be logged")

# Conditionally enable/disable based on environment
if debug_mode:
    logger.enable()
else:
    logger.disable()

logger.debug("Debug information")

from logly import logger

# Disable logging
logger.disable()
logger.info("This won't be logged")
logger.error("This won't be logged either")

import pytest
from logly import logger

@pytest.fixture(autouse=True)
def silence_logs():
    """Disable logging during tests."""
    logger.disable()
    yield
    logger.enable()

# Disable debug logging in production
if production:
    logger.disable()

# All logging suppressed
logger.info("Not logged in production")

from logly import logger

# Create custom level alias
logger.level("NOTICE", "INFO")

# Use custom level
logger.log("NOTICE", "Important notice", category="security")

# Map business terms to technical levels
logger.level("AUDIT", "INFO")
logger.level("SECURITY", "WARNING")
logger.level("FATAL", "CRITICAL")

logger.log("AUDIT", "User login", user="alice", ip="192.168.1.1")
logger.log("SECURITY", "Suspicious activity detected", threat_level=7)
logger.log("FATAL", "System shutdown required")

# E-commerce application
logger.level("ORDER", "INFO")
logger.level("PAYMENT", "WARNING")
logger.level("FRAUD", "ERROR")

logger.log("ORDER", "Order placed", order_id="ORD-12345", amount=99.99)
logger.log("PAYMENT", "Payment retry", attempt=2)
logger.log("FRAUD", "Fraudulent transaction blocked", card="****1234")

# Create multiple aliases for same level
logger.level("NOTICE", "INFO")
logger.level("NOTE", "INFO")
logger.level("FYI", "INFO")

logger.log("NOTICE", "Server maintenance scheduled")
logger.log("NOTE", "Configuration updated")
logger.log("FYI", "Cache cleared")

from logly import logger

# Configure logger with custom settings
logger.configure(
    level="DEBUG",
    color=True,
    show_time=True,
    show_module=True
)
logger.info("Custom configuration")

# Reset to defaults
logger.reset()
logger.info("Back to default configuration")

import pytest
from logly import logger

@pytest.fixture(autouse=True)
def reset_logger():
    """Reset logger before each test."""
    yield
    logger.reset()  # Clean up after test

def test_custom_config():
    logger.configure(level="TRACE", color=False)
    logger.trace("Test message")
    # Automatically reset after test

def load_config(config_file: str):
    # Reset existing configuration
    logger.reset()

    # Load new configuration
    config = read_config(config_file)
    logger.configure(**config)
    logger.info("Configuration reloaded", file=config_file)

# Configure with per-level controls
logger.configure(
    console_levels={"DEBUG": False, "TRACE": False},
    time_levels={"ERROR": True, "CRITICAL": True},
    color_levels={"INFO": False}
)

# Reset clears all per-level controls
logger.reset()
logger.info("All controls reset to defaults")

from logly import logger

# Application code
logger.info("Application started")
logger.info("Processing data")
logger.info("Application complete")

# Cleanup at exit
logger.complete()

def main():
    try:
        logger.configure(level="INFO")
        logger.add("logs/app.log")

        # Application logic
        logger.info("Running application")
        process_data()

    finally:
        # Always cleanup
        logger.complete()

if __name__ == "__main__":
    main()

# Configure multiple sinks
logger.add("console")
logger.add("logs/app.log")
logger.add("logs/error.log", level="ERROR")

# Application code
logger.info("Processing...")
logger.error("Error occurred")

# Flush all sinks
logger.complete()

import asyncio

async def main():
    logger.configure(level="INFO")
    logger.add("logs/async.log", async_write=True)

    # Async operations
    await async_task()

    # Wait for async writes to complete
    logger.complete()

asyncio.run(main())

from logly import logger

# Add sinks
console_id = logger.add("console")
file_id = logger.add("app.log")

# Disable file logging
logger.disable_sink(file_id)
logger.info("Only to console")  # Logged to console only

# Re-enable file logging
logger.enable_sink(file_id)
logger.info("To both sinks")  # Logged to both console and file

from logly import logger

# Setup sinks
console_id = logger.add("console")
debug_file_id = logger.add("debug.log")
error_file_id = logger.add("error.log", filter_min_level="ERROR")

# Disable debug file in production
if production:
    logger.disable_sink(debug_file_id)

logger.debug("Debug info")  # To console (and debug file in dev)
logger.error("Error occurred")  # To all sinks

from logly import logger

# Feature-specific logging
feature_sinks = {}

def enable_feature_logging(feature_name):
    """Enable detailed logging for a feature."""
    sink_id = logger.add(f"logs/{feature_name}.log")
    feature_sinks[feature_name] = sink_id
    return sink_id

def disable_feature_logging(feature_name):
    """Disable logging for a feature."""
    if feature_name in feature_sinks:
        sink_id = feature_sinks[feature_name]
        logger.disable_sink(sink_id)

# Use feature logging
enable_feature_logging("payment")
# ... lots of payment logs ...
disable_feature_logging("payment")  # Stop logging payments

from logly import logger

# Setup
file_id = logger.add("app.log")

# Temporarily stop file logging
logger.disable_sink(file_id)
logger.info("Not in file")

# Resume file logging
logger.enable_sink(file_id)
logger.info("Back in file")

from logly import logger
import time

# Setup sinks
console_id = logger.add("console")
verbose_id = logger.add("verbose.log")

# Disable verbose logging for high-performance section
logger.disable_sink(verbose_id)

start = time.time()
for i in range(1000000):
    process_item(i)
    # No verbose file writes during hot loop

logger.enable_sink(verbose_id)
logger.info(f"Processed 1M items in {time.time() - start:.2f}s")

from logly import logger
import os

# Setup sinks
console_id = logger.add("console")
debug_id = logger.add("debug.log")

# Disable debug file in production
if os.getenv("ENV") == "production":
    logger.disable_sink(debug_id)

logger.debug("Debug information")  # Only to console in prod
logger.info("Application started")  # To both sinks

from logly import logger

file_id = logger.add("app.log")

# Check initial state
enabled = logger.is_sink_enabled(file_id)
print(f"Sink enabled: {enabled}")  # True

# Disable and check
logger.disable_sink(file_id)
enabled = logger.is_sink_enabled(file_id)
print(f"Sink enabled: {enabled}")  # False

from logly import logger

debug_id = logger.add("debug.log")

def toggle_debug_logging():
    """Toggle debug file logging."""
    if logger.is_sink_enabled(debug_id):
        logger.disable_sink(debug_id)
        logger.info("Debug logging disabled")
    else:
        logger.enable_sink(debug_id)
        logger.info("Debug logging enabled")

from logly import logger

# Add multiple sinks
console_id = logger.add("console")
app_log_id = logger.add("app.log")
error_log_id = logger.add("error.log", filter_min_level="ERROR")

# Report status
for sink_id in logger.list_sinks():
    info = logger.sink_info(sink_id)
    enabled = logger.is_sink_enabled(sink_id)

    print(f"Sink {sink_id}:")
    print(f"  Type: {info.get('type', 'unknown')}")
    print(f"  Path: {info.get('path', 'N/A')}")
    print(f"  Enabled: {enabled}")

# Use logger.disable()/enable() when:
# • Testing: Silence all log output
# • Performance: Temporarily disable all logging
# • Application state: Pause all logging during critical sections

logger.add("console")
logger.add("app.log")
logger.add("error.log")

# Disable ALL sinks at once
logger.disable()
logger.info("Not logged anywhere")  # No output to any sink

# Re-enable ALL sinks
logger.enable()
logger.info("Logged everywhere")  # Console + both files

# Use enable_sink()/disable_sink() when:
# • Conditional output: Only certain sinks based on conditions
# • Dynamic routing: Change where logs go at runtime
# • Performance tuning: Disable expensive sinks temporarily

console_id = logger.add("console")
app_log_id = logger.add("app.log")
debug_log_id = logger.add("debug.log")

# Disable only debug file in production
if production:
    logger.disable_sink(debug_log_id)

logger.info("User login")  # → Console + app.log only

# Re-enable debug file for troubleshooting
if user_requests_debug:
    logger.enable_sink(debug_log_id)

logger.debug("Detailed info")  # → All 3 sinks now

# Combine both for maximum flexibility

console_id = logger.add("console")
file_id = logger.add("app.log")

# Scenario 1: Testing mode - silence everything
if testing:
    logger.disable()  # Global disable (fastest)

# Scenario 2: Debug mode - extra file output
if debug_mode:
    debug_id = logger.add("debug.log")

# Scenario 3: Performance mode - file logging only
if performance_mode:
    logger.disable_sink(console_id)  # Disable console
    # File logging still active

# Global disable overrides per-sink settings
logger.disable()
logger.enable_sink(file_id)  # Has no effect until global enable()
logger.info("Not logged")  # Still disabled globally

logger.enable()
logger.info("Logged to file")  # Now works (file is enabled)