fractor 0.1.4 → 0.1.7

data/examples/multi_work_type/multi_work_type.rb

@@ -45,7 +45,7 @@ module MultiWorkType
     end
 
     def to_s
-      "ImageWork: dimensions=#{dimensions.join("x")}, format=#{format}"
+      "ImageWork: dimensions=#{dimensions.join('x')}, format=#{format}"
     end
   end
 
@@ -62,7 +62,7 @@ module MultiWorkType
         error = TypeError.new("Unsupported work type: #{work.class}")
         Fractor::WorkResult.new(
           error: error,
-          work: work
+          work: work,
         )
       end
     end
@@ -74,7 +74,8 @@ module MultiWorkType
       sleep(rand(0.01..0.05)) # Simulate processing time
 
       processed_text = case work.format
-                       when :markdown then process_markdown(work.data, work.options)
+                       when :markdown then process_markdown(work.data,
+                                                            work.options)
                        when :html then process_html(work.data, work.options)
                        when :json then process_json(work.data, work.options)
                        else work.data.upcase # Simple transformation for plain text
@@ -87,10 +88,10 @@ module MultiWorkType
           transformed_data: processed_text,
           metadata: {
             word_count: processed_text.split(/\s+/).size,
-            char_count: processed_text.length
-          }
+            char_count: processed_text.length,
+          },
         },
-        work: work
+        work: work,
       )
     end
 
@@ -110,13 +111,13 @@ module MultiWorkType
         applied_filters: %i[sharpen contrast],
         processing_metadata: {
           original_size: input_size,
-          processed_size: (input_size * 0.8).to_i # Simulate compression
-        }
+          processed_size: (input_size * 0.8).to_i, # Simulate compression
+        },
       }
 
       Fractor::WorkResult.new(
         result: simulated_result,
-        work: work
+        work: work,
       )
     end
 
@@ -127,7 +128,7 @@ module MultiWorkType
       links = text.scan(/\[(.+?)\]\((.+?)\)/)
 
       "Processed Markdown: #{text.length} chars, #{headers.size} headers, #{links.size} links\n" \
-        "Headers: #{headers.join(", ")}\n" \
+        "Headers: #{headers.join(', ')}\n" \
         "#{text.gsub(/^#+\s+(.+)$/, '💫 \1 💫')}"
     end
 
@@ -136,7 +137,7 @@ module MultiWorkType
       tags = text.scan(/<(\w+)[^>]*>/).flatten
 
       "Processed HTML: #{text.length} chars, #{tags.size} tags\n" \
-        "Tags: #{tags.uniq.join(", ")}\n" \
+        "Tags: #{tags.uniq.join(', ')}\n" \
         "#{text.gsub(%r{<(\w+)[^>]*>(.+?)</\1>}, '✨\2✨')}"
     end
 
@@ -147,7 +148,7 @@ module MultiWorkType
       keys = data.keys
 
       "Processed JSON: #{keys.size} top-level keys\n" \
-        "Keys: #{keys.join(", ")}\n" \
+        "Keys: #{keys.join(', ')}\n" \
         "Pretty-printed: #{data}"
     rescue StandardError => e
       "Invalid JSON: #{e.message}"
@@ -162,14 +163,14 @@ module MultiWorkType
       # Create supervisor with a MultiFormatWorker pool
       @supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: MultiFormatWorker, num_workers: worker_count }
-        ]
+          { worker_class: MultiFormatWorker, num_workers: worker_count },
+        ],
       )
 
       @results = {
         text: [],
         image: [],
-        errors: []
+        errors: [],
       }
     end
 
@@ -197,10 +198,10 @@ module MultiWorkType
         total_items: text_items.size + image_items.size,
         processed: {
           text: @results[:text].size,
-          image: @results[:image].size
+          image: @results[:image].size,
         },
         errors: @results[:errors].size,
-        results: @results
+        results: @results,
       }
     end
 
@@ -220,7 +221,7 @@ module MultiWorkType
       results_aggregator.errors.each do |error_result|
         @results[:errors] << {
           error: error_result.error,
-          work_type: error_result.work.class.name
+          work_type: error_result.work.class.name,
         }
       end
 
@@ -244,21 +245,21 @@ if __FILE__ == $PROGRAM_NAME
   text_items = [
     {
       data: "This is a plain text document. It has no special formatting.",
-      format: :plain
+      format: :plain,
     },
     {
       data: "# Markdown Document\n\nThis is a **bold** statement. Here's a [link](https://example.com).",
-      format: :markdown
+      format: :markdown,
     },
     {
       data: "<html><body><h1>HTML Document</h1><p>This is a paragraph.</p></body></html>",
-      format: :html
+      format: :html,
     },
     {
       data: "{name: 'Product', price: 29.99, tags: ['electronics', 'gadget']}",
       format: :json,
-      options: { pretty: true }
-    }
+      options: { pretty: true },
+    },
   ]
 
   # Sample image items (simulated)
@@ -266,18 +267,18 @@ if __FILE__ == $PROGRAM_NAME
     {
       data: "simulated_jpeg_data_1",
       dimensions: [800, 600],
-      format: :jpeg
+      format: :jpeg,
     },
     {
       data: "simulated_png_data_1",
       dimensions: [1024, 768],
-      format: :png
+      format: :png,
     },
     {
       data: "simulated_gif_data_1",
       dimensions: [320, 240],
-      format: :gif
-    }
+      format: :gif,
+    },
   ]
 
   worker_count = 4
@@ -309,8 +310,8 @@ if __FILE__ == $PROGRAM_NAME
   puts "Image Processing Results:"
   result[:results][:image].each_with_index do |image_result, index|
     puts "Image Item #{index + 1} (#{image_result[:format]}):"
-    puts "  Dimensions: #{image_result[:dimensions].join("x")}"
-    puts "  Applied filters: #{image_result[:applied_filters].join(", ")}"
+    puts "  Dimensions: #{image_result[:dimensions].join('x')}"
+    puts "  Applied filters: #{image_result[:applied_filters].join(', ')}"
     puts "  Compression: #{(1 - image_result[:processing_metadata][:processed_size].to_f / image_result[:processing_metadata][:original_size]).round(2) * 100}%"
     puts
   end

data/examples/performance_monitoring.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "../lib/fractor"
+require_relative "../lib/fractor/performance_monitor"
+
+# Example worker that simulates varying processing times
+class VariableLatencyWorker
+  def self.perform(work)
+    # Simulate variable work latency
+    sleep(rand * 0.1) # 0-100ms
+
+    result = work.payload[:value] * 2
+    Fractor::WorkResult.new(result: result, work: work)
+  end
+end
+
+# Example: Basic Performance Monitoring
+puts "=" * 80
+puts "Performance Monitoring Example"
+puts "=" * 80
+
+# Create supervisor with multiple workers
+supervisor = Fractor::Supervisor.new(
+  worker_pools: [
+    { worker_class: VariableLatencyWorker, num_workers: 4 },
+  ],
+)
+
+# Create and start performance monitor
+monitor = Fractor::PerformanceMonitor.new(supervisor, sample_interval: 0.5)
+monitor.start
+
+puts "\nProcessing 100 work items..."
+puts "Monitor started, sampling every 0.5 seconds"
+
+# Add work items
+100.times do |i|
+  supervisor.add_work_item(Fractor::Work.new({ value: i }))
+end
+
+# Run the supervisor
+supervisor_thread = Thread.new { supervisor.run }
+
+# Wait for completion
+sleep 0.5 while supervisor.work_queue.size > 0 || supervisor.results.results.size < 100
+
+# Stop monitoring
+monitor.stop
+supervisor.stop
+supervisor_thread.join
+
+puts "\n" + "=" * 80
+puts "Human-Readable Report"
+puts "=" * 80
+puts monitor.report
+
+puts "\n" + "=" * 80
+puts "JSON Export"
+puts "=" * 80
+puts JSON.pretty_generate(JSON.parse(monitor.to_json))
+
+puts "\n" + "=" * 80
+puts "Prometheus Metrics"
+puts "=" * 80
+puts monitor.to_prometheus
+
+puts "\n" + "=" * 80
+puts "Example: Real-time Monitoring with Manual Recording"
+puts "=" * 80
+
+# Create a new monitor
+supervisor2 = Fractor::Supervisor.new(
+  worker_pools: [
+    { worker_class: VariableLatencyWorker, num_workers: 2 },
+  ],
+)
+
+monitor2 = Fractor::PerformanceMonitor.new(supervisor2)
+monitor2.start
+
+puts "\nManually recording job completions..."
+
+# Simulate job execution and manually record metrics
+10.times do |i|
+  start_time = Time.now
+
+  # Simulate work
+  sleep(rand * 0.05)
+
+  # Record the job
+  latency = Time.now - start_time
+  success = rand > 0.1 # 90% success rate
+
+  monitor2.record_job(latency, success: success)
+
+  print "." if i % 10 == 0
+end
+
+monitor2.stop
+
+puts "\n\nFinal Metrics:"
+snapshot = monitor2.snapshot
+puts "  Jobs Processed: #{snapshot[:jobs_processed]}"
+puts "  Success Rate: #{(snapshot[:jobs_succeeded].to_f / snapshot[:jobs_processed] * 100).round(2)}%"
+puts "  Average Latency: #{(snapshot[:average_latency] * 1000).round(2)}ms"
+puts "  P95 Latency: #{(snapshot[:p95_latency] * 1000).round(2)}ms"
+puts "  Throughput: #{snapshot[:throughput].round(2)} jobs/sec"
+
+puts "\n" + "=" * 80
+puts "Example Complete"
+puts "=" * 80
+puts "\nPerformance monitoring provides:"
+puts "  ✓ Jobs processed counter"
+puts "  ✓ Latency tracking (average, p50, p95, p99)"
+puts "  ✓ Throughput calculation (jobs/second)"
+puts "  ✓ Worker utilization tracking"
+puts "  ✓ Queue depth monitoring"
+puts "  ✓ Memory usage tracking"
+puts "  ✓ JSON export"
+puts "  ✓ Prometheus metrics export"