package main import ( "context" "fmt" "time" "github.com/seasbee/go-patternx" ) func main() { // Create a bloom filter bf, err := patternx.NewBloomFilter(&patternx.BloomConfig{ ExpectedItems: 10000, FalsePositiveRate: 0.01, }) if err != nil { panic(err) } defer bf.Close() // Add items bf.Add(context.Background(), "user123") bf.Add(context.Background(), "user456") // Check membership exists, _ := bf.Contains(context.Background(), "user123") fmt.Printf("User exists: %v\n", exists) // Create a circuit breaker cb, err := patternx.NewCircuitBreaker(patternx.DefaultConfigCircuitBreaker()) if err != nil { panic(err) } // Execute with circuit breaker err = cb.Execute(func() error { // Your operation here return nil }) if err != nil { fmt.Printf("Circuit breaker error: %v\n", err) } // Create a bulkhead bh, err := patternx.NewBulkhead(patternx.DefaultBulkheadConfig()) if err != nil { panic(err) } defer bh.Close() // Execute with bulkhead result, err := bh.Execute(context.Background(), func() (interface{}, error) { return "success", nil }) if err != nil { fmt.Printf("Bulkhead error: %v\n", err) } else { fmt.Printf("Result: %v\n", result) } // Use retry pattern policy := patternx.DefaultPolicy() err = patternx.Retry(policy, func() error { // Your operation here return nil }) if err != nil { fmt.Printf("Retry error: %v\n", err) } // Create pub/sub system store := &MyStore{} // Implement PubSubStore interface config := patternx.DefaultConfigPubSub(store) ps, err := patternx.NewPubSub(config) if err != nil { panic(err) } defer ps.Close(context.Background()) // Create topic err = ps.CreateTopic(context.Background(), "orders") if err != nil { panic(err) } // Subscribe to topic handler := func(ctx context.Context, msg *patternx.MessagePubSub) error { fmt.Printf("Processing order: %s\n", string(msg.Data)) return nil } _, err = ps.Subscribe(context.Background(), "orders", "order-processor", handler, &patternx.MessageFilter{}) if err != nil { panic(err) } // Publish message data := []byte("order-123") err = ps.Publish(context.Background(), "orders", data, map[string]string{"type": "order"}) if err != nil { fmt.Printf("Publish error: %v\n", err) } }

import "github.com/seasbee/go-patternx" // Create bloom filter with store store := &MyBloomStore{} // Implement BloomStore interface bf, err := patternx.NewBloomFilter(&patternx.BloomConfig{ ExpectedItems: 1000000, FalsePositiveRate: 0.01, Store: store, TTL: 24 * time.Hour, }) if err != nil { panic(err) } defer bf.Close() // Add items in batch items := []string{"item1", "item2", "item3", "item4", "item5"} err = bf.AddBatch(context.Background(), items) if err != nil { panic(err) } // Check multiple items exists, err := bf.ContainsBatch(context.Background(), items) if err != nil { panic(err) }

import "github.com/seasbee/go-patternx" // Create circuit breaker with custom config config := patternx.ConfigCircuitBreaker{ Threshold: 5, // Open after 5 failures Timeout: 30 * time.Second, // Keep open for 30 seconds HalfOpenMax: 3, // Allow 3 requests in half-open } circuitBreaker, err := patternx.NewCircuitBreaker(config) if err != nil { panic(err) } // Execute with circuit breaker err = circuitBreaker.Execute(func() error { // Call external service return callExternalService() }) // Check circuit breaker state stats := circuitBreaker.GetStats() fmt.Printf("Circuit breaker state: %s\n", stats.State)

import "github.com/seasbee/go-patternx" // Create worker pool config := patternx.DefaultConfigPool() config.MinWorkers = 5 config.MaxWorkers = 20 config.QueueSize = 1000 config.EnableAutoScaling = true config.ScaleUpThreshold = 0.8 config.ScaleDownThreshold = 0.2 wp, err := patternx.NewPool(config) if err != nil { panic(err) } defer wp.Close() // Submit jobs for i := 0; i < 100; i++ { job := patternx.Job{ ID: fmt.Sprintf("job_%d", i), Task: func() (interface{}, error) { // Process job time.Sleep(100 * time.Millisecond) return "processed", nil }, Timeout: 5 * time.Second, } err := wp.Submit(job) if err != nil { fmt.Printf("Failed to submit job: %v\n", err) } } // Get pool statistics stats := wp.GetStats() fmt.Printf("Active workers: %d\n", stats.ActiveWorkers.Load()) fmt.Printf("Completed jobs: %d\n", stats.CompletedJobs.Load())

import "github.com/seasbee/go-patternx" // Create Redis clients clients := []patternx.LockClient{ redisClient1, redisClient2, redisClient3, } // Create Redlock config := &patternx.Config{ Clients: clients, Quorum: 2, RetryDelay: 10 * time.Millisecond, MaxRetries: 3, DriftFactor: 0.01, EnableMetrics: true, } rl, err := patternx.NewRedlock(config) if err != nil { panic(err) } // Acquire lock lock, err := rl.Lock(context.Background(), "resource_key", 30*time.Second) if err != nil { panic(err) } defer lock.Unlock(context.Background()) // Perform critical section operations fmt.Println("Lock acquired, performing critical operations...") time.Sleep(5 * time.Second) // Lock is automatically released when function returns

import "github.com/seasbee/go-patternx" // Create pub/sub system with high reliability store := &MyPubSubStore{} // Implement PubSubStore interface config := patternx.HighReliabilityConfigPubSub(store) ps, err := patternx.NewPubSub(config) if err != nil { panic(err) } defer ps.Close(context.Background()) // Create topic err = ps.CreateTopic(context.Background(), "orders") if err != nil { panic(err) } // Subscribe with message filtering handler := func(ctx context.Context, msg *patternx.MessagePubSub) error { fmt.Printf("Processing order: %s\n", string(msg.Data)) return nil } filter := &patternx.MessageFilter{ Headers: map[string]string{"type": "order"}, } _, err = ps.Subscribe(context.Background(), "orders", "order-processor", handler, filter) if err != nil { panic(err) } // Publish message with headers data := []byte(`{"order_id": "12345", "amount": 99.99}`) headers := map[string]string{ "type": "order", "priority": "high", "source": "web", } err = ps.Publish(context.Background(), "orders", data, headers) if err != nil { panic(err) } // Get system statistics stats := ps.GetStats() fmt.Printf("System stats: %+v\n", stats)

// Bloom Filter patternx.DefaultBloomConfig(store) // Bulkhead patternx.DefaultBulkheadConfig() // Circuit Breaker patternx.DefaultConfigCircuitBreaker() // Dead Letter Queue patternx.DefaultConfigDLQ() // Redlock patternx.DefaultConfig(clients) // Retry patternx.DefaultPolicy() // Worker Pool patternx.DefaultConfigPool() // Pub/Sub System patternx.DefaultConfigPubSub(store)

// High-performance configurations patternx.AggressiveBloomConfig(store) patternx.HighPerformanceBulkheadConfig() patternx.HighPerformanceConfigCircuitBreaker() patternx.HighPerformanceConfigDLQ() patternx.AggressiveConfig(clients) patternx.AggressivePolicy() patternx.HighPerformanceConfigPool() patternx.HighReliabilityConfigPubSub(store)

// Custom bloom filter configuration config := &patternx.BloomConfig{ ExpectedItems: 1000000, FalsePositiveRate: 0.001, // 0.1% false positive rate Store: myStore, TTL: 24 * time.Hour, EnableMetrics: true, } // Custom circuit breaker configuration config := patternx.ConfigCircuitBreaker{ Threshold: 10, Timeout: 60 * time.Second, HalfOpenMax: 5, } // Custom pub/sub configuration config := &patternx.ConfigPubSub{ Store: store, BufferSize: 50000, MaxRetryAttempts: 5, RetryDelay: 200 * time.Millisecond, MaxConcurrentOperations: 500, OperationTimeout: 60 * time.Second, CircuitBreakerThreshold: 3, CircuitBreakerTimeout: 120 * time.Second, EnableDeadLetterQueue: true, }

// Production-ready configuration example func createProductionConfig() { // Bloom Filter for caching bloomConfig := &patternx.BloomConfig{ ExpectedItems: 10000000, // 10M items FalsePositiveRate: 0.001, // 0.1% false positive EnableMetrics: true, } // Circuit Breaker for external services cbConfig := patternx.ConfigCircuitBreaker{ Threshold: 20, // Higher threshold Timeout: 60 * time.Second, // Longer timeout HalfOpenMax: 10, // More half-open requests } // Worker Pool for processing poolConfig := patternx.ConfigPool{ MinWorkers: 10, MaxWorkers: 100, QueueSize: 10000, EnableAutoScaling: true, EnableMetrics: true, } // Bulkhead for resource isolation bulkheadConfig := patternx.BulkheadConfig{ MaxConcurrentCalls: 50, MaxQueueSize: 1000, MaxWaitDuration: 5 * time.Second, HealthThreshold: 0.8, } // Pub/Sub for messaging pubsubConfig := &patternx.ConfigPubSub{ Store: store, BufferSize: 50000, MaxRetryAttempts: 5, RetryDelay: 200 * time.Millisecond, MaxConcurrentOperations: 500, OperationTimeout: 60 * time.Second, CircuitBreakerThreshold: 3, CircuitBreakerTimeout: 120 * time.Second, EnableDeadLetterQueue: true, } }

// Health monitoring if !circuitBreaker.IsHealthy() { // Alert: Circuit breaker unhealthy log.Error("Circuit breaker health check failed") } // Metrics collection stats := workerPool.GetStats() prometheus.Gauge("worker_pool_active_workers").Set(float64(stats.ActiveWorkers.Load())) prometheus.Counter("worker_pool_completed_jobs").Add(float64(stats.CompletedJobs.Load())) // Performance monitoring bloomStats := bloomFilter.GetStats() log.Info("Bloom filter performance", "item_count", bloomStats["item_count"], "false_positive_rate", bloomStats["false_positive_rate"]) // Pub/Sub monitoring pubsubStats := pubsubSystem.GetStats() log.Info("Pub/Sub system performance", "total_messages", pubsubStats["total_messages"], "active_connections", pubsubStats["active_connections"])