fractor 0.1.4 → 0.1.7

data/examples/specialized_workers/specialized_workers.rb

@@ -5,11 +5,14 @@ require_relative "../../lib/fractor"
 module SpecializedWorkers
   # First work type: Compute-intensive operations
   class ComputeWork < Fractor::Work
+    attr_reader :work_type
+
     def initialize(data, operation = :default, parameters = {})
       super({
         data: data,
         operation: operation,
-        parameters: parameters
+        parameters: parameters,
+        work_type: :compute,  # Add work type identifier for Ractor compatibility
       })
     end
 
@@ -25,6 +28,10 @@ module SpecializedWorkers
       input[:parameters]
     end
 
+    def work_type
+      input[:work_type]
+    end
+
     def to_s
       "ComputeWork: operation=#{operation}, parameters=#{parameters}"
     end
@@ -32,12 +39,16 @@ module SpecializedWorkers
 
   # Second work type: Database operations
   class DatabaseWork < Fractor::Work
-    def initialize(data = "", query_type = :select, table = "unknown", conditions = {})
+    attr_reader :work_type
+
+    def initialize(data = "", query_type = :select, table = "unknown",
+conditions = {})
       super({
         data: data,
         query_type: query_type,
         table: table,
-        conditions: conditions
+        conditions: conditions,
+        work_type: :database,  # Add work type identifier for Ractor compatibility
       })
     end
 
@@ -57,6 +68,10 @@ module SpecializedWorkers
       input[:conditions]
     end
 
+    def work_type
+      input[:work_type]
+    end
+
     def to_s
       "DatabaseWork: query_type=#{query_type}, table=#{table}, conditions=#{conditions}"
     end
@@ -64,24 +79,28 @@ module SpecializedWorkers
 
   # First worker type: Handles compute-intensive operations
   class ComputeWorker < Fractor::Worker
-    def initialize
+    def initialize(name: nil, **options)
+      super
       # Setup resources needed for computation
-      @compute_resources = { memory: 1024, cpu_cores: 4 }
+      # Use Ractor.make_shareable to make the hash shareable across Ractors
+      @compute_resources = Ractor.make_shareable({ memory: 1024, cpu_cores: 4 })
     end
 
     def process(work)
-      # Only handle ComputeWork
-      unless work.is_a?(ComputeWork)
+      # Only handle ComputeWork - check work_type for Ractor compatibility
+      unless work.respond_to?(:work_type) && work.work_type == :compute
         return Fractor::WorkResult.new(
           error: "ComputeWorker can only process ComputeWork, got: #{work.class}",
-          work: work
+          work: work,
         )
       end
 
       # Process based on the requested operation
       result = case work.operation
-               when :matrix_multiply then matrix_multiply(work.data, work.parameters)
-               when :image_transform then image_transform(work.data, work.parameters)
+               when :matrix_multiply then matrix_multiply(work.data,
+                                                          work.parameters)
+               when :image_transform then image_transform(work.data,
+                                                          work.parameters)
                when :path_finding then path_finding(work.data, work.parameters)
                else default_computation(work.data, work.parameters)
                end
@@ -90,9 +109,9 @@ module SpecializedWorkers
         result: {
           operation: work.operation,
           computation_result: result,
-          resources_used: @compute_resources
+          resources_used: @compute_resources,
         },
-        work: work
+        work: work,
       )
     end
 
@@ -110,7 +129,7 @@ module SpecializedWorkers
       # Simulate image transformation
       sleep(rand(0.1..0.3))
       transforms = params[:transforms] || %i[rotate scale]
-      "Image transformation applied: #{transforms.join(", ")} with parameters #{params}"
+      "Image transformation applied: #{transforms.join(', ')} with parameters #{params}"
     end
 
     def path_finding(_data, params)
@@ -130,17 +149,19 @@ module SpecializedWorkers
 
   # Second worker type: Handles database operations
   class DatabaseWorker < Fractor::Worker
-    def initialize
+    def initialize(name: nil, **options)
+      super
       # Setup database connection and resources
-      @db_connection = { pool_size: 5, timeout: 30 }
+      # Use Ractor.make_shareable to make the hash shareable across Ractors
+      @db_connection = Ractor.make_shareable({ pool_size: 5, timeout: 30 })
     end
 
     def process(work)
-      # Only handle DatabaseWork
-      unless work.is_a?(DatabaseWork)
+      # Only handle DatabaseWork - check work_type for Ractor compatibility
+      unless work.respond_to?(:work_type) && work.work_type == :database
         return Fractor::WorkResult.new(
           error: "DatabaseWorker can only process DatabaseWork, got: #{work.class}",
-          work: work
+          work: work,
         )
       end
 
@@ -148,7 +169,8 @@ module SpecializedWorkers
       result = case work.query_type
                when :select then perform_select(work.table, work.conditions)
                when :insert then perform_insert(work.table, work.data)
-               when :update then perform_update(work.table, work.data, work.conditions)
+               when :update then perform_update(work.table, work.data,
+                                                work.conditions)
                when :delete then perform_delete(work.table, work.conditions)
                else default_query(work.query_type, work.table, work.conditions)
                end
@@ -159,9 +181,9 @@ module SpecializedWorkers
           table: work.table,
           rows_affected: result[:rows_affected],
           data: result[:data],
-          execution_time: result[:time]
+          execution_time: result[:time],
         },
-        work: work
+        work: work,
       )
     end
 
@@ -174,8 +196,10 @@ module SpecializedWorkers
       record_count = rand(0..20)
       {
         rows_affected: record_count,
-        data: record_count.times.map { |i| { id: i + 1, name: "Record #{i + 1}" } },
-        time: rand(0.01..0.05)
+        data: Array.new(record_count) do |i|
+          { id: i + 1, name: "Record #{i + 1}" }
+        end,
+        time: rand(0.01..0.05),
       }
     end
 
@@ -185,7 +209,7 @@ module SpecializedWorkers
       {
         rows_affected: 1,
         data: { id: rand(1000..9999) },
-        time: rand(0.01..0.03)
+        time: rand(0.01..0.03),
       }
     end
 
@@ -196,7 +220,7 @@ module SpecializedWorkers
       {
         rows_affected: affected,
         data: nil,
-        time: rand(0.01..0.05)
+        time: rand(0.01..0.05),
       }
     end
 
@@ -207,7 +231,7 @@ module SpecializedWorkers
       {
         rows_affected: affected,
         data: nil,
-        time: rand(0.01..0.03)
+        time: rand(0.01..0.03),
       }
     end
 
@@ -217,7 +241,7 @@ module SpecializedWorkers
       {
         rows_affected: 0,
         data: nil,
-        time: rand(0.005..0.01)
+        time: rand(0.005..0.01),
       }
     end
   end
@@ -230,14 +254,14 @@ module SpecializedWorkers
       # Create separate supervisors for each worker type
       @compute_supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: ComputeWorker, num_workers: compute_workers }
-        ]
+          { worker_class: ComputeWorker, num_workers: compute_workers },
+        ],
       )
 
       @db_supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: DatabaseWorker, num_workers: db_workers }
-        ]
+          { worker_class: DatabaseWorker, num_workers: db_workers },
+        ],
       )
 
       @compute_results = []
@@ -249,13 +273,20 @@ module SpecializedWorkers
       compute_work_items = compute_tasks.map do |task|
         ComputeWork.new(task[:data], task[:operation], task[:parameters])
       end
+      puts "Created #{compute_work_items.size} compute work items"
+      puts "First compute work item: #{compute_work_items.first.inspect}" if compute_work_items.any?
       @compute_supervisor.add_work_items(compute_work_items)
+      puts "Added compute work items to supervisor"
 
       # Create and add database work items
       db_work_items = db_tasks.map do |task|
-        DatabaseWork.new(task[:data], task[:query_type], task[:table], task[:conditions])
+        DatabaseWork.new(task[:data], task[:query_type], task[:table],
+                         task[:conditions])
       end
+      puts "Created #{db_work_items.size} database work items"
+      puts "First db work item: #{db_work_items.first.inspect}" if db_work_items.any?
       @db_supervisor.add_work_items(db_work_items)
+      puts "Added database work items to supervisor"
 
       # Run the supervisors directly - this is more reliable
       @compute_supervisor.run
@@ -266,7 +297,19 @@ module SpecializedWorkers
       db_results_agg = @db_supervisor.results
 
       puts "Received compute results: #{compute_results_agg.results.size} items"
+      puts "Received compute errors: #{compute_results_agg.errors.size} items"
+      if compute_results_agg.errors.any?
+        compute_results_agg.errors.each do |e|
+          puts "  Error: #{e.error}"
+        end
+      end
       puts "Received database results: #{db_results_agg.results.size} items"
+      puts "Received database errors: #{db_results_agg.errors.size} items"
+      if db_results_agg.errors.any?
+        db_results_agg.errors.each do |e|
+          puts "  Error: #{e.error}"
+        end
+      end
 
       # Format and store results
       @compute_results = format_compute_results(compute_results_agg)
@@ -277,13 +320,13 @@ module SpecializedWorkers
         computation: {
           tasks: compute_tasks.size,
           completed: @compute_results.size,
-          results: @compute_results
+          results: @compute_results,
         },
         database: {
           tasks: db_tasks.size,
           completed: @db_results.size,
-          results: @db_results
-        }
+          results: @db_results,
+        },
       }
     end
 
@@ -316,18 +359,18 @@ if __FILE__ == $PROGRAM_NAME
     {
       operation: :matrix_multiply,
       data: "Matrix data...",
-      parameters: { size: [10, 10] }
+      parameters: { size: [10, 10] },
     },
     {
       operation: :image_transform,
       data: "Image data...",
-      parameters: { transforms: %i[rotate scale blur], angle: 45, scale: 1.5 }
+      parameters: { transforms: %i[rotate scale blur], angle: 45, scale: 1.5 },
     },
     {
       operation: :path_finding,
       data: "Graph data...",
-      parameters: { algorithm: :dijkstra, nodes: 20, start: 1, end: 15 }
-    }
+      parameters: { algorithm: :dijkstra, nodes: 20, start: 1, end: 15 },
+    },
   ]
 
   # Prepare database tasks
@@ -335,24 +378,24 @@ if __FILE__ == $PROGRAM_NAME
     {
       query_type: :select,
       table: "users",
-      conditions: { active: true, role: "admin" }
+      conditions: { active: true, role: "admin" },
     },
     {
       query_type: :insert,
       table: "orders",
-      data: "Order data..."
+      data: "Order data...",
     },
     {
       query_type: :update,
       table: "products",
       data: "Product data...",
-      conditions: { category: "electronics" }
+      conditions: { category: "electronics" },
     },
     {
       query_type: :delete,
       table: "sessions",
-      conditions: { expired: true }
-    }
+      conditions: { expired: true },
+    },
   ]
 
   compute_workers = 2
@@ -363,7 +406,7 @@ if __FILE__ == $PROGRAM_NAME
   start_time = Time.now
   system = SpecializedWorkers::HybridSystem.new(
     compute_workers: compute_workers,
-    db_workers: db_workers
+    db_workers: db_workers,
   )
   result = system.process_mixed_workload(compute_tasks, db_tasks)
   end_time = Time.now

data/examples/stream_processor/README.adoc

@@ -0,0 +1,206 @@
+= Real-Time Data Stream Processor Example
+:toc:
+:toclevels: 3
+
+Real-time event stream processor using Fractor::ContinuousServer for processing continuous data streams with windowing, metrics tracking, and graceful shutdown.
+
+== Purpose
+
+This example demonstrates:
+
+* Continuous event processing with Fractor::ContinuousServer
+* Sliding window aggregation (5-second windows)
+* Real-time metrics tracking
+* Backpressure handling
+* Graceful shutdown with SIGINT/SIGTERM
+* Performance monitoring
+
+== Features
+
+=== Continuous Processing
+
+Processes events as they arrive without stopping:
+
+* Non-blocking event ingestion
+* Parallel processing across workers
+* Result collection in background thread
+* Automatic workload distribution
+
+=== Sliding Window Aggregation
+
+Maintains a sliding time window of recent events:
+
+* Configurable window size (default: 5 seconds)
+* Automatic cleanup of old events
+* Window-based metrics calculation
+* Real-time window size tracking
+
+=== Performance Metrics
+
+Tracks and displays real-time metrics:
+
+* Total events processed
+* Events per second
+* Average processing time
+* Current window size
+
+=== Graceful Shutdown
+
+Handles termination signals properly:
+
+* SIGINT (Ctrl+C) for manual shutdown
+* SIGTERM for system shutdown
+* Preserves in-flight work
+* Final summary report
+
+== Usage
+
+=== Basic Usage
+
+Run with default settings (30 seconds, 10 events/second):
+
+[source,bash]
+----
+ruby stream_processor.rb
+----
+
+=== Custom Duration
+
+Process for 60 seconds:
+
+[source,bash]
+----
+ruby stream_processor.rb -d 60
+----
+
+=== Custom Event Rate
+
+Generate 50 events per second:
+
+[source,bash]
+----
+ruby stream_processor.rb -r 50
+----
+
+=== Custom Workers
+
+Use 8 worker ractors:
+
+[source,bash]
+----
+ruby stream_processor.rb -w 8
+----
+
+=== Custom Window Size
+
+Use 10-second window:
+
+[source,bash]
+----
+ruby stream_processor.rb --window 10
+----
+
+=== Combined Options
+
+[source,bash]
+----
+ruby stream_processor.rb -w 8 -d 120 -r 100 --window 10
+----
+
+== Examples
+
+=== Example 1: Default Settings
+
+[source,bash]
+----
+$ ruby stream_processor.rb
+
+Starting Stream Processor...
+Window size: 5 seconds
+Workers: 4
+Press Ctrl+C to stop gracefully
+
+Generating event stream for 30 seconds at 10 events/second...
+
+Events: 300 | Processed: 298 | Rate: 9.93 e/s | Window: 47 | Avg Time: 0.12 ms
+
+Generated 300 events
+
+Stopping Stream Processor...
+
+============================================================
+FINAL SUMMARY
+============================================================
+Total Events: 300
+Processed: 300
+Errors: 0
+Duration: 30.25 seconds
+Average Rate: 9.92 events/second
+============================================================
+----
+
+=== Example 2: High Throughput
+
+[source,bash]
+----
+$ ruby stream_processor.rb -w 8 -r 100 -d 10
+
+Starting Stream Processor...
+Window size: 5 seconds
+Workers: 8
+
+Events: 1000 | Processed: 998 | Rate: 99.8 e/s | Window: 492 | Avg Time: 0.08 ms
+
+Generated 1000 events
+
+FINAL SUMMARY
+============================================================
+Total Events: 1000
+Processed: 1000
+Duration: 10.05 seconds
+Average Rate: 99.50 events/second
+----
+
+=== Example 3: Graceful Shutdown
+
+Press Ctrl+C during processing:
+
+[source,bash]
+----
+$ ruby stream_processor.rb
+
+Events: 150 | Processed: 148 | Rate: 10.1 e/s | Window: 48 | Avg Time: 0.10 ms
+^C
+Stopping Stream Processor...
+
+FINAL SUMMARY
+============================================================
+Total Events: 150
+Processed: 150
+Duration: 14.87 seconds
+Average Rate: 10.09 events/second
+----
+
+== Architecture
+
+The processor consists of:
+
+* **Event**: Work item representing a stream event
+* **EventProcessorWorker**: Worker that processes events
+* **StreamProcessor**: Main processor managing the continuous server
+* **EventGenerator**: Test utility for generating event streams
+
+== Testing
+
+Run the test suite:
+
+[source,bash]
+----
+bundle exec rspec spec/examples/stream_processor_spec.rb
+----
+
+== See Also
+
+* link:../../README.adoc[Fractor Main Documentation]
+* link:../../docs/continuous-mode.adoc[Continuous Mode Guide]
+* link:../log_analyzer/README.adoc[Log Analyzer Example]