features

type AdaptiveSampler struct {
	// contains filtered or unexported fields
}

type AdaptiveWindow struct {
	Start        time.Time
	End          time.Time
	MessageCount uint64
	Rate         float64
}

type BurstTracker struct {
	// contains filtered or unexported fields
}

type ChainMode int

type CompressibleLogger interface {
	Logger

	// SetCompression enables/disables compression
	SetCompression(compressionType int) error

	// SetCompressMinAge sets minimum age before compression
	SetCompressMinAge(age int)

	// SetCompressWorkers sets number of compression workers
	SetCompressWorkers(workers int)
}

type CompressionConfig struct {
	Type    int  // Compression type (types.CompressionNone, types.CompressionGzip)
	MinAge  int  // Minimum number of rotations before compression
	Workers int  // Number of compression workers
	Enabled bool // Whether compression is enabled
}

type CompressionManager struct {
	// contains filtered or unexported fields
}

type CompressionStatus struct {
	Type          CompressionType `json:"type"`
	MinAge        int             `json:"min_age"`
	Workers       int             `json:"workers"`
	IsRunning     bool            `json:"is_running"`
	QueueLength   int             `json:"queue_length"`
	QueueCapacity int             `json:"queue_capacity"`
}

type CompressionType int

type Compressor interface {
	// Compress compresses a file
	Compress(src, dest string) error

	// Type returns the compression type
	Type() int

	// Extension returns the file extension for compressed files
	Extension() string
}

type ContextualRule struct {
	Name         string
	Condition    func(level int, fields map[string]interface{}) bool
	RedactFields []string
	Replacement  string
}

type FieldPathRule struct {
	Path        string // JSON path like "user.profile.ssn"
	Replacement string // Custom replacement text for this path
}

type FieldRedactionRule struct {
	FieldPath string // JSONPath-like field path
	Pattern   string // Regex pattern to match
	Replace   string // Replacement string
}

type Filter interface {
	// ShouldLog determines if a message should be logged
	ShouldLog(level int, message string, fields map[string]interface{}) bool

	// Name returns the filter name for identification
	Name() string
}

type FilterCache struct {
	// contains filtered or unexported fields
}

type FilterChain struct {
	Name        string
	Mode        ChainMode // AND, OR, XOR modes
	Filters     []NamedFilter
	StopOnMatch bool // Stop evaluating after first match (for OR mode)
	Inverted    bool // Invert the final result
}

type FilterFunc func(level int, message string, fields map[string]interface{}) bool

type FilterManager struct {
	// contains filtered or unexported fields
}

type FilterMetrics struct {
	TotalChecks      uint64
	TotalPassed      uint64
	TotalFiltered    uint64
	FilterHits       map[string]uint64
	ChainHits        map[string]uint64
	CacheHits        uint64
	CacheMisses      uint64
	ProcessingTimeNs int64
	LastUpdate       time.Time
}

type FilterStatus struct {
	FilterCount     int           `json:"filter_count"`
	ChainCount      int           `json:"chain_count"`
	ActiveFilters   int           `json:"active_filters"`
	DisabledFilters int           `json:"disabled_filters"`
	CacheEnabled    bool          `json:"cache_enabled"`
	CacheSize       int           `json:"cache_size,omitempty"`
	CacheMaxSize    int           `json:"cache_max_size,omitempty"`
	CacheTTL        time.Duration `json:"cache_ttl,omitempty"`
}

type FilterableLogger interface {
	Logger

	// AddFilter adds a filter function
	AddFilter(filter types.FilterFunc) error

	// RemoveFilter removes a filter function
	RemoveFilter(filter types.FilterFunc) error

	// ClearFilters removes all filters
	ClearFilters()
}

type FullFeaturedLogger interface {
	StructuredLogger
	FilterableLogger
	SamplableLogger
	RotatableLogger
	CompressibleLogger
	RecoverableLogger
	RedactableLogger
	MetricsLogger
}

type LevelFilter struct {
	MinLevel int
	MaxLevel int
}

type Logger interface {
	// Basic logging methods
	Debug(args ...interface{})
	Info(args ...interface{})
	Warn(args ...interface{})
	Error(args ...interface{})

	// Formatted logging methods
	Debugf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Warnf(format string, args ...interface{})
	Errorf(format string, args ...interface{})

	// Close closes the logger
	Close() error
}

type MetricsLogger interface {
	Logger

	// GetMetrics returns logger metrics
	GetMetrics() map[string]interface{}

	// ResetMetrics resets all metrics
	ResetMetrics()
}

type NamedFilter struct {
	Name        string
	Description string
	Filter      FilterFunc
	Priority    int  // Higher priority filters are evaluated first
	Enabled     bool // Can be toggled without removing
	Tags        []string
}

type PatternSamplingRule struct {
	Pattern     string
	Rate        float64
	Priority    int // Higher priority rules override lower ones
	Description string
	MatchFields bool // Whether to match against fields as well
}

type RateLimiter struct {
	// contains filtered or unexported fields
}

type RecoverableLogger interface {
	Logger

	// SetRecoveryConfig sets recovery configuration (defined in recovery.go)
	SetRecoveryConfig(config interface{})

	// RecoverFromError attempts to recover from an error
	RecoverFromError(err error, msg types.LogMessage, dest *types.Destination)
}

type Recovery interface {
	// Recover attempts to recover from an error
	Recover(err error) error

	// IsRecoverable determines if an error is recoverable
	IsRecoverable(err error) bool

	// GetFallbackOptions returns fallback options
	GetFallbackOptions() []string
}

type RecoveryConfig struct {
	// Maximum retry attempts
	MaxRetries int
	// Delay between retries
	RetryDelay time.Duration
	// Exponential backoff multiplier
	BackoffMultiplier float64
	// Maximum retry delay
	MaxRetryDelay time.Duration
	// Fallback destination
	FallbackPath string
	// Buffer size for temporary storage
	BufferSize int
	// Recovery strategy
	Strategy RecoveryStrategy
}

type RecoveryManager struct {
	// contains filtered or unexported fields
}

type RecoveryStrategy int

type RedactableLogger interface {
	Logger

	// SetRedaction sets redaction patterns
	SetRedaction(patterns []string, replace string) error

	// SetRedactionConfig sets advanced redaction configuration (defined in redaction.go)
	SetRedactionConfig(config interface{})

	// EnableRedactionForLevel enables/disables redaction for a specific level
	EnableRedactionForLevel(level int, enable bool)
}

type RedactionCache struct {
	// contains filtered or unexported fields
}

type RedactionConfig struct {
	EnableBuiltInPatterns bool     // Whether to apply built-in data patterns (SSN, credit cards, etc.)
	EnableFieldRedaction  bool     // Whether to apply JSON field redaction
	EnableDataPatterns    bool     // Whether to apply data pattern redaction in content
	MaxCacheSize          int      // Maximum size of redaction cache
	SkipLevels            []int    // Log levels to skip redaction for (e.g., DEBUG)
	FieldPaths            []string // Specific field paths to redact (e.g., "user.profile.ssn")
}

type RedactionManager struct {
	// contains filtered or unexported fields
}

type RedactionMetrics struct {
	TotalProcessed   uint64
	TotalRedacted    uint64
	FieldsRedacted   map[string]uint64
	PatternsMatched  map[string]uint64
	ProcessingTimeNs int64
	CacheHits        uint64
	CacheMisses      uint64
	LastUpdate       time.Time
}

type RedactionMode int

type Redactor struct {
	// contains filtered or unexported fields
}

type RedactorInterface interface {
	// Redact redacts sensitive data from a message
	Redact(message string) string

	// RedactFields redacts sensitive data from structured fields
	RedactFields(fields map[string]interface{}) map[string]interface{}

	// AddPattern adds a redaction pattern
	AddPattern(pattern string)

	// RemovePattern removes a redaction pattern
	RemovePattern(pattern string)
}

type RegexFilter struct {
	Pattern *regexp.Regexp
	Include bool // true to include matches, false to exclude
}

type RotatableLogger interface {
	Logger

	// SetMaxSize sets maximum file size before rotation
	SetMaxSize(size int64)

	// SetMaxFiles sets maximum number of files to keep
	SetMaxFiles(files int)

	// SetMaxAge sets maximum age for log files
	SetMaxAge(age time.Duration) error

	// Rotate manually triggers rotation
	Rotate() error
}

type RotatedFileInfo struct {
	Path         string    `json:"path"`
	Name         string    `json:"name"`
	Size         int64     `json:"size"`
	RotationTime time.Time `json:"rotation_time"`
	IsCompressed bool      `json:"is_compressed"`
}

type RotationConfig struct {
	MaxSize      int64         // Maximum file size before rotation
	MaxFiles     int           // Maximum number of files to keep
	MaxAge       time.Duration // Maximum age of files
	KeepOriginal bool          // Whether to keep the original file
}

type RotationManager struct {
	// contains filtered or unexported fields
}

type RotationStatus struct {
	MaxAge          time.Duration `json:"max_age"`
	MaxFiles        int           `json:"max_files"`
	CleanupInterval time.Duration `json:"cleanup_interval"`
	IsRunning       bool          `json:"is_running"`
}

type Rotator interface {
	// Rotate rotates the log file
	Rotate(currentPath string) error

	// ShouldRotate determines if rotation is needed
	ShouldRotate(size int64, age time.Duration) bool

	// GetRotatedFilename generates a rotated filename
	GetRotatedFilename(basePath string, index int) string
}

type SamplableLogger interface {
	Logger

	// SetSampling configures sampling
	SetSampling(strategy int, rate float64) error

	// GetSamplingRate returns current sampling rate
	GetSamplingRate() float64
}

type Sampler interface {
	// ShouldSample determines if a message should be sampled
	ShouldSample(level int, message string, fields map[string]interface{}) bool

	// Rate returns the current sampling rate
	Rate() float64

	// SetRate sets the sampling rate
	SetRate(rate float64)
}

type SamplingConfig struct {
	Strategy int                                              // Sampling strategy (types.SamplingNone, types.SamplingRandom, etc.)
	Rate     float64                                          // Sampling rate (0.0-1.0)
	KeyFunc  func(int, string, map[string]interface{}) string // Key function for consistent sampling
}

type SamplingManager struct {
	// contains filtered or unexported fields
}

type SamplingMetrics struct {
	TotalMessages   uint64
	SampledMessages uint64
	DroppedMessages uint64
	CurrentRate     float64
	EffectiveRate   float64 // Actual sampling rate based on decisions
	StrategyHits    map[string]uint64
	LevelHits       map[int]uint64
	PatternHits     map[string]uint64
	LastUpdate      time.Time
}

type SamplingMetricsExport struct {
	TotalMessages   uint64            `json:"total_messages"`
	SampledMessages uint64            `json:"sampled_messages"`
	DroppedMessages uint64            `json:"dropped_messages"`
	CurrentRate     float64           `json:"current_rate"`
	EffectiveRate   float64           `json:"effective_rate"`
	LastUpdate      time.Time         `json:"last_update"`
	Strategies      map[string]uint64 `json:"strategies"`
	Levels          map[string]uint64 `json:"levels"`
	Patterns        map[string]uint64 `json:"patterns"`
}

type SamplingStatus struct {
	Strategy        SamplingStrategy      `json:"strategy"`
	Rate            float64               `json:"rate"`
	IsActive        bool                  `json:"is_active"`
	LevelRates      map[int]float64       `json:"level_rates,omitempty"`
	PatternRules    []PatternSamplingRule `json:"pattern_rules,omitempty"`
	AdaptiveRate    float64               `json:"adaptive_rate,omitempty"`
	RateLimitTokens float64               `json:"rate_limit_tokens,omitempty"`
}

type SamplingStrategy int

type StructuredLogger interface {
	Logger

	// WithField adds a single field
	WithField(key string, value interface{}) StructuredLogger

	// WithFields adds multiple fields
	WithFields(fields map[string]interface{}) StructuredLogger
}