Format Patterns

/**
 * Interface for tokens that render log entry components as text
 */
interface Token {
    /**
     * Get the required log entry values for this token
     * @return Collection of required LogEntryValue enums
     */
    Collection<LogEntryValue> getRequiredLogEntryValues();
    
    /**
     * Render the token using log entry data
     * @param logEntry Log entry to render
     * @param builder StringBuilder to append output to
     */
    void render(LogEntry logEntry, StringBuilder builder);
    
    /**
     * Apply token value to prepared statement for JDBC writer
     * @param logEntry Log entry data
     * @param statement JDBC PreparedStatement
     * @param index Parameter index in statement
     * @throws SQLException if database operation fails
     */
    void apply(LogEntry logEntry, PreparedStatement statement, int index) throws SQLException;
}

/**
 * Parser for format patterns producing collections of tokens
 */
class FormatPatternParser {
    /**
     * Create parser with throwable filter support
     * @param filters Comma-separated list of throwable filters
     */
    public FormatPatternParser(String filters);
    
    /**
     * Parse format pattern into tokens
     * @param pattern Format pattern string
     * @return Collection of tokens representing the pattern
     */
    public Collection<Token> parse(String pattern);
    
    /**
     * Parse format pattern for JDBC usage
     * @param pattern Format pattern string
     * @return Collection of tokens for JDBC statements
     */
    public Collection<Token> parseForJdbc(String pattern);
}

/**
 * Token for rendering timestamps with customizable format
 */
class DateToken implements Token {
    /**
     * Create date token with specified format
     * @param pattern Date format pattern (SimpleDateFormat syntax)
     */
    public DateToken(String pattern);
    
    /**
     * Create date token with format and timezone
     * @param pattern Date format pattern
     * @param timeZone Timezone for rendering
     */
    public DateToken(String pattern, TimeZone timeZone);
}

/**
 * Token for rendering application uptime
 */
class UptimeToken implements Token {
    /**
     * Create uptime token with default format
     */
    public UptimeToken();
    
    /**
     * Create uptime token with custom format
     * @param pattern Format pattern for uptime display
     */
    public UptimeToken(String pattern);
}

/**
 * Token for rendering thread information
 */
class ThreadToken implements Token {
    /**
     * Create thread token with default format (thread name)
     */
    public ThreadToken();
    
    /**
     * Create thread token with custom format
     * @param pattern Format for thread info (name, id, or both)
     */
    public ThreadToken(String pattern);
}

/**
 * Token for rendering process ID
 */
class ProcessIdToken implements Token {
    /**
     * Create process ID token
     */
    public ProcessIdToken();
}

/**
 * Token for rendering formatted log messages
 */
class MessageToken implements Token {
    /**
     * Create message token
     */
    public MessageToken();
}

/**
 * Token for rendering exception information
 */
class ExceptionToken implements Token {
    /**
     * Create exception token with default formatting
     */
    public ExceptionToken();
    
    /**
     * Create exception token with throwable filters
     * @param filters Comma-separated list of throwable filters
     */
    public ExceptionToken(String filters);
}

/**
 * Token for rendering class names
 */
class ClassNameToken implements Token {
    /**
     * Create class name token with default format (full class name)
     */
    public ClassNameToken();
    
    /**
     * Create class name token with custom format
     * @param pattern Format pattern (full, simple, package)
     */
    public ClassNameToken(String pattern);
}

/**
 * Token for rendering method names
 */
class MethodToken implements Token {
    /**
     * Create method token
     */
    public MethodToken();
}

/**
 * Token for rendering source file names
 */
class FileToken implements Token {
    /**
     * Create file token
     */
    public FileToken();
}

/**
 * Token for rendering source line numbers
 */
class LineToken implements Token {
    /**
     * Create line token
     */
    public LineToken();
}

/**
 * Token for rendering log levels
 */
class LevelToken implements Token {
    /**
     * Create level token with default format
     */
    public LevelToken();
    
    /**
     * Create level token with custom format
     * @param pattern Format pattern (full, short, numeric)
     */
    public LevelToken(String pattern);
}

/**
 * Token for rendering log tags
 */
class TagToken implements Token {
    /**
     * Create tag token
     */
    public TagToken();
}

/**
 * Token for rendering context values
 */
class ContextToken implements Token {
    /**
     * Create context token for specific key
     * @param key Context key to render
     */
    public ContextToken(String key);
    
    /**
     * Create context token with key and default value
     * @param key Context key to render
     * @param defaultValue Default value if key not found
     */
    public ContextToken(String key, String defaultValue);
}

/**
 * Token for rendering literal text
 */
class PlainTextToken implements Token {
    /**
     * Create plain text token
     * @param text Literal text to render
     */
    public PlainTextToken(String text);
}

/**
 * Token for rendering newlines
 */
class NewLineToken implements Token {
    /**
     * Create newline token
     */
    public NewLineToken();
}

# Simple console format
writer=console
writer.format={date: HH:mm:ss} {level}: {message}

# Detailed file format
writer=file
writer.file=app.log
writer.format={date: yyyy-MM-dd HH:mm:ss.SSS} [{level}] [{thread}] {class}.{method}(): {message}

# Development format with full source information
writer=console
writer.format={date: HH:mm:ss.SSS} {level} [{thread}] {class}.{method}({file}:{line}): {message}{newline}{exception}

# Production format with minimal information
writer=file
writer.format={date} {level}: {message}

# JSON-like structured format
writer=file
writer.format={"timestamp":"{date:yyyy-MM-dd'T'HH:mm:ss.SSSZ}","level":"{level}","thread":"{thread}","message":"{message}"}

# Include context values in log format
writer=console
writer.format={date: HH:mm:ss} [{level}] [user:{context:userId}] [session:{context:sessionId}] {message}

# Context with defaults
writer=file
writer.format={date} {level} [user:{context:userId:-unknown}] {class}: {message}

# Full exception details
writer=file
writer.format={date} {level}: {message}{newline}{exception}
writer.exception=keep

# Minimal exception info
writer=console  
writer.format={date: HH:mm:ss} {level}: {message} [{exception}]
writer.exception=strip

# Multi-line detailed format
writer=file
writer.format=== {date: yyyy-MM-dd HH:mm:ss.SSS} ==={newline}Level: {level}{newline}Thread: {thread}{newline}Location: {class}.{method}({file}:{line}){newline}Message: {message}{newline}{exception}{newline}

# Compact single-line format
writer=console
writer.format={date: HH:mm:ss} {level} {class}: {message}

# Minimal pattern for high-volume logging
writer=file
writer.format={date: HH:mm:ss} {level}: {message}

# No source code information for better performance
writer=console
writer.format={date: HH:mm:ss} {level} [{thread}]: {message}