lex-apollo 0.4.20 → 0.4.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f197e46e616eb71f939175480496d17775c67985bf70d631ac8d089724c7ac7d
-  data.tar.gz: c8f6ee951339eda218647c3bee95bfda3f32c6ee62a44abcaad8940b40214bd9
+  metadata.gz: 9a3e0ff5897e31c3f8e91f5b71eb96fd9ee90a15a041a5034ae936e2188806ae
+  data.tar.gz: c3aba4e4e156c940298dde9c54da46b77e87ffa05db60b7f4b3877307fa20c1c
 SHA512:
-  metadata.gz: 5b4822965e47e806bf21b1e07e3a675fff365bdea474514278ab61efc1be2e3fc557756f2ad8ab32e63b2d1eb24286dfe25c44ceacbba723bd877d1402d7a5ab
-  data.tar.gz: b67b970d6cf8734abd96c5de5e993e802ba924fd966307e60fd7911f7879559e3835d262ed653a269b740bbffd2574df9e156afe4e4c9dfd6a15b70afce6d658
+  metadata.gz: e8d3000ec6c34b23c5f49eea11b2a03d8ef117d395f9134782cf1c2fe91650b569b036571aaafd023d36d3fbd74725d492e44b98ed701348717b3221a7e45986
+  data.tar.gz: 811fd837e8370dde5d998daadad819f648da2f4b1aae3258c82573efb773a4901c6aff8b6cbcbe60eb9f964cee9146b81288d923429321cc7e70e046cd14371b

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.4.22] - 2026-04-28
+
+### Fixed
+- `/api/apollo/stats` now returns the health UI metrics Interlink expects: `recent_24h`, `avg_confidence`, and a synthesized `by_status["active"]` count for non-archived entries. This keeps the Knowledge Health cards populated instead of rendering missing values. Fixes #16.
+
+## [0.4.21] - 2026-04-27
+
+### Changed
+- `Apollo::Runners::Knowledge#handle_ingest` now emits warn-level logs on the three early-return failure paths (nil/blank content, nil content_type, apollo_data_not_available). Companion to PR #15: that PR added `handle_exception` to the rescue paths; this PR closes the silent-failure window for the early-return paths that fire BEFORE any rescue would. Tag values in the log line are sanitized via `gsub(/[\r\n]+/, ' ')` to prevent log-line injection from caller-controlled tags.
+
 ## [0.4.20] - 2026-04-25
 
 ### Fixed

data/lib/legion/extensions/apollo/api.rb

@@ -9,6 +9,37 @@ module Legion
       class Api < Sinatra::Base
         set :host_authorization, permitted: :any
 
+        class << self
+          def stats_payload(now: Time.now)
+            return { error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
+
+            entries = Legion::Data::Model::ApolloEntry
+            by_status = grouped_counts(entries, :status)
+            by_status['active'] = entries.exclude(status: 'archived').count
+
+            stats = {
+              total_entries:   entries.count,
+              recent_24h:      entries.where { created_at >= (now - 86_400) }.count,
+              avg_confidence:  average_confidence(entries),
+              by_status:       by_status,
+              by_content_type: grouped_counts(entries, :content_type)
+            }
+            stats[:total_relations] = Legion::Data::Model::ApolloRelation.count if defined?(Legion::Data::Model::ApolloRelation)
+            stats
+          end
+
+          private
+
+          def grouped_counts(entries, column)
+            entries.group_and_count(column).all.to_h { |row| [row[column].to_s, row[:count]] }
+          end
+
+          def average_confidence(entries)
+            avg = entries.avg(:confidence)
+            avg&.to_f&.round(3)
+          end
+        end
+
         before do
           content_type :json
         end
@@ -140,18 +171,7 @@ module Legion
 
         # Statistics
         get '/api/apollo/stats' do
-          stats = {}
-          if defined?(Legion::Data::Model::ApolloEntry)
-            stats[:total_entries] = Legion::Data::Model::ApolloEntry.count
-            stats[:by_status]     = Legion::Data::Model::ApolloEntry.group_and_count(:status).all
-                                                                    .to_h { |r| [r[:status], r[:count]] }
-            stats[:by_content_type] = Legion::Data::Model::ApolloEntry.group_and_count(:content_type).all
-                                                                      .to_h { |r| [r[:content_type], r[:count]] }
-            stats[:total_relations] = Legion::Data::Model::ApolloRelation.count if defined?(Legion::Data::Model::ApolloRelation)
-          else
-            stats[:error] = 'apollo_data_not_available'
-          end
-          stats.to_json
+          self.class.stats_payload.to_json
         end
       end
     end

data/lib/legion/extensions/apollo/runners/knowledge.rb

@@ -85,9 +85,8 @@ module Legion
 
             content = normalize_text_input(content)
             log.debug("Apollo Knowledge.handle_ingest content_length=#{content.length} content_type=#{content_type} tags=#{Array(tags).size} source_agent=#{source_agent} source_channel=#{source_channel || 'nil'}") # rubocop:disable Layout/LineLength
-            return { success: false, error: 'content is required' } if content.strip.empty?
-            return { success: false, error: 'content_type is required' } if content_type.nil?
-            return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
+            early_error = ingest_early_return_error(content: content, content_type: content_type, tags: tags)
+            return early_error if early_error
 
             hash = content_hash || (defined?(Helpers::Writeback) ? Helpers::Writeback.content_hash(content) : nil)
             existing = active_duplicate_for_hash(hash)
@@ -353,6 +352,27 @@ module Legion
 
           private
 
+          def ingest_early_return_error(content:, content_type:, tags:)
+            if content.strip.empty?
+              safe_tags = Array(tags).map(&:to_s).map { |t| t.gsub(/[\r\n]+/, ' ') }
+              log.warn('[apollo][handle_ingest] early-return: content is required ' \
+                       "content_type=#{content_type} tags=#{safe_tags.inspect}")
+              return { success: false, error: 'content is required' }
+            end
+
+            if content_type.nil?
+              log.warn('[apollo][handle_ingest] early-return: content_type is required ' \
+                       "content_length=#{content.to_s.length}")
+              return { success: false, error: 'content_type is required' }
+            end
+
+            return nil if defined?(Legion::Data::Model::ApolloEntry)
+
+            log.warn('[apollo][handle_ingest] early-return: apollo_data_not_available ' \
+                     "content_type=#{content_type}")
+            { success: false, error: 'apollo_data_not_available' }
+          end
+
           def normalize_content_type(raw)
             sym = raw.to_s.delete_prefix(':').gsub(%r{[/\s]}, '_').strip.downcase.to_sym
             sym = CONTENT_TYPE_ALIASES.fetch(sym, sym)

data/lib/legion/extensions/apollo/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.20'
+      VERSION = '0.4.22'
     end
   end
 end

data/spec/legion/extensions/apollo/api_spec.rb

@@ -25,4 +25,68 @@ RSpec.describe Legion::Extensions::Apollo::Api do
   it 'is defined as a Sinatra app' do
     expect(described_class.superclass).to eq(Sinatra::Base)
   end
+
+  describe '.stats_payload' do
+    let(:entry_model) { class_double('Legion::Data::Model::ApolloEntry') }
+    let(:relation_model) { class_double('Legion::Data::Model::ApolloRelation', count: 4) }
+    let(:status_counts) do
+      instance_double(
+        'StatusCounts',
+        all: [
+          { status: 'candidate', count: 2 },
+          { status: 'confirmed', count: 3 },
+          { status: 'archived', count: 1 }
+        ]
+      )
+    end
+    let(:content_type_counts) do
+      instance_double(
+        'ContentTypeCounts',
+        all: [
+          { content_type: 'document_chunk', count: 5 },
+          { content_type: 'observation', count: 1 }
+        ]
+      )
+    end
+    let(:active_entries) { instance_double('ActiveEntries', count: 5) }
+    let(:recent_entries) { instance_double('RecentEntries', count: 2) }
+
+    before do
+      stub_const('Legion::Data::Model::ApolloEntry', entry_model)
+      stub_const('Legion::Data::Model::ApolloRelation', relation_model)
+      allow(entry_model).to receive(:count).and_return(6)
+      allow(entry_model).to receive(:avg).with(:confidence).and_return(0.81234)
+      allow(entry_model).to receive(:exclude).with(status: 'archived').and_return(active_entries)
+      allow(entry_model).to receive(:where).and_return(recent_entries)
+      allow(entry_model).to receive(:group_and_count).with(:status).and_return(status_counts)
+      allow(entry_model).to receive(:group_and_count).with(:content_type).and_return(content_type_counts)
+    end
+
+    it 'returns the health UI metrics expected by Interlink' do
+      payload = described_class.stats_payload(now: Time.utc(2026, 4, 28, 12, 0, 0))
+
+      expect(payload).to include(
+        total_entries:   6,
+        recent_24h:      2,
+        avg_confidence:  0.812,
+        total_relations: 4
+      )
+      expect(payload[:by_status]).to include(
+        'candidate' => 2,
+        'confirmed' => 3,
+        'archived'  => 1,
+        'active'    => 5
+      )
+      expect(payload[:by_content_type]).to eq(
+        'document_chunk' => 5,
+        'observation'    => 1
+      )
+    end
+
+    it 'returns an apollo data error when the entry model is unavailable' do
+      hide_const('Legion::Data::Model::ApolloEntry')
+
+      expect(described_class.stats_payload).to eq(error: 'apollo_data_not_available')
+    end
+  end
 end

data/spec/legion/extensions/apollo/runners/knowledge_spec.rb

@@ -337,6 +337,36 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         )
       end
     end
+
+    context 'early-return warn logs' do
+      let(:logger) { instance_double('Logger', debug: nil, info: nil, warn: nil) }
+
+      before { allow(host).to receive(:log).and_return(logger) }
+
+      it 'emits a warn log when content is nil' do
+        host.handle_ingest(content: nil, content_type: 'fact')
+        expect(logger).to have_received(:warn).with(/early-return: content is required/)
+      end
+
+      it 'emits a warn log when content_type is nil' do
+        host.handle_ingest(content: 'something', content_type: nil)
+        expect(logger).to have_received(:warn).with(/early-return: content_type is required/)
+      end
+
+      it 'emits a warn log when apollo_data_not_available' do
+        hide_const('Legion::Data::Model::ApolloEntry') if defined?(Legion::Data::Model::ApolloEntry)
+        host.handle_ingest(content: 'something', content_type: 'fact')
+        expect(logger).to have_received(:warn).with(/early-return: apollo_data_not_available/)
+      end
+
+      it 'sanitizes newline-bearing tags in the warn log' do
+        host.handle_ingest(content: nil, content_type: 'fact', tags: ["evil\nFAKE LOG LINE", 'normal'])
+        expect(logger).to have_received(:warn) do |msg|
+          expect(msg).to include('evil FAKE LOG LINE')
+          expect(msg).not_to include("\n")
+        end
+      end
+    end
   end
 
   describe '#handle_query' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.20
+  version: 0.4.22
 platform: ruby
 authors:
 - Esity