legionio 1.7.8 → 1.7.13

data/lib/legion/task_outcome_observer.rb

@@ -41,7 +41,7 @@ module Legion
         record_learning(domain: domain, success: success)
         publish_lesson(runner: runner_class, function: function, success: success)
       rescue StandardError => e
-        Legion::Logging.debug "[TaskOutcomeObserver] handle_outcome error: #{e.message}" if defined?(Legion::Logging)
+        Legion::Logging.warn "[TaskOutcomeObserver] handle_outcome error: #{e.class}: #{e.message}" if defined?(Legion::Logging)
       end
 
       def derive_domain(runner_class)
@@ -53,13 +53,15 @@ module Legion
       end
 
       def record_learning(domain:, success:)
-        return unless defined?(Legion::Extensions::Agentic::Learning::MetaLearning)
+        client = meta_learning_client
+        return unless client
 
-        Legion::Extensions::Agentic::Learning::MetaLearning.record_learning_episode(
-          domain_id: domain, success: success
-        )
+        domain_id = resolve_learning_domain_id(client, domain)
+        return unless domain_id
+
+        client.record_learning_episode(domain_id: domain_id, success: success)
       rescue StandardError => e
-        Legion::Logging.debug "[TaskOutcomeObserver] record_learning failed: #{e.message}" if defined?(Legion::Logging)
+        Legion::Logging.warn "[TaskOutcomeObserver] record_learning failed: #{e.class}: #{e.message}" if defined?(Legion::Logging)
       end
 
       def publish_lesson(runner:, function:, success:, **_opts)
@@ -76,7 +78,7 @@ module Legion
           is_inference:     false
         )
       rescue StandardError => e
-        Legion::Logging.debug "[TaskOutcomeObserver] publish_lesson failed: #{e.message}" if defined?(Legion::Logging)
+        Legion::Logging.warn "[TaskOutcomeObserver] publish_lesson failed: #{e.class}: #{e.message}" if defined?(Legion::Logging)
       end
 
       def setup_llm_reflection_hook
@@ -94,7 +96,29 @@ module Legion
         Legion::LLM::Hooks::Reflection.install
         Legion::Logging.info '[TaskOutcomeObserver] LLM reflection hook auto-installed'
       rescue StandardError => e
-        Legion::Logging.debug "[TaskOutcomeObserver] LLM reflection hook install failed: #{e.message}" if defined?(Legion::Logging)
+        Legion::Logging.warn "[TaskOutcomeObserver] LLM reflection hook install failed: #{e.class}: #{e.message}" if defined?(Legion::Logging)
+      end
+
+      def meta_learning_client
+        return unless defined?(Legion::Extensions::Agentic::Learning::MetaLearning::Client)
+
+        @meta_learning_client ||= Legion::Extensions::Agentic::Learning::MetaLearning::Client.new
+      end
+
+      def resolve_learning_domain_id(client, domain)
+        domain_map = learning_domain_map
+        return domain_map[domain] if domain_map.key?(domain)
+
+        result = client.create_learning_domain(name: domain)
+        return if result.is_a?(Hash) && result[:error]
+
+        domain_id = result[:id]
+        domain_map[domain] = domain_id if domain_id
+        domain_id
+      end
+
+      def learning_domain_map
+        @learning_domain_map ||= {}
       end
     end
   end

data/lib/legion/telemetry.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'legion/logging/helper'
+
 module Legion
   module Telemetry
+    extend Legion::Logging::Helper
+
     autoload :OpenInference, 'legion/telemetry/open_inference'
     autoload :SafetyMetrics, 'legion/telemetry/safety_metrics'
 
@@ -11,14 +15,14 @@ module Legion
       defined?(OpenTelemetry::Trace) &&
         OpenTelemetry::Trace.current_span != OpenTelemetry::Trace::Span::INVALID
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#otel_available? failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.otel_available')
       false
     end
 
     def enabled?
       defined?(OpenTelemetry::SDK) ? true : false
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#enabled? failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.enabled')
       false
     end
 
@@ -29,13 +33,13 @@ module Legion
         return
       end
 
-      Legion::Logging.debug "[Telemetry] span: #{name}" if defined?(Legion::Logging)
+      log.debug { "[Telemetry] starting span=#{name} kind=#{kind}" }
       tracer = OpenTelemetry.tracer_provider.tracer('legion', Legion::VERSION)
       tracer.in_span(name, kind: kind, attributes: sanitize_attributes(attributes), &)
     rescue StandardError => e
       raise if block_given? && !otel_init_error?(e)
 
-      Legion::Logging.debug "[Telemetry] span error for #{name}: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.with_span', span_name: name, kind: kind)
       yield(nil) if block_given?
     end
 
@@ -45,7 +49,7 @@ module Legion
       span.record_exception(exception)
       span.status = OpenTelemetry::Trace::Status.error(exception.message)
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#record_exception failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.record_exception')
       nil
     end
 
@@ -60,7 +64,7 @@ module Legion
         [k.to_s, val]
       end
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#sanitize_attributes failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.sanitize_attributes')
       {}
     end
 
@@ -82,14 +86,14 @@ module Legion
       tracing = telemetry[:tracing]
       tracing.is_a?(Hash) ? tracing : {}
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#tracing_settings failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.tracing_settings')
       {}
     end
 
     def otel_init_error?(error)
       error.message.include?('OpenTelemetry') || error.message.include?('tracer')
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#otel_init_error? check failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.otel_init_error?')
       false
     end
 
@@ -111,10 +115,13 @@ module Legion
       )
 
       OpenTelemetry.tracer_provider.add_span_processor(processor)
-      Legion::Logging.info "OTLP exporter configured: #{endpoint}"
+      log.info "OTLP exporter configured: #{endpoint}"
       true
     rescue LoadError
-      Legion::Logging.warn 'opentelemetry-exporter-otlp gem not available'
+      log.warn 'opentelemetry-exporter-otlp gem not available'
+      false
+    rescue StandardError => e
+      handle_exception(e, level: :warn, operation: 'telemetry.configure_otlp', endpoint: endpoint)
       false
     end
 
@@ -124,9 +131,10 @@ module Legion
       exporter = OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
       processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter)
       OpenTelemetry.tracer_provider.add_span_processor(processor)
+      log.info 'Console telemetry exporter configured'
       true
     rescue StandardError => e
-      Legion::Logging.debug "Telemetry#configure_console failed: #{e.message}" if defined?(Legion::Logging)
+      handle_exception(e, level: :debug, operation: 'telemetry.configure_console')
       false
     end
   end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.7.8'
+  VERSION = '1.7.13'
 end

data/lib/legion/webhooks.rb

@@ -3,10 +3,15 @@
 require 'openssl'
 require 'net/http'
 require 'uri'
+require 'legion/logging/helper'
 
 module Legion
   module Webhooks
+    DISPATCH_CACHE_TTL = 5
+
     class << self
+      include Legion::Logging::Helper
+
       def register(url:, secret:, event_types: ['*'], max_retries: 5, **)
         return { error: 'data_unavailable' } unless db_available?
 
@@ -19,6 +24,7 @@ module Legion
           created_at:  Time.now.utc,
           updated_at:  Time.now.utc
         )
+        invalidate_dispatch_cache!
         { registered: true, id: id }
       end
 
@@ -26,6 +32,7 @@ module Legion
         return { error: 'data_unavailable' } unless db_available?
 
         Legion::Data.connection[:webhooks].where(id: id).delete
+        invalidate_dispatch_cache!
         { unregistered: true }
       end
 
@@ -38,26 +45,111 @@ module Legion
       def dispatch(event_name, payload)
         return unless db_available?
 
-        webhooks = Legion::Data.connection[:webhooks].where(status: 'active').all
+        webhooks = active_dispatch_webhooks
         webhooks.each do |wh|
-          patterns = begin
-            Legion::JSON.load(wh[:event_types])
-          rescue StandardError => e
-            Legion::Logging.debug("Webhooks#dispatch event_types parse failed: #{e.message}") if defined?(Legion::Logging)
-            ['*']
-          end
+          patterns = event_patterns_for(wh, event_name: event_name)
           next unless patterns.any? { |p| File.fnmatch?(p, event_name) }
 
+          log.debug { "[Webhooks] dispatching event=#{event_name} webhook_id=#{wh[:id]} patterns=#{patterns.size}" }
           deliver(wh, event_name, payload)
         end
       end
 
       def deliver(webhook, event_name, payload, attempt: 1)
-        Legion::Logging.info "[Webhooks] delivery attempt #{attempt} for event=#{event_name} url=#{webhook[:url]}" if defined?(Legion::Logging)
-        body = Legion::JSON.dump({ event: event_name, payload: payload, timestamp: Time.now.utc.iso8601 })
+        log.info "[Webhooks] delivery attempt #{attempt} for event=#{event_name} url=#{webhook[:url]}"
+        body = delivery_body(event_name, payload)
         signature = compute_signature(webhook[:secret], body)
 
-        uri = URI.parse(webhook[:url])
+        response = perform_delivery_request(webhook[:url], event_name, body, signature)
+        success = response.code.to_i < 400
+
+        if success
+          log.info "[Webhooks] delivered event=#{event_name} status=#{response.code}"
+        else
+          log.warn "[Webhooks] delivery failed event=#{event_name} status=#{response.code} url=#{webhook[:url]}"
+        end
+
+        handle_delivery_response(
+          webhook:    webhook,
+          event_name: event_name,
+          payload:    payload,
+          response:   response,
+          success:    success,
+          attempt:    attempt
+        )
+      rescue StandardError => e
+        handle_exception(
+          e,
+          level:      :error,
+          operation:  'webhooks.deliver',
+          event_name: event_name,
+          webhook_id: webhook[:id],
+          attempt:    attempt,
+          url:        webhook[:url]
+        )
+        handle_delivery_exception(webhook, event_name, payload, attempt, e)
+      end
+
+      def compute_signature(secret, body)
+        OpenSSL::HMAC.hexdigest('SHA256', secret, body)
+      end
+
+      private
+
+      def invalidate_dispatch_cache!
+        @active_webhooks_cache = nil
+        @active_webhooks_cached_at = nil
+        @pattern_cache = {}
+      end
+
+      def active_dispatch_webhooks
+        cache_valid = @active_webhooks_cache && @active_webhooks_cached_at &&
+                      (monotonic_now - @active_webhooks_cached_at) < DISPATCH_CACHE_TTL
+        return @active_webhooks_cache if cache_valid
+
+        @active_webhooks_cache = Legion::Data.connection[:webhooks].where(status: 'active').all
+        @active_webhooks_cached_at = monotonic_now
+        @active_webhooks_cache
+      end
+
+      def monotonic_now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
+      def event_patterns_for(webhook, event_name:)
+        @pattern_cache ||= {}
+        cached_entry = @pattern_cache[webhook[:id]]
+
+        if cached_entry &&
+           cached_entry[:updated_at] == webhook[:updated_at] &&
+           cached_entry[:event_types] == webhook[:event_types]
+          return cached_entry[:patterns]
+        end
+
+        patterns = parse_event_patterns(webhook[:event_types], webhook_id: webhook[:id], event_name: event_name)
+        @pattern_cache[webhook[:id]] = {
+          updated_at:  webhook[:updated_at],
+          event_types: webhook[:event_types],
+          patterns:    patterns
+        }
+        patterns
+      end
+
+      def parse_event_patterns(raw_event_types, webhook_id:, event_name:)
+        parsed = Legion::JSON.load(raw_event_types)
+        Array(parsed).map(&:to_s).reject(&:empty?).then { |patterns| patterns.empty? ? ['*'] : patterns }
+      rescue StandardError => e
+        handle_exception(e, level: :debug, operation: 'webhooks.dispatch.parse_event_types',
+                            event_name: event_name, webhook_id: webhook_id)
+        ['*']
+      end
+
+      def delivery_body(event_name, payload)
+        Legion::JSON.dump({ event: event_name, payload: payload, timestamp: Time.now.utc.iso8601 })
+      end
+
+      def perform_delivery_request(url, event_name, body, signature)
+        uri = URI.parse(url)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = uri.scheme == 'https'
         http.open_timeout = 5
@@ -68,54 +160,90 @@ module Legion
         request['X-Legion-Signature'] = "sha256=#{signature}"
         request['X-Legion-Event'] = event_name
         request.body = body
+        http.request(request)
+      end
 
-        response = http.request(request)
-        success = response.code.to_i < 400
+      def handle_delivery_response(delivery)
+        error_message = "http_status=#{delivery[:response].code}" unless delivery[:success]
+        record_delivery(
+          webhook_id: delivery[:webhook][:id],
+          event_name: delivery[:event_name],
+          status:     delivery[:response].code.to_i,
+          success:    delivery[:success],
+          error:      error_message,
+          attempt:    delivery[:attempt]
+        )
+        return { delivered: true, status: delivery[:response].code.to_i } if delivery[:success]
 
-        if success
-          Legion::Logging.info "[Webhooks] delivered event=#{event_name} status=#{response.code}" if defined?(Legion::Logging)
-        elsif defined?(Legion::Logging)
-          Legion::Logging.error "[Webhooks] delivery failed event=#{event_name} status=#{response.code} url=#{webhook[:url]}"
-        end
+        finalize_failure(
+          webhook:         delivery[:webhook],
+          event_name:      delivery[:event_name],
+          payload:         delivery[:payload],
+          attempt:         delivery[:attempt],
+          error:           error_message,
+          response_status: delivery[:response].code.to_i
+        )
+      end
 
-        record_delivery(webhook[:id], event_name, response.code.to_i, success)
-        { delivered: success, status: response.code.to_i }
-      rescue StandardError => e
-        Legion::Logging.error "[Webhooks] delivery error event=#{event_name}: #{e.message}" if defined?(Legion::Logging)
-        record_delivery(webhook[:id], event_name, nil, false, error: e.message)
-        if attempt < (webhook[:max_retries] || 5)
-          Legion::Logging.warn "[Webhooks] will retry event=#{event_name} attempt=#{attempt}" if defined?(Legion::Logging)
-          { delivered: false, error: e.message, will_retry: true }
-        else
-          dead_letter(webhook[:id], event_name, payload, attempt, e.message)
-          { delivered: false, error: e.message, dead_lettered: true }
+      def handle_delivery_exception(webhook, event_name, payload, attempt, error)
+        record_delivery(
+          webhook_id: webhook[:id],
+          event_name: event_name,
+          status:     nil,
+          success:    false,
+          error:      error.message,
+          attempt:    attempt
+        )
+        finalize_failure(
+          webhook:    webhook,
+          event_name: event_name,
+          payload:    payload,
+          attempt:    attempt,
+          error:      error.message
+        )
+      end
+
+      def finalize_failure(failure)
+        if retry_pending?(failure[:webhook], failure[:attempt])
+          next_attempt = failure[:attempt] + 1
+          log.warn "[Webhooks] retrying event=#{failure[:event_name]} next_attempt=#{next_attempt}"
+          return deliver(failure[:webhook], failure[:event_name], failure[:payload], attempt: next_attempt)
         end
+
+        dead_letter(failure[:webhook][:id], failure[:event_name], failure[:payload], failure[:attempt], failure[:error])
+        { delivered: false, error: failure[:error], dead_lettered: true, status: failure[:response_status] }
       end
 
-      def compute_signature(secret, body)
-        OpenSSL::HMAC.hexdigest('SHA256', secret, body)
+      def retry_pending?(webhook, attempt)
+        attempt <= retry_limit(webhook)
       end
 
-      private
+      def retry_limit(webhook)
+        retries = webhook[:max_retries].to_i
+        retries.negative? ? 0 : retries
+      end
 
       def db_available?
         defined?(Legion::Data) && Legion::Data.respond_to?(:connection) && Legion::Data.connection
       rescue StandardError => e
-        Legion::Logging.debug("Webhooks#db_available? failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :debug, operation: 'webhooks.db_available?')
         false
       end
 
-      def record_delivery(webhook_id, event_name, status, success, error: nil)
+      def record_delivery(delivery)
         Legion::Data.connection[:webhook_deliveries].insert(
-          webhook_id:      webhook_id,
-          event_name:      event_name,
-          response_status: status,
-          success:         success,
-          error:           error,
+          webhook_id:      delivery[:webhook_id],
+          event_name:      delivery[:event_name],
+          response_status: delivery[:status],
+          success:         delivery[:success],
+          attempt:         delivery.fetch(:attempt, 1),
+          error:           delivery[:error],
           delivered_at:    Time.now.utc
         )
       rescue StandardError => e
-        Legion::Logging.debug("Webhooks#record_delivery failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :debug, operation: 'webhooks.record_delivery',
+                            webhook_id: delivery[:webhook_id], event_name: delivery[:event_name],
+                            status: delivery[:status], success: delivery[:success], attempt: delivery.fetch(:attempt, 1))
         nil
       end
 
@@ -129,7 +257,8 @@ module Legion
           created_at: Time.now.utc
         )
       rescue StandardError => e
-        Legion::Logging.debug("Webhooks#dead_letter failed: #{e.message}") if defined?(Legion::Logging)
+        handle_exception(e, level: :debug, operation: 'webhooks.dead_letter',
+                            webhook_id: webhook_id, event_name: event_name, attempts: attempts)
         nil
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.8
+  version: 1.7.13
 platform: ruby
 authors:
 - Esity
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -225,42 +225,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.16
+        version: 1.3.22
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.16
+        version: 1.3.22
 - !ruby/object:Gem::Dependency
   name: legion-crypt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.17
+        version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.17
+        version: 1.5.1
 - !ruby/object:Gem::Dependency
   name: legion-data
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.7
+        version: 1.6.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.7
+        version: 1.6.19
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement
@@ -281,56 +281,56 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: legion-settings
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.19
+        version: 1.3.25
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.19
+        version: 1.3.25
 - !ruby/object:Gem::Dependency
   name: legion-transport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.4
+        version: 1.4.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.4
+        version: 1.4.14
 - !ruby/object:Gem::Dependency
   name: legion-apollo
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: legion-gaia
   requirement: !ruby/object:Gem::Requirement