Lifecycle & Statistics

Processor provides complete lifecycle management, cache control, and health monitoring capabilities.

Lifecycle

Close

Signature: func (p *Processor) Close() error

Closes the processor and releases resources. This method should be called after using the Processor.

processor, _ := json.New(json.DefaultConfig())
defer processor.Close()

IsClosed

Signature: func (p *Processor) IsClosed() bool

Checks whether the processor is closed.

if processor.IsClosed() {
    // Processor is closed, cannot be used anymore
}

Cache Management

ClearCache

Signature: func (p *Processor) ClearCache()

Clears the processor's internal cache.

processor.ClearCache()

Useful for:

• Data source has changed
• Memory usage is too high
• Need to force a refresh

WarmupCache

Signature: func (p *Processor) WarmupCache(jsonStr string, paths []string, cfg ...Config) (*WarmupResult, error)

Warms up the cache to improve subsequent operation performance.

paths := []string{"user.name", "user.email", "items[*].id"}
result, err := processor.WarmupCache(data, paths)
if err != nil {
    panic(err)
}
fmt.Printf("Successfully warmed up %d paths\n", result.Successful)

WarmupResult Struct:

type WarmupResult struct {
    TotalPaths  int      `json:"total_paths"`            // Total path count
    Successful  int      `json:"successful"`             // Successfully warmed up path count
    Failed      int      `json:"failed"`                 // Failed path count
    SuccessRate float64  `json:"success_rate"`           // Success rate (percentage)
    FailedPaths []string `json:"failed_paths,omitempty"` // List of failed paths
}

Field	Type	Description
TotalPaths	int	Total path count
Successful	int	Successfully warmed up path count
Failed	int	Failed path count
SuccessRate	float64	Success rate (0-100)
FailedPaths	[]string	List of failed paths

Statistics

GetStats

Signature: func (p *Processor) GetStats() Stats

Gets the processor's statistics.

stats := processor.GetStats()
fmt.Printf("Cache hit ratio: %.2f%%\n", stats.HitRatio * 100)
fmt.Printf("Cache size: %d\n", stats.CacheSize)

Stats Struct:

type Stats struct {
    CacheSize        int64         `json:"cache_size"`        // Cache entry count
    CacheMemory      int64         `json:"cache_memory"`      // Cache memory usage (bytes)
    MaxCacheSize     int           `json:"max_cache_size"`    // Maximum cache size
    HitCount         int64         `json:"hit_count"`         // Cache hit count
    MissCount        int64         `json:"miss_count"`        // Cache miss count
    HitRatio         float64       `json:"hit_ratio"`         // Cache hit ratio
    CacheTTL         time.Duration `json:"cache_ttl"`         // Cache TTL
    CacheEnabled     bool          `json:"cache_enabled"`     // Whether cache is enabled
    IsClosed         bool          `json:"is_closed"`         // Whether the processor is closed
    MemoryEfficiency float64       `json:"memory_efficiency"` // Memory efficiency
    OperationCount   int64         `json:"operation_count"`   // Total operation count
    ErrorCount       int64         `json:"error_count"`       // Total error count
}

Field	Type	Description
CacheSize	int64	Current cache entry count
CacheMemory	int64	Cache memory usage (bytes)
MaxCacheSize	int	Maximum cache size limit
HitCount	int64	Cache hit count
MissCount	int64	Cache miss count
HitRatio	float64	Cache hit ratio (0-1)
CacheTTL	time.Duration	Cache expiration time
CacheEnabled	bool	Whether cache is enabled
IsClosed	bool	Whether the processor is closed
MemoryEfficiency	float64	Memory efficiency
OperationCount	int64	Total operation count
ErrorCount	int64	Total error count

Health Check

GetHealthStatus

Signature: func (p *Processor) GetHealthStatus() HealthStatus

Gets the processor's health status.

status := processor.GetHealthStatus()
if status.Healthy {
    fmt.Println("Processor is healthy")
} else {
    for name, check := range status.Checks {
        if !check.Healthy {
            fmt.Printf("Check %s failed: %s\n", name, check.Message)
        }
    }
}

HealthStatus Struct:

type HealthStatus struct {
    Timestamp time.Time              `json:"timestamp"` // Check time
    Healthy   bool                   `json:"healthy"`   // Overall health status
    Checks    map[string]CheckResult `json:"checks"`    // Results of each check
}

type CheckResult struct {
    Healthy bool   `json:"healthy"` // Whether healthy
    Message string `json:"message"` // Status message
}

Field	Type	Description
Timestamp	time.Time	Check time
Healthy	bool	Whether overall healthy
Checks	map[string]CheckResult	Details of each check

Extension Hooks

AddHook

Signature: func (p *Processor) AddHook(hook Hook)

Adds an operation hook to the processor.

processor.AddHook(&LoggingHook{})
processor.AddHook(json.TimingHook(&MetricsRecorder{}))

Hooks are called before and after each operation, useful for:

• Logging
• Performance monitoring
• Metrics collection
• Audit trailing

SetLogger

Signature: func (p *Processor) SetLogger(logger *slog.Logger)

Sets the processor's logger. Used for debugging and runtime diagnostics.

processor, _ := json.New()
defer processor.Close()

processor.SetLogger(slog.Default().With("component", "json-processor"))

GetConfig

Signature: func (p *Processor) GetConfig() Config

Gets a copy of the processor's current configuration. The returned configuration can be safely modified without affecting the processor.

processor, _ := json.New()
defer processor.Close()

cfg := processor.GetConfig()
fmt.Printf("Cache enabled: %v\n", cfg.EnableCache)
fmt.Printf("Max JSON size: %d\n", cfg.MaxJSONSize)

Usage Recommendations

Resource Management

processor, _ := json.New()
defer processor.Close()  // Ensure resources are released

// Use processor...

Performance Optimization

// Warm up frequently used paths
processor.WarmupCache(data, []string{
    "user.name",
    "user.email",
    "items[*].id",
})

// Periodically check statistics
stats := processor.GetStats()
if stats.HitRatio < 0.5 {
    // Low hit ratio, consider adjusting cache configuration
}

Monitoring Integration

// Periodic health checks
go func() {
    ticker := time.NewTicker(30 * time.Second)
    for range ticker.C {
        status := processor.GetHealthStatus()
        if !status.Healthy {
            log.Printf("Processor unhealthy: %+v", status.Checks)
        }
    }
}()

Related

• Config - Configuration options (cache size, TTL, etc.)
• Hook System - Detailed hook usage guide
• Interface Definitions - Hook interfaces