igniter 0.4.3 → 0.5.0

data/lib/igniter/runtime/resolver.rb

@@ -29,6 +29,8 @@ module Igniter
                   resolve_effect(node)
                 when :await
                   resolve_await(node)
+                when :aggregate
+                  resolve_aggregate(node)
                 when :remote
                   resolve_remote(node)
                 else
@@ -65,6 +67,26 @@ module Igniter
         NodeState.new(node: node, status: :succeeded, value: @execution.fetch_input!(node.name))
       end
 
+      def resolve_aggregate(node)
+        unless defined?(Igniter::Dataflow)
+          raise ResolutionError,
+                "Aggregate nodes require the dataflow extension. " \
+                "Add: require 'igniter/extensions/dataflow'"
+        end
+
+        collection_result = resolve_dependency_value(node.source_collection)
+        unless collection_result.respond_to?(:diff)
+          raise ResolutionError,
+                "Aggregate '#{node.name}' requires an incremental collection. " \
+                "Ensure '#{node.source_collection}' uses mode: :incremental"
+        end
+
+        agg_state = @execution.aggregate_state_for(node.name)
+        agg_state.apply_diff!(collection_result.diff, collection_result)
+
+        NodeState.new(node: node, status: :succeeded, value: agg_state.value)
+      end
+
       def resolve_effect(node)
         dependencies = node.dependencies.each_with_object({}) do |dep, memo|
           memo[dep] = resolve_dependency_value(dep)
@@ -87,17 +109,19 @@ module Igniter
         raise PendingDependencyError.new(deferred, "Waiting for external event '#{node.event_name}'")
       end
 
-      def resolve_remote(node) # rubocop:disable Metrics/MethodLength
+      def resolve_remote(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         unless defined?(Igniter::Server::Client)
           raise ResolutionError,
                 "remote: nodes require `require 'igniter/server'` (server integration not loaded)"
         end
 
+        url = resolve_remote_url(node)
+
         inputs = node.input_mapping.each_with_object({}) do |(child_input, dep_name), memo|
           memo[child_input] = resolve_dependency_value(dep_name)
         end
 
-        client   = Igniter::Server::Client.new(node.node_url, timeout: node.timeout)
+        client   = Igniter::Server::Client.new(url, timeout: node.timeout)
         response = client.execute(node.contract_name, inputs: inputs)
 
         case response[:status]
@@ -106,25 +130,148 @@ module Igniter
         when :failed
           error_message = response.dig(:error, :message) || response.dig(:error, "message")
           raise ResolutionError,
-                "Remote #{node.contract_name}@#{node.node_url}: #{error_message}"
+                "Remote #{node.contract_name}@#{url}: #{error_message}"
         else
           raise ResolutionError,
-                "Remote #{node.contract_name}@#{node.node_url}: unexpected status '#{response[:status]}'"
+                "Remote #{node.contract_name}@#{url}: unexpected status '#{response[:status]}'"
         end
       rescue Igniter::Server::Client::ConnectionError => e
-        raise ResolutionError, "Cannot reach #{node.node_url}: #{e.message}"
+        raise ResolutionError, "Cannot reach #{url}: #{e.message}"
+      end
+
+      # Resolve the target URL for a remote node based on its routing_mode.
+      # :static     → node_url directly
+      # :capability → Mesh::Router selects an alive peer (raises DeferredCapabilityError if none)
+      # :pinned     → Mesh::Router asserts the peer is alive (raises IncidentError if not)
+      def resolve_remote_url(node) # rubocop:disable Metrics/MethodLength
+        case node.routing_mode
+        when :static
+          node.node_url
+        when :capability
+          unless defined?(Igniter::Mesh)
+            raise ResolutionError,
+                  "remote :#{node.name} uses capability routing — add `require 'igniter/mesh'`"
+          end
+          deferred = Runtime::DeferredResult.build(
+            payload: { capability: node.capability },
+            source_node: node.name,
+            waiting_on: node.name
+          )
+          Igniter::Mesh.router.find_peer_for(node.capability, deferred)
+        when :pinned
+          unless defined?(Igniter::Mesh)
+            raise ResolutionError,
+                  "remote :#{node.name} uses pinned routing — add `require 'igniter/mesh'`"
+          end
+          Igniter::Mesh.router.resolve_pinned(node.pinned_to)
+        end
       end
 
-      def resolve_compute(node)
+      def resolve_compute(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # Capability policy check — raises CapabilityViolationError if denied.
+        check_capability_policy!(node)
+
+        # Running state preserves dep_snapshot + value_version from the stale state.
+        # These are used for memoization (skip recompute) and value backdating.
+        running_state = @execution.cache.fetch(node.name)
+        old_dep_snapshot = running_state&.dep_snapshot
+        old_value = running_state&.value
+        old_value_version = running_state&.value_version || 0
+
+        # Resolve all dependencies (may recursively recompute upstream nodes).
         dependencies = node.dependencies.each_with_object({}) do |dependency_name, memo|
           memo[dependency_name] = resolve_dependency_value(dependency_name)
         end
 
+        # Build snapshot of current dep value_versions (only regular nodes, not outputs).
+        current_dep_snapshot = build_dep_snapshot(node)
+
+        # Memoization: if all dep value_versions are unchanged, skip the compute entirely.
+        if old_dep_snapshot && old_value && old_value_version.positive? &&
+           dep_snapshot_match?(current_dep_snapshot, old_dep_snapshot)
+          @execution.events.emit(:node_skipped, node: node, status: :succeeded,
+                                                payload: { reason: :deps_unchanged })
+          return NodeState.new(node: node, status: :succeeded, value: old_value,
+                               value_version: old_value_version,
+                               dep_snapshot: current_dep_snapshot)
+        end
+
+        # Content-addressed cache: pure executor + same dep values → reuse across executions.
+        if (content_key = build_content_key(node, dependencies))
+          cached_value = Igniter::ContentAddressing.cache.fetch(content_key)
+          if cached_value
+            @execution.events.emit(:node_content_cache_hit, node: node, status: :succeeded,
+                                                            payload: { key: content_key.to_s })
+            return NodeState.new(node: node, status: :succeeded, value: cached_value,
+                                 dep_snapshot: current_dep_snapshot)
+          end
+        end
+
+        # TTL cache: any compute node + same dep fingerprint → reuse across executions.
+        ttl_key             = build_ttl_cache_key(node, dependencies)
+        is_coalescing_leader = false
+
+        if ttl_key
+          if (cached_value = Igniter::NodeCache.cache.fetch(ttl_key))
+            @execution.events.emit(:node_ttl_cache_hit, node: node, status: :succeeded,
+                                                        payload: { key: ttl_key.to_s })
+            return NodeState.new(node: node, status: :succeeded, value: cached_value,
+                                 dep_snapshot: current_dep_snapshot)
+          end
+
+          # Coalescing: if another execution is already computing this node for the same
+          # inputs, join as a follower instead of duplicating the work.
+          if node.coalesce? && (lock = Igniter::NodeCache.coalescing_lock)
+            role, flight = lock.acquire(ttl_key.hex)
+            if role == :follower
+              coalesced_value, coalesced_error = lock.wait(flight)
+              raise coalesced_error if coalesced_error
+
+              # Follower timed out — coalesced_value is nil, fall through to compute independently
+              unless coalesced_value.nil? && coalesced_error.nil? && !flight.done
+                @execution.events.emit(:node_coalesced, node: node, status: :succeeded,
+                                                        payload: { key: ttl_key.to_s })
+                return NodeState.new(node: node, status: :succeeded, value: coalesced_value,
+                                     dep_snapshot: current_dep_snapshot)
+              end
+            else
+              is_coalescing_leader = true
+            end
+          end
+        end
+
         value = call_compute(node.callable, dependencies)
-        return NodeState.new(node: node, status: :pending, value: normalize_deferred_result(value, node)) if deferred_result?(value)
+        if deferred_result?(value)
+          return NodeState.new(node: node, status: :pending,
+                               value: normalize_deferred_result(value, node))
+        end
+
         value = normalize_guard_value(node, value)
 
-        NodeState.new(node: node, status: :succeeded, value: value)
+        # Value backdating: if the output is unchanged, preserve value_version so that
+        # downstream nodes whose dep_snapshots reference this node won't see it as changed.
+        if old_value && old_value_version.positive? && value == old_value
+          @execution.events.emit(:node_backdated, node: node, status: :succeeded,
+                                                  payload: { reason: :value_unchanged })
+          store_ttl_result(ttl_key, value, node, is_coalescing_leader)
+          return NodeState.new(node: node, status: :succeeded, value: value,
+                               value_version: old_value_version,
+                               dep_snapshot: current_dep_snapshot)
+        end
+
+        # Store in content cache for future executions.
+        Igniter::ContentAddressing.cache.store(content_key, value) if content_key
+
+        # Store in TTL cache and notify any coalescing followers.
+        store_ttl_result(ttl_key, value, node, is_coalescing_leader)
+
+        NodeState.new(node: node, status: :succeeded, value: value,
+                      dep_snapshot: current_dep_snapshot)
+      rescue StandardError => e
+        # If this execution was the coalescing leader, notify followers of the failure
+        # so they are unblocked (they will re-raise the error through their own path).
+        Igniter::NodeCache.coalescing_lock&.finish!(ttl_key&.hex, error: e) if is_coalescing_leader
+        raise
       end
 
       def call_compute(callable, dependencies)
@@ -151,11 +298,9 @@ module Igniter
       end
 
       def call_compute_object(callable, dependencies)
-        if callable.respond_to?(:call)
-          callable.call(**dependencies)
-        else
-          raise ResolutionError, "Unsupported callable: #{callable.class}"
-        end
+        raise ResolutionError, "Unsupported callable: #{callable.class}" unless callable.respond_to?(:call)
+
+        callable.call(**dependencies)
       end
 
       def resolve_composition(node)
@@ -222,6 +367,8 @@ module Igniter
       end
 
       def resolve_collection(node)
+        return resolve_incremental_collection(node) if node.mode == :incremental
+
         items = resolve_dependency_value(node.source_dependency)
         context_values = node.context_dependencies.each_with_object({}) do |dependency_name, memo|
           memo[dependency_name] = resolve_dependency_value(dependency_name)
@@ -277,17 +424,93 @@ module Igniter
         )
       end
 
+      def resolve_incremental_collection(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        unless defined?(Igniter::Dataflow)
+          raise ResolutionError.new(
+            "Collection '#{node.name}' uses mode: :incremental — " \
+            "add `require 'igniter/extensions/dataflow'` to activate it",
+            context: collection_context(node)
+          )
+        end
+
+        items = resolve_dependency_value(node.source_dependency)
+        context_values = node.context_dependencies.each_with_object({}) do |dep_name, memo|
+          memo[dep_name] = resolve_dependency_value(dep_name)
+        end
+
+        normalized_items = normalize_collection_items(node, items, context_values)
+        normalized_items = Igniter::Dataflow::WindowFilter.new(node.window).apply(normalized_items) if node.window
+
+        diff_state = @execution.diff_state_for(node.name)
+        key_fn     = ->(item) { extract_collection_key(node, item) }
+        diff       = diff_state.compute_diff(normalized_items, key_fn)
+
+        collection_items = {}
+
+        # Reuse cached results for unchanged items (no child contract re-run)
+        diff.unchanged.each do |key|
+          cached = diff_state.cached_item_for(key)
+          collection_items[key] = cached if cached
+          emit_collection_item_event(:collection_item_reused, node, key)
+        end
+
+        # Retract removed items from the diff state
+        diff.removed.each { |key| diff_state.retract!(key) }
+
+        # Run child contracts only for added + changed items
+        to_process = normalized_items.select { |item| diff.added.include?(key_fn.call(item)) || diff.changed.include?(key_fn.call(item)) }
+
+        to_process.each do |item_inputs|
+          item_key = key_fn.call(item_inputs)
+          emit_collection_item_event(:collection_item_started, node, item_key, item_inputs: item_inputs)
+          child_contract = node.contract_class.new(item_inputs)
+          begin
+            child_contract.resolve_all
+          rescue Igniter::Error
+            nil
+          end
+          child_error = child_contract.execution.cache.values.find(&:failed?)&.error
+
+          result_item = if child_error
+            emit_collection_item_event(:collection_item_failed, node, item_key, error: child_error.message, error_type: child_error.class.name, child_execution_id: child_contract.execution.events.execution_id)
+            Runtime::CollectionResult::Item.new(key: item_key, status: :failed, error: child_error)
+          else
+            emit_collection_item_event(:collection_item_succeeded, node, item_key, child_execution_id: child_contract.execution.events.execution_id)
+            Runtime::CollectionResult::Item.new(key: item_key, status: :succeeded, result: child_contract.result)
+          end
+
+          collection_items[item_key] = result_item
+          diff_state.update!(item_key, item_inputs, result_item)
+        end
+
+        # Preserve the input array ordering in the result
+        ordered_items = normalized_items.each_with_object({}) do |item_inputs, memo|
+          key = key_fn.call(item_inputs)
+          memo[key] = collection_items[key] if collection_items.key?(key)
+        end
+
+        NodeState.new(
+          node: node,
+          status: :succeeded,
+          value: Igniter::Dataflow::IncrementalCollectionResult.new(items: ordered_items, diff: diff)
+        )
+      end
+
       def resolve_dependency_value(dependency_name)
         if @execution.compiled_graph.node?(dependency_name)
           dependency_state = resolve(dependency_name)
           raise dependency_state.error if dependency_state.failed?
-          raise PendingDependencyError.new(dependency_state.value, context: pending_context(dependency_state.node)) if dependency_state.pending?
+
+          if dependency_state.pending?
+            raise PendingDependencyError.new(dependency_state.value,
+                                             context: pending_context(dependency_state.node))
+          end
 
           dependency_state.value
         elsif @execution.compiled_graph.outputs_by_name.key?(dependency_name.to_sym)
           output = @execution.compiled_graph.fetch_output(dependency_name)
           value = @execution.send(:resolve_exported_output, output)
-          raise PendingDependencyError.new(value) if deferred_result?(value)
+          raise PendingDependencyError, value if deferred_result?(value)
 
           value
         else
@@ -357,21 +580,89 @@ module Igniter
       end
 
       def normalize_error(error, node)
-        return error if error.is_a?(Igniter::Error)
+        # Trust any Igniter::Error that already carries node context.
+        return error if error.is_a?(Igniter::Error) && error.node_name
 
-        ResolutionError.new(
-          error.message,
-          context: {
-            graph: @execution.compiled_graph.name,
-            node_id: node.id,
-            node_name: node.name,
-            node_path: node.path,
-            source_location: node.source_location,
-            execution_id: @execution.events.execution_id
-          }
+        # Domain-specific subclasses (IncidentError, DeferredCapabilityError,
+        # InvariantError, …) carry semantics the caller depends on — preserve
+        # their type unchanged. Only bare Igniter::ResolutionError instances
+        # (raised with just a message inside an executor) get enriched.
+        return error if error.is_a?(Igniter::Error) && !error.instance_of?(Igniter::ResolutionError)
+
+        node_context = {
+          graph: @execution.compiled_graph.name,
+          node_id: node.id,
+          node_name: node.name,
+          node_path: node.path,
+          source_location: node.source_location,
+          execution_id: @execution.events.execution_id
+        }
+
+        ResolutionError.new(error.message, context: node_context)
+      end
+
+      # ─── Capabilities ──────────────────────────────────────────────────────────
+
+      def check_capability_policy!(node)
+        return unless defined?(Igniter::Capabilities) && Igniter::Capabilities.policy
+        return unless node.callable.is_a?(Class) && node.callable <= Igniter::Executor
+
+        Igniter::Capabilities.policy.check!(node.name, node.callable)
+      end
+
+      # ─── Content addressing ────────────────────────────────────────────────────
+
+      # Returns a ContentKey for pure executors when content addressing is loaded.
+      # Returns nil for non-pure executors, Procs, or when the extension is absent.
+      def build_content_key(node, dep_values)
+        return unless defined?(Igniter::ContentAddressing)
+        return unless node.callable.is_a?(Class) && node.callable <= Igniter::Executor
+        return unless node.callable.pure?
+
+        Igniter::ContentAddressing::ContentKey.compute(node.callable, dep_values)
+      end
+
+      # ─── TTL cache ─────────────────────────────────────────────────────────────
+
+      # Returns a NodeCache::CacheKey when TTL caching is active for this node.
+      # Returns nil when NodeCache is not loaded, no backend is configured,
+      # or the node has no cache_ttl declared.
+      def build_ttl_cache_key(node, dep_values)
+        return unless defined?(Igniter::NodeCache)
+        return unless Igniter::NodeCache.cache
+        return unless node.respond_to?(:cache_ttl) && node.cache_ttl
+
+        dep_hex = Igniter::NodeCache::Fingerprinter.call(dep_values)
+        Igniter::NodeCache::CacheKey.new(
+          @execution.compiled_graph.name,
+          node.name,
+          dep_hex
         )
       end
 
+      # Stores a computed value in the TTL cache and signals any coalescing followers.
+      def store_ttl_result(ttl_key, value, node, is_leader)
+        return unless ttl_key
+
+        Igniter::NodeCache.cache.store(ttl_key, value, ttl: node.cache_ttl)
+        Igniter::NodeCache.coalescing_lock&.finish!(ttl_key.hex, value: value) if is_leader
+      end
+
+      def build_dep_snapshot(node)
+        node.dependencies.each_with_object({}) do |dep_name, memo|
+          next unless @execution.compiled_graph.node?(dep_name)
+
+          dep_state = @execution.cache.fetch(dep_name.to_sym)
+          memo[dep_name] = dep_state&.value_version
+        end
+      end
+
+      def dep_snapshot_match?(current, old)
+        return false if current.size != old.size
+
+        current.all? { |name, vv| old[name] == vv }
+      end
+
       def normalize_guard_value(node, value)
         return value unless node.respond_to?(:guard?) && node.guard?
         return true if value
@@ -389,9 +680,7 @@ module Igniter
       end
 
       def normalize_collection_items(node, items, context_values = {})
-        if node.input_mapper? && items.is_a?(Hash)
-          items = items.to_a
-        end
+        items = items.to_a if node.input_mapper? && items.is_a?(Hash)
 
         unless items.is_a?(Array)
           raise CollectionInputError.new(
@@ -440,14 +729,17 @@ module Igniter
 
       def ensure_unique_collection_keys!(node, items)
         keys = items.map do |item|
-          item.fetch(node.key_name) { raise CollectionKeyError.new("Collection '#{node.name}' item is missing key '#{node.key_name}'", context: collection_context(node)) }
+          item.fetch(node.key_name) do
+            raise CollectionKeyError.new("Collection '#{node.name}' item is missing key '#{node.key_name}'",
+                                         context: collection_context(node))
+          end
         end
 
         duplicates = keys.group_by(&:itself).select { |_key, entries| entries.size > 1 }.keys
         return if duplicates.empty?
 
         raise CollectionKeyError.new(
-          "Collection '#{node.name}' has duplicate keys: #{duplicates.join(', ')}",
+          "Collection '#{node.name}' has duplicate keys: #{duplicates.join(", ")}",
           context: collection_context(node)
         )
       end

data/lib/igniter/runtime/stores/redis_store.rb

@@ -11,22 +11,46 @@ module Igniter
           @namespace = namespace
         end
 
-        def save(snapshot, correlation: nil, graph: nil) # rubocop:disable Lint/UnusedMethodArgument
+        # Save a snapshot. Maintains secondary indexes:
+        #   {namespace}:all               — set of all execution_ids
+        #   {namespace}:graph:{name}      — set of execution_ids for a given graph
+        #   {namespace}:corr:{graph}      — hash of JSON(sorted_correlation) → execution_id
+        def save(snapshot, correlation: nil, graph: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
           execution_id = snapshot[:execution_id] || snapshot["execution_id"]
           @redis.set(redis_key(execution_id), JSON.generate(snapshot))
+          @redis.sadd(all_key, execution_id)
+
+          if graph
+            @redis.sadd(graph_key(graph), execution_id)
+            if correlation && !correlation.empty?
+              corr_json = JSON.generate(correlation.transform_keys(&:to_s).sort.to_h)
+              @redis.hset(correlation_key(graph), corr_json, execution_id)
+            end
+          end
+
           execution_id
         end
 
         def find_by_correlation(graph:, correlation:)
-          raise NotImplementedError, "find_by_correlation is not implemented for RedisStore"
+          normalized = correlation.transform_keys(&:to_s).sort.to_h
+          @redis.hget(correlation_key(graph), JSON.generate(normalized))
         end
 
         def list_all(graph: nil)
-          raise NotImplementedError, "list_all is not implemented for RedisStore"
+          @redis.smembers(graph ? graph_key(graph) : all_key)
         end
 
         def list_pending(graph: nil)
-          raise NotImplementedError, "list_pending is not implemented for RedisStore"
+          list_all(graph: graph).select do |id|
+            payload = @redis.get(redis_key(id))
+            next false unless payload
+
+            snapshot = JSON.parse(payload)
+            states   = snapshot["states"] || {}
+            states.any? { |_name, state| state["status"].to_s == "pending" }
+          rescue StandardError
+            false
+          end
         end
 
         def fetch(execution_id)
@@ -38,6 +62,7 @@ module Igniter
 
         def delete(execution_id)
           @redis.del(redis_key(execution_id))
+          @redis.srem(all_key, execution_id)
         end
 
         def exist?(execution_id)
@@ -50,6 +75,18 @@ module Igniter
         def redis_key(execution_id)
           "#{@namespace}:#{execution_id}"
         end
+
+        def all_key
+          "#{@namespace}:all"
+        end
+
+        def graph_key(graph)
+          "#{@namespace}:graph:#{graph}"
+        end
+
+        def correlation_key(graph)
+          "#{@namespace}:corr:#{graph}"
+        end
       end
     end
   end

data/lib/igniter/server/client.rb

@@ -8,7 +8,7 @@ module Igniter
   module Server
     # HTTP client for calling remote igniter-server nodes.
     # Uses only stdlib (Net::HTTP + JSON), no external gems required.
-    class Client
+    class Client # rubocop:disable Metrics/ClassLength
       class Error < Igniter::Server::Error; end
       class ConnectionError < Error; end
       class RemoteError < Error; end
@@ -51,6 +51,40 @@ module Igniter
         get("/v1/health")
       end
 
+      # Fetch peer manifest: peer_name, capabilities, contracts, url.
+      def manifest
+        response = get("/v1/manifest")
+        {
+          peer_name: response["peer_name"],
+          capabilities: (response["capabilities"] || []).map(&:to_sym),
+          contracts: response["contracts"] || [],
+          url: response["url"]
+        }
+      end
+
+      # Fetch the list of all peers known to the remote node.
+      # Returns an Array of hashes with :name, :url, :capabilities (Array<Symbol>).
+      def list_peers
+        Array(get("/v1/mesh/peers")).map do |p|
+          {
+            name: p["name"],
+            url: p["url"],
+            capabilities: Array(p["capabilities"]).map(&:to_sym)
+          }
+        end
+      end
+
+      # Register this node as a peer on the remote node.
+      def register_peer(name:, url:, capabilities: [])
+        post("/v1/mesh/peers",
+             { "name" => name, "url" => url, "capabilities" => capabilities.map(&:to_s) })
+      end
+
+      # Remove a peer registration from the remote node. Best-effort.
+      def unregister_peer(name)
+        delete_request("/v1/mesh/peers/#{uri_encode(name)}")
+      end
+
       private
 
       def post(path, body)
@@ -72,6 +106,15 @@ module Igniter
         raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
       end
 
+      def delete_request(path)
+        uri  = build_uri(path)
+        http = build_http(uri)
+        req  = Net::HTTP::Delete.new(uri.path, json_headers)
+        parse_response(http.request(req))
+      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout => e
+        raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
+      end
+
       def build_uri(path)
         URI.parse("#{@base_url}#{path}")
       end

data/lib/igniter/server/config.rb

@@ -3,15 +3,22 @@
 module Igniter
   module Server
     class Config
-      attr_accessor :host, :port, :store, :logger
+      attr_accessor :host, :port, :store, :logger,
+                    :metrics_collector, :log_format, :drain_timeout,
+                    :peer_name, :peer_capabilities
       attr_reader   :registry
 
       def initialize
-        @host     = "0.0.0.0"
-        @port     = 4567
-        @store    = Igniter::Runtime::Stores::MemoryStore.new
-        @registry = Registry.new
-        @logger   = nil
+        @host              = "0.0.0.0"
+        @port              = 4567
+        @store             = Igniter::Runtime::Stores::MemoryStore.new
+        @registry          = Registry.new
+        @logger            = nil
+        @metrics_collector = nil
+        @log_format        = :text
+        @drain_timeout     = 30
+        @peer_name         = nil
+        @peer_capabilities = []
       end
 
       def register(name, contract_class)

data/lib/igniter/server/handlers/event_handler.rb

@@ -4,6 +4,10 @@ module Igniter
   module Server
     module Handlers
       class EventHandler < Base
+        def initialize(registry, store, collector: nil) # rubocop:disable Lint/UnusedMethodArgument
+          super(registry, store)
+        end
+
         private
 
         def handle(params:, body:) # rubocop:disable Metrics/MethodLength

data/lib/igniter/server/handlers/execute_handler.rb

@@ -4,6 +4,11 @@ module Igniter
   module Server
     module Handlers
       class ExecuteHandler < Base
+        def initialize(registry, store, collector: nil)
+          super(registry, store)
+          @collector = collector
+        end
+
         private
 
         def handle(params:, body:)
@@ -18,6 +23,7 @@ module Igniter
             contract_class.start(inputs, store: @store)
           else
             contract = contract_class.new(inputs)
+            contract.execution.events.subscribe(@collector) if @collector
             begin
               contract.resolve_all
             rescue Igniter::Error