ruby_reactor 0.4.1 → 0.5.0

data/lib/ruby_reactor/sidekiq_adapter.rb

@@ -41,8 +41,8 @@ module RubyReactor
 
     def self.perform_map_element_in(delay, map_id:, element_id:, index:, serialized_inputs:, reactor_class_info:,
                                     strict_ordering:, parent_context_id:, parent_reactor_class_name:, step_name:,
-                                    batch_size: nil, serialized_context: nil)
-      RubyReactor::SidekiqWorkers::MapElementWorker.perform_in(
+                                    batch_size: nil, serialized_context: nil, fail_fast: nil)
+      job_id = RubyReactor::SidekiqWorkers::MapElementWorker.perform_in(
         delay,
         {
           "map_id" => map_id,
@@ -55,9 +55,13 @@ module RubyReactor
           "parent_reactor_class_name" => parent_reactor_class_name,
           "step_name" => step_name,
           "batch_size" => batch_size,
-          "serialized_context" => serialized_context
+          "serialized_context" => serialized_context,
+          "fail_fast" => fail_fast
         }
       )
+      # Return an AsyncResult so RetryManager#handle_async_retry recognises the
+      # element was successfully requeued and yields a RetryQueuedResult.
+      RubyReactor::AsyncResult.new(job_id: job_id)
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -78,23 +82,5 @@ module RubyReactor
     end
 
     # rubocop:enable Metrics/ParameterLists
-    # rubocop:disable Metrics/ParameterLists
-    def self.perform_map_execution_async(map_id:, serialized_inputs:, reactor_class_info:, strict_ordering:,
-                                         parent_context_id:, parent_reactor_class_name:, step_name:, fail_fast: nil)
-      # rubocop:enable Metrics/ParameterLists
-      job_id = RubyReactor::SidekiqWorkers::MapExecutionWorker.perform_async(
-        {
-          "map_id" => map_id,
-          "serialized_inputs" => serialized_inputs,
-          "reactor_class_info" => reactor_class_info,
-          "strict_ordering" => strict_ordering,
-          "parent_context_id" => parent_context_id,
-          "parent_reactor_class_name" => parent_reactor_class_name,
-          "step_name" => step_name,
-          "fail_fast" => fail_fast
-        }
-      )
-      RubyReactor::AsyncResult.new(job_id: job_id)
-    end
   end
 end

data/lib/ruby_reactor/step/map_step.rb

@@ -183,31 +183,35 @@ module RubyReactor
           )
         end
 
-        def dispatch_async_map(map_id, arguments, context, reactor_class_info, step_name)
-          if arguments[:batch_size]
-            # Use new Dispatcher with Backpressure
-            RubyReactor::Map::Dispatcher.perform(
-              map_id: map_id,
-              parent_context_id: context.context_id,
-              parent_reactor_class_name: context.reactor_class.name,
-              source: arguments[:source],
-              batch_size: arguments[:batch_size],
-              step_name: step_name,
-              argument_mappings: arguments[:argument_mappings],
-              strict_ordering: arguments[:strict_ordering],
-              mapped_reactor_class: arguments[:mapped_reactor_class],
-              fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
-            )
-            queue_collector(map_id, context, step_name, arguments[:strict_ordering])
-            "map:#{map_id}"
-          else
-            queue_single_worker(map_id: map_id, arguments: arguments, context: context,
-                                reactor_class_info: reactor_class_info, step_name: step_name)
-          end
+        def dispatch_async_map(map_id, arguments, context, _reactor_class_info, step_name)
+          # Every async map runs through the per-element Dispatcher path. When no
+          # batch_size is given we default to the full source size (one fan-out
+          # batch), so there is a single execution path: each element runs in its
+          # own worker, with the map counter/collector tracking completion. This
+          # lets elements with async steps or async retries hand off correctly
+          # instead of being forced to run synchronously in a single worker.
+          batch_size = arguments[:batch_size] || arguments[:source].size
+
+          RubyReactor::Map::Dispatcher.perform(
+            map_id: map_id,
+            parent_context_id: context.context_id,
+            parent_reactor_class_name: context.reactor_class.name,
+            source: arguments[:source],
+            batch_size: batch_size,
+            step_name: step_name,
+            argument_mappings: arguments[:argument_mappings],
+            strict_ordering: arguments[:strict_ordering],
+            mapped_reactor_class: arguments[:mapped_reactor_class],
+            fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
+          )
+          queue_collector(map_id, context, step_name, arguments[:strict_ordering])
+          "map:#{map_id}"
         end
 
         def prepare_async_execution(context, map_id, count)
           storage = RubyReactor.configuration.storage_adapter
+          middlewares = context.middlewares || Executor.middlewares_for(context.reactor_class)
+          middlewares.on(:before_async_enqueue, context)
           serialized_context = ContextSerializer.serialize(context)
           storage.store_context(context.context_id, serialized_context, context.reactor_class.name)
           storage.set_map_counter(map_id, count, context.reactor_class.name)
@@ -268,18 +272,6 @@ module RubyReactor
             strict_ordering: strict_ordering, timeout: 3600
           )
         end
-
-        def queue_single_worker(map_id:, arguments:, context:, reactor_class_info:, step_name:)
-          inputs = { source: arguments[:source], mappings: arguments[:argument_mappings] || {} }
-          serialized_inputs = ContextSerializer.serialize_value(inputs)
-
-          RubyReactor.configuration.async_router.perform_map_execution_async(
-            map_id: map_id, serialized_inputs: serialized_inputs,
-            reactor_class_info: reactor_class_info, strict_ordering: arguments[:strict_ordering],
-            parent_context_id: context.context_id, parent_reactor_class_name: context.reactor_class.name,
-            step_name: step_name.to_s, fail_fast: arguments[:fail_fast].nil? || arguments[:fail_fast]
-          )
-        end
       end
     end
   end

data/lib/ruby_reactor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyReactor
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/ruby_reactor/web/coordination_serializer.rb

@@ -122,34 +122,28 @@ module RubyReactor
           end
 
           {
-            configured: {
-              limits: config[:limits].map do |window|
-                {
-                  name: window[:name],
-                  limit: window[:limit],
-                  period_seconds: window[:period_seconds]
-                }
-              end
-            },
+            configured: { limits: map_limits(config[:limits]) },
             key: key,
             state: windows
           }
         rescue StandardError => e
           {
-            configured: {
-              limits: config[:limits]&.map do |window|
-                {
-                  name: window[:name],
-                  limit: window[:limit],
-                  period_seconds: window[:period_seconds]
-                }
-              end
-            },
+            configured: { limits: map_limits(config[:limits]) },
             key: nil,
             key_error: e.message
           }
         end
 
+        def map_limits(limits)
+          Array(limits).map do |window|
+            {
+              name: window[:name],
+              limit: window[:limit],
+              period_seconds: window[:period_seconds]
+            }
+          end
+        end
+
         def build_period(config, inputs, adapter)
           key = resolve_key(config[:key_proc], inputs)
           every = config[:every]

data/teley/Dockerfile

@@ -0,0 +1,60 @@
+# Dockerfile for teley
+FROM node:24-slim
+
+WORKDIR /app
+
+# Install git and other build deps
+RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+
+# Clone teley repo
+RUN git clone https://github.com/logaretm/teley.git .
+
+# Allow native builds for dependencies (like esbuild) via workspace config
+RUN echo "dangerouslyAllowAllBuilds: true" > pnpm-workspace.yaml
+
+# Patch workers/src/durable-object.ts to support default_token
+RUN node -e ' \
+  const fs = require("fs"); \
+  const file = "workers/src/durable-object.ts"; \
+  let content = fs.readFileSync(file, "utf8"); \
+  content = content.replace("const token = url.searchParams.get(\x27token\x27);", "const token = url.searchParams.get(\x27token\x27) || \x27default_token\x27;"); \
+  fs.writeFileSync(file, content, "utf8"); \
+'
+
+# Patch app/pages/live/[roomId].vue to support default_token fallback
+RUN node -e ' \
+  const fs = require("fs"); \
+  const file = "app/pages/live/[roomId].vue"; \
+  let content = fs.readFileSync(file, "utf8"); \
+  content = content.replace("const token = (route.query.token as string) || \x27\x27;", "const token = (route.query.token as string) || \x27default_token\x27;"); \
+  fs.writeFileSync(file, content, "utf8"); \
+'
+
+# Patch app/composables/useSession.ts to default to ruby_reactor_session and default_token
+RUN node -e ' \
+  const fs = require("fs"); \
+  const file = "app/composables/useSession.ts"; \
+  let content = fs.readFileSync(file, "utf8"); \
+  content = content.replace(/const initialize = async \(\): Promise<void> => {[\s\S]*?};/, "const initialize = async (): Promise<void> => {\n    if (initialized.value) return;\n    roomId.value = \x27ruby_reactor_session\x27;\n    receiveToken.value = \x27default_token\x27;\n    isNewSession.value = false;\n    initialized.value = true;\n  };"); \
+  fs.writeFileSync(file, content, "utf8"); \
+'
+
+
+# Enable corepack and install pnpm
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Install dependencies
+RUN pnpm install --frozen-lockfile
+
+# Build the Nuxt static files
+RUN pnpm build
+
+# Expose port
+EXPOSE 3000
+
+ENV HOST=0.0.0.0
+ENV PORT=3000
+
+# Start Cloudflare Pages local dev server via wrangler
+WORKDIR /app/workers
+CMD ["npx", "wrangler", "dev", "--ip", "0.0.0.0", "--port", "3000"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_reactor
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Artur
@@ -133,10 +133,12 @@ files:
 - lib/ruby_reactor/map/collector.rb
 - lib/ruby_reactor/map/dispatcher.rb
 - lib/ruby_reactor/map/element_executor.rb
-- lib/ruby_reactor/map/execution.rb
 - lib/ruby_reactor/map/helpers.rb
 - lib/ruby_reactor/map/result_enumerator.rb
 - lib/ruby_reactor/max_retries_exhausted_failure.rb
+- lib/ruby_reactor/middleware.rb
+- lib/ruby_reactor/middleware_runner.rb
+- lib/ruby_reactor/open_telemetry.rb
 - lib/ruby_reactor/period.rb
 - lib/ruby_reactor/rate_limit.rb
 - lib/ruby_reactor/reactor.rb
@@ -152,7 +154,6 @@ files:
 - lib/ruby_reactor/sidekiq_adapter.rb
 - lib/ruby_reactor/sidekiq_workers/map_collector_worker.rb
 - lib/ruby_reactor/sidekiq_workers/map_element_worker.rb
-- lib/ruby_reactor/sidekiq_workers/map_execution_worker.rb
 - lib/ruby_reactor/sidekiq_workers/worker.rb
 - lib/ruby_reactor/step.rb
 - lib/ruby_reactor/step/compose_step.rb
@@ -184,6 +185,7 @@ files:
 - llms-full.txt
 - llms.txt
 - sig/ruby_reactor.rbs
+- teley/Dockerfile
 homepage: https://github.com/arturictus/ruby_reactor
 licenses: []
 metadata:

data/lib/ruby_reactor/map/execution.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RubyReactor
-  module Map
-    class Execution
-      extend Helpers
-
-      def self.perform(arguments)
-        arguments = arguments.transform_keys(&:to_sym)
-        storage = RubyReactor.configuration.storage_adapter
-
-        parent_context = load_parent_context_from_storage(
-          arguments[:parent_context_id], arguments[:parent_reactor_class_name], storage
-        )
-        reactor_class = resolve_reactor_class(arguments[:reactor_class_info])
-        inputs = ContextSerializer.deserialize_value(arguments[:serialized_inputs])
-
-        results = execute_all_elements(
-          source: inputs[:source], mappings: inputs[:mappings],
-          reactor_class: reactor_class, parent_context: parent_context,
-          storage_options: {
-            map_id: arguments[:map_id], storage: storage,
-            parent_reactor_class_name: arguments[:parent_reactor_class_name],
-            strict_ordering: arguments[:strict_ordering],
-            fail_fast: arguments[:fail_fast]
-          }
-        )
-
-        finalize_execution(results, parent_context, arguments[:step_name], arguments[:parent_reactor_class_name],
-                           storage)
-      end
-
-      def self.execute_all_elements(source:, mappings:, reactor_class:, parent_context:, storage_options:)
-        # rubocop:disable Metrics/BlockLength
-        source.map.with_index do |element, index|
-          if storage_options[:fail_fast]
-            failed_context_id = storage_options[:storage].retrieve_map_failed_context_id(
-              storage_options[:map_id], storage_options[:parent_reactor_class_name]
-            )
-            next if failed_context_id
-          end
-          element_inputs = build_element_inputs(mappings, parent_context, element)
-
-          # Manually create and link context to ensure parent_context_id is set
-          child_context = RubyReactor::Context.new(element_inputs, reactor_class)
-          link_contexts(child_context, parent_context)
-
-          # Ensure we store the element context linkage
-          storage_options[:storage].store_map_element_context_id(
-            storage_options[:map_id], child_context.context_id, storage_options[:parent_reactor_class_name]
-          )
-
-          # Set map metadata for failure handling
-          metadata = {
-            map_id: storage_options[:map_id],
-            parent_reactor_class_name: storage_options[:parent_reactor_class_name],
-            index: index
-          }
-          child_context.map_metadata = metadata
-
-          executor = RubyReactor::Executor.new(reactor_class, {}, child_context)
-          executor.execute
-          result = executor.result
-
-          store_result(result, index, storage_options)
-
-          if result.failure? && storage_options[:fail_fast]
-            storage_options[:storage].store_map_failed_context_id(
-              storage_options[:map_id], child_context.context_id, storage_options[:parent_reactor_class_name]
-            )
-          end
-
-          result
-        end.compact
-        # rubocop:enable Metrics/BlockLength
-      end
-
-      def self.link_contexts(child_context, parent_context)
-        child_context.parent_context = parent_context
-        child_context.root_context = parent_context.root_context || parent_context
-        child_context.inline_async_execution = parent_context.inline_async_execution
-      end
-
-      def self.store_result(result, index, options)
-        value = result.success? ? result.value : { _error: result.error }
-        options[:storage].store_map_result(
-          options[:map_id], index, ContextSerializer.serialize_value(value), options[:parent_reactor_class_name],
-          strict_ordering: options[:strict_ordering]
-        )
-      end
-
-      def self.finalize_execution(results, parent_context, step_name, parent_reactor_class_name, storage)
-        step_config = Object.const_get(parent_reactor_class_name).steps[step_name.to_sym]
-        final_result = apply_collect_block(results, step_config)
-        resume_parent_execution(parent_context, step_name, final_result, storage)
-      end
-
-      private_class_method :execute_all_elements, :store_result, :finalize_execution
-    end
-  end
-end

data/lib/ruby_reactor/sidekiq_workers/map_execution_worker.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "sidekiq"
-
-module RubyReactor
-  module SidekiqWorkers
-    class MapExecutionWorker
-      include ::Sidekiq::Worker
-
-      def perform(arguments)
-        RubyReactor::Map::Execution.perform(arguments)
-      end
-    end
-  end
-end