igniter 0.5.0 → 0.5.1

data/packages/igniter-app/lib/igniter/app/credentials/trail.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Igniter
+  class App
+    module Credentials
+      class Trail
+        attr_reader :store
+
+        def initialize(store: nil, clock: -> { Time.now.utc.iso8601 })
+          @store = store
+          @clock = clock
+          @events = Array(store&.load_events).map { |event| normalize_loaded_event(event).freeze }
+        end
+
+        def record(event = nil, **attributes)
+          canonical_event =
+            if event
+              normalize_event(event)
+            else
+              build_event(attributes)
+            end
+
+          payload = canonical_event.to_h.merge(event_id: SecureRandom.uuid).freeze
+
+          @events << payload
+          store&.append(payload)
+          prune_retained_events!
+          payload
+        end
+
+        def events(limit: nil)
+          selected = limit ? @events.last(limit) : @events
+          selected.map(&:dup)
+        end
+
+        def latest_event
+          @events.last&.dup
+        end
+
+        def snapshot(limit: 10, filters: nil, order_by: nil, direction: :asc)
+          selected = apply_query(filters: filters, order_by: order_by, direction: direction)
+          limited = selected.first(limit)
+
+          {
+            query: {
+              filters: compact_filters(filters),
+              order_by: order_by&.to_sym,
+              direction: direction&.to_sym,
+              limit: limit
+            }.freeze,
+            total: selected.size,
+            latest_type: selected.last&.dig(:event),
+            latest_status: selected.last&.dig(:status),
+            latest_at: selected.last&.dig(:timestamp),
+            by_event: counts_for(:event, selected),
+            by_status: counts_for(:status, selected),
+            by_policy: counts_for(:policy_name, selected),
+            by_credential: counts_for(:credential_key, selected),
+            by_target_node: counts_for(:target_node, selected),
+            persistence: persistence_metadata,
+            events: limited.map(&:dup)
+          }
+        end
+
+        def lease_request_snapshot(limit: 10, filters: nil, order_by: nil, direction: :asc)
+          requests = apply_request_query(filters: filters, order_by: order_by, direction: direction)
+          limited = requests.first(limit)
+
+          {
+            query: {
+              filters: compact_filters(filters),
+              order_by: order_by&.to_sym,
+              direction: direction&.to_sym,
+              limit: limit
+            }.freeze,
+            total: requests.size,
+            latest_request_id: requests.last&.dig(:request_id),
+            latest_event: requests.last&.dig(:latest_event),
+            latest_status: requests.last&.dig(:status),
+            latest_at: requests.last&.dig(:latest_at),
+            by_event: counts_for(:latest_event, requests),
+            by_status: counts_for(:status, requests),
+            by_policy: counts_for(:policy_name, requests),
+            by_credential: counts_for(:credential_key, requests),
+            by_target_node: counts_for(:target_node, requests),
+            persistence: persistence_metadata,
+            requests: limited.map(&:dup)
+          }.freeze
+        end
+
+        def clear!
+          @events.clear
+          store&.clear!
+          self
+        end
+
+        private
+
+        def build_event(attributes)
+          Events::CredentialEvent.new(
+            timestamp: @clock.call,
+            **attributes
+          )
+        end
+
+        def normalize_event(value)
+          case value
+          when Events::CredentialEvent
+            value
+          when Hash
+            Events::CredentialEvent.from_h(value)
+          else
+            raise ArgumentError, "event must be a CredentialEvent or Hash"
+          end
+        end
+
+        def normalize_loaded_event(event)
+          canonical = normalize_event(event).to_h.each_with_object({}) do |(key, value), memo|
+            memo[key] = value
+          end
+          event_id = event[:event_id] || event["event_id"]
+          canonical[:event_id] = event_id if event_id
+          canonical
+        end
+
+        def counts_for(key, events)
+          Array(events).each_with_object(Hash.new(0)) do |event, memo|
+            value = event[key]
+            next if value.nil?
+
+            memo[value] += 1
+          end
+        end
+
+        def apply_query(filters:, order_by:, direction:)
+          filtered = apply_filters(@events, filters)
+          apply_order(filtered, order_by: order_by, direction: direction)
+        end
+
+        def apply_request_query(filters:, order_by:, direction:)
+          filtered = apply_filters(lease_request_records, filters)
+          apply_order(filtered, order_by: order_by, direction: direction)
+        end
+
+        def apply_filters(events, filters)
+          return Array(events) if filters.nil? || filters.empty?
+
+          filters.each_with_object(Array(events)) do |(key, value), memo|
+            next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+            allowed = Array(value)
+            memo.select! do |event|
+              event_value = event[key.to_sym]
+              allowed.include?(event_value)
+            end
+          end
+        end
+
+        def apply_order(events, order_by:, direction:)
+          return Array(events) if order_by.nil?
+
+          sorted = Array(events).sort_by do |event|
+            value = event[order_by.to_sym]
+            value.is_a?(Symbol) ? value.to_s : value.to_s
+          end
+          direction.to_sym == :desc ? sorted.reverse : sorted
+        end
+
+        def compact_filters(filters)
+          (filters || {}).each_with_object({}) do |(key, value), memo|
+            next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+            memo[key.to_sym] = Array(value)
+          end.freeze
+        end
+
+        def persistence_metadata
+          return { enabled: false } unless store
+
+          return store.persistence_metadata if store.respond_to?(:persistence_metadata)
+
+          {
+            enabled: true,
+            store_class: store.class.name,
+            path: store.respond_to?(:path) ? store.path : nil
+          }.compact
+        end
+
+        def prune_retained_events!
+          if store&.respond_to?(:prune_events)
+            @events = store.prune_events(@events).map(&:freeze)
+            return
+          end
+
+          limit = store&.respond_to?(:retained_limit) ? store.retained_limit : nil
+          return unless limit && limit.positive?
+          return if @events.size <= limit
+
+          @events.shift(@events.size - limit)
+        end
+
+        def lease_request_records
+          grouped = Hash.new { |hash, key| hash[key] = [] }
+
+          @events.each do |event|
+            next unless event[:event].to_s.start_with?("lease_")
+
+            grouped[request_id_for(event)] << event
+          end
+
+          grouped.each_value.map do |events|
+            build_request_record(events)
+          end
+        end
+
+        def build_request_record(events)
+          ordered_events = Array(events).sort_by { |event| event[:timestamp].to_s }
+          latest = ordered_events.last || {}
+          first = ordered_events.first || {}
+          metadata = latest.fetch(:metadata, {})
+
+          {
+            request_id: request_id_for(latest),
+            credential_key: latest[:credential_key],
+            policy_name: latest[:policy_name],
+            node: latest[:node] || first[:node],
+            target_node: latest[:target_node] || first[:target_node],
+            actor: latest[:actor],
+            origin: latest[:origin],
+            source: latest[:source],
+            reason: latest[:reason],
+            lease_id: latest[:lease_id],
+            requested_scope: metadata[:requested_scope],
+            credential_provider: metadata[:credential_provider],
+            latest_event: latest[:event],
+            status: latest[:status],
+            latest_at: latest[:timestamp],
+            requested_at: first[:timestamp],
+            events_count: ordered_events.size,
+            events: ordered_events.map(&:dup)
+          }.compact.freeze
+        end
+
+        def request_id_for(event)
+          metadata = event.fetch(:metadata, {})
+          metadata[:request_id] || event[:lease_id] || "#{event[:timestamp]}:#{event[:credential_key]}:#{event[:target_node]}"
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/credentials.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "igniter/core"
+
+require_relative "credentials/credential_policy"
+require_relative "credentials/credential"
+require_relative "credentials/config_loader"
+require_relative "credentials/lease_request"
+require_relative "credentials/policies"
+require_relative "credentials/events"
+require_relative "credentials/trail"
+require_relative "credentials/store"
+require_relative "credentials/stores/file_store"
+
+module Igniter
+  class App
+    module Credentials
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/dev_output_sync.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+$stdout.sync = true
+$stderr.sync = true

data/packages/igniter-app/lib/igniter/app/diagnostics/app_host_contributor.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Diagnostics
+      module AppHostContributor
+        class << self
+          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
+            app = report[:app]
+            return report unless app
+            return report unless app[:host] == :app
+
+            settings = Hash(app.dig(:host_settings, :app) || {})
+            report[:app_host] = {
+              adapter: :server,
+              host: settings[:host],
+              port: settings[:port],
+              log_format: settings[:log_format],
+              drain_timeout: settings[:drain_timeout],
+              routes: app[:routes],
+              hooks: app[:hooks],
+              metrics: app[:metrics],
+              store: app[:store]
+            }
+            report
+          end
+
+          def append_text(report:, lines:)
+            app_host = report[:app_host]
+            return unless app_host
+
+            lines << "App Host: #{summary(app_host)}"
+          end
+
+          def append_markdown_summary(report:, lines:)
+            app_host = report[:app_host]
+            return unless app_host
+
+            lines << "- App Host: #{summary(app_host)}"
+          end
+
+          def append_markdown_sections(report:, lines:)
+            app_host = report[:app_host]
+            return unless app_host
+
+            lines << ""
+            lines << "## App Host"
+            lines << "- Listener: host=`#{app_host[:host]}` port=`#{app_host[:port]}` log_format=`#{app_host[:log_format]}`"
+            lines << "- Runtime: drain_timeout=#{app_host[:drain_timeout]}, routes=#{app_host[:routes]}"
+            lines << "- Hooks: before=#{app_host.dig(:hooks, :before_request)}, after=#{app_host.dig(:hooks, :after_request)}, around=#{app_host.dig(:hooks, :around_request)}"
+            lines << "- Metrics: configured=#{app_host.dig(:metrics, :configured)}"
+            lines << "- Store: configured=#{app_host.dig(:store, :configured)}"
+          end
+
+          private
+
+          def summary(app_host)
+            [
+              "host=#{app_host[:host]}",
+              "port=#{app_host[:port]}",
+              "log_format=#{app_host[:log_format]}",
+              "routes=#{app_host[:routes]}",
+              "metrics=#{app_host.dig(:metrics, :configured)}",
+              "store=#{app_host.dig(:store, :configured)}"
+            ].join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/diagnostics/cluster_app_host_contributor.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Diagnostics
+      module ClusterAppHostContributor
+        class << self
+          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
+            app = report[:app]
+            return report unless app
+            return report unless app[:host] == :cluster_app
+
+            cluster_settings = Hash(app.dig(:host_settings, :cluster_app) || {})
+            server_settings = Hash(app.dig(:host_settings, :app) || {})
+
+            report[:cluster_app_host] = {
+              adapter: :cluster_app,
+              peer_name: cluster_settings[:peer_name],
+              local_capabilities: Array(cluster_settings[:local_capabilities]).map(&:to_sym).sort,
+              local_tags: Array(cluster_settings[:local_tags]).map(&:to_sym).sort,
+              local_metadata: Hash(cluster_settings[:local_metadata] || {}),
+              local_metadata_keys: Hash(cluster_settings[:local_metadata] || {}).keys.map(&:to_s).sort,
+              seeds: Array(cluster_settings[:seeds]),
+              seed_count: Array(cluster_settings[:seeds]).size,
+              static_peers: Array(cluster_settings[:peers]).map { |peer| serialize_peer(peer) },
+              static_peer_count: Array(cluster_settings[:peers]).size,
+              discovery_interval: cluster_settings[:discovery_interval],
+              auto_announce: cluster_settings[:auto_announce],
+              local_url: cluster_settings[:local_url],
+              gossip_fanout: cluster_settings[:gossip_fanout],
+              start_discovery: cluster_settings[:start_discovery],
+              server: {
+                host: server_settings[:host],
+                port: server_settings[:port],
+                log_format: server_settings[:log_format],
+                drain_timeout: server_settings[:drain_timeout]
+              }
+            }
+            report
+          end
+
+          def append_text(report:, lines:)
+            cluster_host = report[:cluster_app_host]
+            return unless cluster_host
+
+            lines << "Cluster Host: #{summary(cluster_host)}"
+          end
+
+          def append_markdown_summary(report:, lines:)
+            cluster_host = report[:cluster_app_host]
+            return unless cluster_host
+
+            lines << "- Cluster Host: #{summary(cluster_host)}"
+          end
+
+          def append_markdown_sections(report:, lines:)
+            cluster_host = report[:cluster_app_host]
+            return unless cluster_host
+
+            lines << ""
+            lines << "## Cluster App Host"
+            lines << "- Peer: name=`#{cluster_host[:peer_name] || "anonymous"}` local_url=`#{cluster_host[:local_url] || "n/a"}`"
+            lines << "- Capabilities: total=#{cluster_host[:local_capabilities].size}, names=#{cluster_host[:local_capabilities].join(", ")}"
+            lines << "- Tags: total=#{cluster_host[:local_tags].size}, names=#{cluster_host[:local_tags].join(", ")}"
+            lines << "- Mesh: seeds=#{cluster_host[:seed_count]}, static_peers=#{cluster_host[:static_peer_count]}, discovery_interval=#{cluster_host[:discovery_interval]}, auto_announce=#{cluster_host[:auto_announce]}, start_discovery=#{cluster_host[:start_discovery]}, gossip_fanout=#{cluster_host[:gossip_fanout]}"
+            lines << "- Server: host=`#{cluster_host.dig(:server, :host)}` port=`#{cluster_host.dig(:server, :port)}` log_format=`#{cluster_host.dig(:server, :log_format)}`"
+          end
+
+          private
+
+          def serialize_peer(peer)
+            normalized = Hash(peer || {})
+            {
+              name: normalized[:name],
+              url: normalized[:url],
+              capabilities: Array(normalized[:capabilities]).map(&:to_sym).sort,
+              tags: Array(normalized[:tags]).map(&:to_sym).sort,
+              metadata_keys: Hash(normalized[:metadata] || {}).keys.map(&:to_s).sort
+            }
+          end
+
+          def summary(cluster_host)
+            [
+              "peer=#{cluster_host[:peer_name] || "anonymous"}",
+              "capabilities=#{cluster_host[:local_capabilities].size}",
+              "tags=#{cluster_host[:local_tags].size}",
+              "seeds=#{cluster_host[:seed_count]}",
+              "static_peers=#{cluster_host[:static_peer_count]}",
+              "auto_announce=#{cluster_host[:auto_announce]}",
+              "start_discovery=#{cluster_host[:start_discovery]}"
+            ].join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/diagnostics/credential_contributor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Diagnostics
+      module CredentialContributor
+        class << self
+          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
+            context = Igniter::App::RuntimeContext.current
+            return report unless context
+
+            app_class = context.fetch(:app_class)
+            credential_audit = app_class.send(:credential_audit_overview, limit: 10)
+            return report unless credential_audit
+
+            report[:app_credentials] = credential_audit
+            report
+          end
+
+          def append_text(report:, lines:)
+            credentials = report[:app_credentials]
+            return unless credentials
+
+            lines << "App Credentials: #{summary(credentials)}"
+          end
+
+          def append_markdown_summary(report:, lines:)
+            credentials = report[:app_credentials]
+            return unless credentials
+
+            lines << "- App Credentials: #{summary(credentials)}"
+          end
+
+          def append_markdown_sections(report:, lines:)
+            credentials = report[:app_credentials]
+            return unless credentials
+
+            lines << ""
+            lines << "## App Credentials"
+            lines << "- Summary: #{summary(credentials)}"
+            Array(credentials[:events]).each do |event|
+              lines << "- `#{event[:event]}` credential=`#{event[:credential_key]}` policy=`#{event[:policy_name]}` status=`#{event[:status]}` target=`#{event[:target_node] || "none"}` reason=`#{event[:reason] || "none"}`"
+            end
+          end
+
+          private
+
+          def summary(credentials)
+            parts = []
+            parts << "events=#{credentials[:total]}"
+            parts << "latest=#{credentials[:latest_type]}" if credentials[:latest_type]
+            parts << "status=#{credentials[:latest_status]}" if credentials[:latest_status]
+            parts << "by_event=#{inline_counts(credentials[:by_event])}" unless credentials[:by_event].nil? || credentials[:by_event].empty?
+            parts << "by_policy=#{inline_counts(credentials[:by_policy])}" unless credentials[:by_policy].nil? || credentials[:by_policy].empty?
+            parts << "persisted=#{credentials.dig(:persistence, :enabled)}"
+            parts.join(", ")
+          end
+
+          def inline_counts(counts)
+            counts.sort_by { |key, _count| key.to_s }.map { |key, count| "#{key}=#{count}" }.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/packages/igniter-app/lib/igniter/app/diagnostics/evolution_contributor.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Igniter
+  class App
+    module Diagnostics
+      module EvolutionContributor
+        class << self
+          def augment(report:, execution:) # rubocop:disable Lint/UnusedMethodArgument
+            context = Igniter::App::RuntimeContext.current
+            return report unless context
+
+            report[:app_evolution] = context.fetch(:app_class).evolution_trail.snapshot(limit: 10)
+            report
+          end
+
+          def append_text(report:, lines:)
+            evolution = report[:app_evolution]
+            return unless evolution
+
+            lines << "App Evolution: #{summary(evolution)}"
+          end
+
+          def append_markdown_summary(report:, lines:)
+            evolution = report[:app_evolution]
+            return unless evolution
+
+            lines << "- App Evolution: #{summary(evolution)}"
+          end
+
+          def append_markdown_sections(report:, lines:)
+            evolution = report[:app_evolution]
+            return unless evolution
+
+            lines << ""
+            lines << "## App Evolution"
+            lines << "- Events: total=#{evolution[:total]}, latest=#{evolution[:latest_type] || "none"}"
+            lines << "- Persistence: enabled=#{evolution.dig(:persistence, :enabled)} store=#{evolution.dig(:persistence, :store_class) || "none"} path=#{evolution.dig(:persistence, :path) || "none"} retain=#{evolution.dig(:persistence, :max_events) || "all"} archived=#{evolution.dig(:persistence, :archived_events) || 0}"
+            unless evolution.dig(:persistence, :retention_policy).nil? || evolution.dig(:persistence, :retention_policy).empty?
+              lines << "- Retention Policy: #{inline_counts(evolution.dig(:persistence, :retention_policy))}"
+            end
+            unless evolution.dig(:persistence, :retained_by_class).nil? || evolution.dig(:persistence, :retained_by_class).empty?
+              lines << "- Live Crest: #{inline_counts(evolution.dig(:persistence, :retained_by_class))}"
+            end
+            evolution[:events].each do |event|
+              lines << "- `#{event[:type]}` source=`#{event[:source]}` at=`#{event[:timestamp]}` payload=#{event[:payload].inspect}"
+            end
+          end
+
+          private
+
+          def summary(evolution)
+            parts = []
+            parts << "total=#{evolution[:total]}"
+            parts << "latest=#{evolution[:latest_type] || "none"}"
+            if evolution[:persistence]
+              parts << "persisted=#{evolution.dig(:persistence, :enabled)}"
+              parts << "retain=#{evolution.dig(:persistence, :max_events) || "all"}"
+              parts << "archived=#{evolution.dig(:persistence, :archived_events) || 0}"
+              unless evolution.dig(:persistence, :retained_by_class).nil? || evolution.dig(:persistence, :retained_by_class).empty?
+                parts << "live=#{inline_counts(evolution.dig(:persistence, :retained_by_class))}"
+              end
+            end
+            parts << "types=#{inline_counts(evolution[:by_type])}" unless evolution[:by_type].empty?
+            parts.join(", ")
+          end
+
+          def inline_counts(counts)
+            counts.sort_by { |key, _count| key.to_s }.map { |key, count| "#{key}=#{count}" }.join(", ")
+          end
+        end
+      end
+    end
+  end
+end