lex-llm-ledger 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b0e51e42bfec73669b2065b292a856ba029708010d10fc038d086a3442207e5
-  data.tar.gz: dbfbc4bf7b969362ff0363096fac13d33e8484080eddbccb09051fe3b794c0ff
+  metadata.gz: 9dc0c64e738b5fe99d37289f48ce3264b7991f7f521d570df80a63615d419972
+  data.tar.gz: a551479f32400fb90df6e0e6bc15423c627d783149f9a17f675421cf3d3f9243
 SHA512:
-  metadata.gz: 18e7a33c0c64c8cb6ebc6ef09c21b174ac2a73ef0643947029e2898ec59bf523e5e0d8c157672908755147b136c98b87117be1f7d1e701d6542862fd9b58e4b3
-  data.tar.gz: f9e869ab4703524b7b054d1c1a44c8ab4d2fd1b53a770aa48f471f69c70f124ad4e4b4a90ecd1ca5399e43817394cdbc05248b00108cdca4ee45b494b8c5d4c9
+  metadata.gz: 4cdf842b8a22047e92f2bd1adba9a953eefaf5bf86b255d54b6e8d22fc9f64545a45c03486348c9732539e34739e74fc43ce61c77d52772aeea93e640f0298ee
+  data.tar.gz: cd05c364405a72b9f1bfed2e539778fb301fa36f20e646f645755eb87e21a98261f5b9442a3c2b0938662a640f2708eb8886c0632dbe5118848e7616c48ad4c0

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.7.1] - 2026-06-11
+
+### Fixed
+- **IDENTITY-07**: `OfficialRouteAttemptWriter` called non-existent `CallerIdentity.resolve_principal_id` and `CallerIdentity.resolve_identity_id`. Delegated to `OfficialRecordWriter.caller_identity_refs` which already implements full identity resolution with header fallbacks and DB lookups.
+
 ## [0.7.0] - 2026-06-09
 
 ### Fixed

data/lib/legion/extensions/llm/ledger/runners/registry_availability.rb

@@ -3,6 +3,7 @@
 require_relative '../helpers/caller_identity'
 require_relative '../helpers/json'
 require_relative '../helpers/persistence_logging'
+require_relative '../writers/official_record_writer'
 
 module Legion
   module Extensions
@@ -66,6 +67,8 @@ module Legion
                 worker_id:               runtime[:worker_id] || runtime[:worker],
                 node_id:                 runtime[:node_id] || runtime[:host_id],
                 identity_canonical_name: extract_canonical_name(body, headers),
+                identity_principal_id:   extract_identity_principal_id(body, headers),
+                identity_id:             extract_identity_id(body, headers),
                 offering_json:           json_dump(offering),
                 runtime_json:            json_dump(runtime),
                 capacity_json:           json_dump(body[:capacity] || {}),
@@ -89,6 +92,44 @@ module Legion
               raw.to_s
             end
 
+            # Resolve identity_principal_id from AMQP headers or body.
+            # Uses OfficialRecordWriter.identity_tables_available? to check if FK resolution is possible.
+            def extract_identity_principal_id(body, headers)
+              raw = headers['x-legion-identity'] ||
+                    body.dig(:identity, :identity) ||
+                    body.dig(:identity, :canonical_name)
+              return nil unless raw && !raw.to_s.empty? # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              db = ::Legion::Data.connection
+              return nil unless Writers::OfficialRecordWriter.identity_tables_available?(db) # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              body_with_identity = body.merge(caller_identity: raw)
+              refs = Writers::OfficialRecordWriter.resolve_identity(db, body_with_identity)
+              refs[:principal_id]
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'write_registry_availability_record.identity_principal')
+              nil
+            end
+
+            # Resolve identity_id from AMQP headers or body.
+            # Uses OfficialRecordWriter.identity_tables_available? to check if FK resolution is possible.
+            def extract_identity_id(body, headers)
+              raw = headers['x-legion-identity'] ||
+                    body.dig(:identity, :identity) ||
+                    body.dig(:identity, :canonical_name)
+              return nil unless raw && !raw.to_s.empty? # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              db = ::Legion::Data.connection
+              return nil unless Writers::OfficialRecordWriter.identity_tables_available?(db) # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              body_with_identity = body.merge(caller_identity: raw)
+              refs = Writers::OfficialRecordWriter.resolve_identity(db, body_with_identity)
+              refs[:identity_id]
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'write_registry_availability_record.identity')
+              nil
+            end
+
             def lane_key(lane)
               if lane.is_a?(String)
                 lane

data/lib/legion/extensions/llm/ledger/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ledger
-        VERSION = '0.7.0'
+        VERSION = '0.7.1'
       end
     end
   end

data/lib/legion/extensions/llm/ledger/writers/official_record_writer.rb

@@ -6,6 +6,7 @@ require 'legion/logging'
 require 'legion/extensions/llm/responses/thinking_extractor'
 require_relative '../helpers/json'
 require_relative '../helpers/persistence_logging'
+require_relative 'official_route_attempt_writer'
 
 module Legion
   module Extensions
@@ -30,6 +31,7 @@ module Legion
                 response = find_or_create_response(db, request, response_message, body)
                 link_response_message!(db, response_message, response)
                 metric = find_or_create_metric(db, request, response, body)
+                OfficialRouteAttemptWriter.write_route_attempts(db, request, response, body)
                 result = { result: :ok, request_id: request[:id], response_id: response[:id], metric_id: metric[:id] }
               end
 
@@ -46,6 +48,7 @@ module Legion
                 request = find_or_create_request(db, conversation, nil, body)
                 response = find_or_create_response(db, request, nil, body)
                 metric = find_or_create_metric(db, request, response, body)
+                OfficialRouteAttemptWriter.write_route_attempts(db, request, response, body)
                 result = { result: :ok, request_id: request[:id], response_id: response[:id], metric_id: metric[:id] }
               end
 
@@ -149,7 +152,7 @@ module Legion
                                            budget_key:              billing(body)[:budget_id] || billing(body)[:budget_key],
                                            injected_tool_count:     Array(body.dig(:audit, :injected_tools) || body[:injected_tools]).size,
                                            context_tokens:          resolve_context_tokens(body),
-                                           request_content_hash:    compute_content_hash(body.dig(:request, :content) || body.dig(:audit, :request_content)),
+                                           request_content_hash:    resolve_request_content_hash(body),
                                            curation_strategy:       body[:curation_strategy] || body.dig(:audit, :curation_strategy),
                                            tool_policy:             body[:tool_policy] || body.dig(:audit, :tool_policy),
                                            requested_at:            recorded_at(body),
@@ -241,7 +244,7 @@ module Legion
                                            error_category:               body[:error_category] || body.dig(:error, :category),
                                            error_code:                   body[:error_code] || body.dig(:error, :code),
                                            error_message:                body[:error_message] || body.dig(:error, :message),
-                                           response_content_hash:        compute_content_hash(body[:response_content] || body.dig(:audit, :response_content)),
+                                           response_content_hash:        resolve_response_content_hash(body),
                                            route_attempts:               (body[:route_attempts] || body.dig(:audit, :route_attempts)).to_i,
                                            escalation_chain_ref:         body[:escalation_chain_ref],
                                            identity_principal_id:        caller_identity_refs(db, body)[:principal_id],
@@ -270,6 +273,7 @@ module Legion
               update_if_missing(updates, existing, :finish_reason, finish_reason(body))
               update_if_missing(updates, existing, :dispatch_path, body[:dispatch_path] || body[:tier])
               update_if_missing(updates, existing, :identity_canonical_name, identity_canonical_name(body))
+              update_if_missing(updates, existing, :response_content_hash, resolve_response_content_hash(body))
 
               vis = visible_response(body)
               if vis
@@ -387,6 +391,7 @@ module Legion
               update_if_missing(updates, existing, :runtime_caller_class, runtime_caller_class(body))
               update_if_missing(updates, existing, :runtime_caller_client, runtime_caller_client(body))
               update_if_missing(updates, existing, :identity_canonical_name, identity_canonical_name(body))
+              update_if_missing(updates, existing, :request_content_hash, resolve_request_content_hash(body))
 
               request_json = request_payload(body) ? json_dump(request_payload(body)) : nil
               if request_json
@@ -836,6 +841,22 @@ module Legion
               Digest::SHA256.hexdigest(json_dump(content))[0..31]
             end
 
+            # Prefer precomputed hash from emitter (A4: hash ships instead of raw content).
+            # Falls back to computing from raw content for backward compatibility.
+            def resolve_request_content_hash(body)
+              return body[:request_content_hash] if present?(body[:request_content_hash])
+
+              compute_content_hash(body.dig(:request, :content) || body.dig(:audit, :request_content))
+            end
+
+            # Prefer precomputed hash from emitter (A4: hash ships instead of raw content).
+            # Falls back to computing from raw content for backward compatibility.
+            def resolve_response_content_hash(body)
+              return body[:response_content_hash] if present?(body[:response_content_hash])
+
+              compute_content_hash(body[:response_content] || body.dig(:audit, :response_content))
+            end
+
             def resolve_context_tokens(body)
               raw = body[:tokens] || body[:audit] || body
               val = raw[:input_tokens] || raw[:input] || raw[:context_tokens] || raw[:prompt_tokens]

data/lib/legion/extensions/llm/ledger/writers/official_route_attempt_writer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'digest'
+require_relative '../helpers/json'
+require_relative '../helpers/persistence_logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Writers
+          module OfficialRouteAttemptWriter
+            extend Legion::Logging::Helper
+
+            module_function
+
+            # Persist route attempt details into llm_route_attempts table.
+            # Called from write_prompt/write_metering after the response row exists.
+            #
+            # Maps emitter keys to table columns:
+            #   provider        -> provider
+            #   instance        -> route_target
+            #   model           -> model_key
+            #   operation       -> operation
+            #   dispatch_path   -> dispatch_path
+            #   status          -> status
+            #   failure_reason  -> failure_reason
+            #   idempotency_key -> idempotency_key
+            def write_route_attempts(db, request, response, body)
+              attempts = Array(body[:route_attempt_details])
+              return if attempts.empty?
+
+              attempts.each_with_index do |attempt, idx|
+                next unless attempt.is_a?(Hash)
+
+                attempt_no = (attempt[:attempt_no] || (idx + 1)).to_i
+                uuid = stable_uuid("#{request[:uuid]}:attempt:#{attempt_no}")
+
+                existing = db[:llm_route_attempts].where(uuid: uuid).first
+                next if existing
+
+                begin
+                  Helpers::PersistenceLogging.insert_row(
+                    db,
+                    :llm_route_attempts,
+                    {
+                      uuid:                          uuid,
+                      message_inference_request_id:  request[:id],
+                      message_inference_response_id: response[:id],
+                      attempt_no:                    attempt_no,
+                      provider:                      attempt[:provider] || body[:provider],
+                      model_key:                     attempt[:model] || attempt[:model_key] || body[:model_id],
+                      tier:                          attempt[:tier] || body[:tier],
+                      route_target:                  attempt[:route_target] || attempt[:instance],
+                      status:                        (attempt[:status] || 'success').to_s,
+                      failure_reason:                attempt[:failure_reason],
+                      latency_ms:                    (attempt[:latency_ms] || 0).to_i,
+                      operation:                     attempt[:operation],
+                      dispatch_path:                 attempt[:dispatch_path],
+                      idempotency_key:               attempt[:idempotency_key],
+                      started_at:                    attempt[:started_at],
+                      ended_at:                      attempt[:ended_at],
+                      identity_principal_id:         resolve_identity_principal_id(db, body),
+                      identity_id:                   resolve_identity_id(db, body),
+                      identity_canonical_name:       identity_canonical_name(body),
+                      inserted_at:                   Time.now.utc
+                    },
+                    operation: 'official_route_attempt_writer.insert'
+                  )
+                rescue Sequel::UniqueConstraintViolation => e
+                  log.debug("[ledger] route_attempt collision resolved uuid=#{uuid} error=#{e.class}")
+                end
+              end
+            end
+
+            def resolve_identity_principal_id(db, body)
+              OfficialRecordWriter.caller_identity_refs(db, body)[:principal_id]
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'route_attempt_writer.identity_principal')
+              nil
+            end
+
+            def resolve_identity_id(db, body)
+              OfficialRecordWriter.caller_identity_refs(db, body)[:identity_id]
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'route_attempt_writer.identity')
+              nil
+            end
+
+            def identity_canonical_name(body)
+              raw = body.dig(:identity, :canonical_name) ||
+                    body.dig(:identity, :identity) ||
+                    body[:caller_identity]
+              return nil unless raw && !raw.to_s.empty?
+
+              raw.to_s
+            end
+
+            def stable_uuid(value)
+              raw = value.to_s
+              return raw if raw.length <= 36
+
+              hex = Digest::SHA256.hexdigest(raw)[0, 32]
+              "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ledger
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Esity
@@ -246,6 +246,7 @@ files:
 - lib/legion/extensions/llm/ledger/writers/official_metering_writer.rb
 - lib/legion/extensions/llm/ledger/writers/official_prompt_writer.rb
 - lib/legion/extensions/llm/ledger/writers/official_record_writer.rb
+- lib/legion/extensions/llm/ledger/writers/official_route_attempt_writer.rb
 - lib/lex-llm-ledger.rb
 homepage: https://github.com/LegionIO/lex-llm-ledger
 licenses: