lex-microsoft_teams 0.6.51 → 0.6.53

data/lib/legion/extensions/microsoft_teams/runners/profile_ingest.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'digest'
+require 'legion/extensions/microsoft_teams/errors'
 require 'legion/extensions/microsoft_teams/helpers/client'
 require 'legion/extensions/microsoft_teams/helpers/graph_cache'
 require 'legion/extensions/microsoft_teams/helpers/permission_guard'
@@ -36,37 +38,36 @@ module Legion
             teams_result = ingest_teams_and_meetings(token: token)
 
             { self: self_result, people: people_result, conversations: conv_result, teams: teams_result }
+          rescue Errors::Throttled => e
+            # Once Graph throttles us, the shared circuit is open and every
+            # remaining stage would just raise Throttled(attempts: 0)
+            # instantly — a burst of identical errors that ingests nothing.
+            # Stop the fan-out at the first throttled stage and report it.
+            log.warn('[microsoft_teams][profile_ingest] throttled mid-ingest; ' \
+                     'aborting remaining stages (retry_after=' \
+                     "#{e.retry_after_known? ? format('%.1f', e.retry_after) : 'unknown'} path=#{e.request})")
+            { throttled: true, retry_after: e.retry_after, request: e.request }
           end
 
           def ingest_self(token:, **)
             conn = graph_connection(token: token)
             profile = conn.get('me').body
 
-            memory_runner.store_trace(
-              type:            :identity,
-              content_payload: ::JSON.dump(profile),
-              domain_tags:     %w[teams self owner],
-              confidence:      1.0,
-              origin:          :direct_experience
-            )
-
             presence = begin
               conn.get('me/presence').body
             rescue StandardError => e
-              handle_exception(e, level: :debug, operation: 'ProfileIngest#ingest_self presence') if defined?(handle_exception)
+              handle_exception(e, level: :warn, operation: 'ProfileIngest#ingest_self presence') if defined?(handle_exception)
               {}
             end
-            unless presence.empty?
-              memory_runner.store_trace(
-                type:            :sensory,
-                content_payload: ::JSON.dump(presence),
-                domain_tags:     %w[teams presence self],
-                confidence:      0.8,
-                origin:          :direct_experience
-              )
-            end
 
             { profile: profile, presence: presence }
+          # rubocop:disable Legion/RescueLogging/NoCapture
+          # Re-raise unlogged: full_ingest logs the throttle once and aborts
+          # the fan-out. A throttle is a fleet signal, not a per-stage error;
+          # logging it here too would just duplicate the line per stage.
+          rescue Errors::Throttled
+            raise
+            # rubocop:enable Legion/RescueLogging/NoCapture
           rescue StandardError => e
             handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_self')
             { error: e.message }
@@ -86,19 +87,14 @@ module Legion
             people = (resp.body || {}).fetch('value', [])
             people.sort_by! { |p| -(p.dig('scoredEmailAddresses', 0, 'relevanceScore') || 0) }
 
-            people.each do |person|
-              name = person['displayName'] || 'Unknown'
-              memory_runner.store_trace(
-                type:            :semantic,
-                content_payload: ::JSON.dump(person.slice('displayName', 'jobTitle', 'department',
-                                                          'officeLocation', 'scoredEmailAddresses')),
-                domain_tags:     ['teams', 'peer', "peer:#{name}"],
-                confidence:      0.7,
-                origin:          :direct_experience
-              )
-            end
-
             { people: people, count: people.length }
+          # rubocop:disable Legion/RescueLogging/NoCapture
+          # Re-raise unlogged: full_ingest logs the throttle once and aborts
+          # the fan-out. A throttle is a fleet signal, not a per-stage error;
+          # logging it here too would just duplicate the line per stage.
+          rescue Errors::Throttled
+            raise
+            # rubocop:enable Legion/RescueLogging/NoCapture
           rescue StandardError => e
             handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_people')
             { error: e.message, skipped: false }
@@ -148,6 +144,13 @@ module Legion
             end
 
             { ingested: ingested }
+          # rubocop:disable Legion/RescueLogging/NoCapture
+          # Re-raise unlogged: full_ingest logs the throttle once and aborts
+          # the fan-out. A throttle is a fleet signal, not a per-stage error;
+          # logging it here too would just duplicate the line per stage.
+          rescue Errors::Throttled
+            raise
+            # rubocop:enable Legion/RescueLogging/NoCapture
           rescue StandardError => e
             handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_conversations')
             { error: e.message, ingested: ingested || 0 }
@@ -194,6 +197,13 @@ module Legion
             end
 
             { teams: teams_count, meetings: meetings_count }
+          # rubocop:disable Legion/RescueLogging/NoCapture
+          # Re-raise unlogged: full_ingest logs the throttle once and aborts
+          # the fan-out. A throttle is a fleet signal, not a per-stage error;
+          # logging it here too would just duplicate the line per stage.
+          rescue Errors::Throttled
+            raise
+            # rubocop:enable Legion/RescueLogging/NoCapture
           rescue StandardError => e
             handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_teams_and_meetings')
             { error: e.message }
@@ -210,13 +220,16 @@ module Legion
                                  top_people: top_people, message_depth: message_depth)
           end
 
+          CHAT_TYPE_PRIORITY = { 'oneOnOne' => 0, 'group' => 1, 'meeting' => 2 }.freeze
+
           private
 
           def build_chat_member_index(conn:, chats:)
             index = {}
-            chats.each do |chat|
+            sorted = chats.sort_by { |c| CHAT_TYPE_PRIORITY[c['chatType']] || 99 }
+            sorted.each do |chat|
               members = cached_graph_get(conn: conn, path: "chats/#{chat['id']}/members",
-                                         shared: true)
+                                         shared: true, ttl: members_cache_ttl)
                         .then { |body| (body || {}).fetch('value', []) }
               members.each do |m|
                 email = m['email']&.downcase
@@ -224,24 +237,65 @@ module Legion
               end
             end
             index
+          # rubocop:disable Legion/RescueLogging/NoCapture
+          # Re-raise unlogged: propagate to full_ingest so the per-chat
+          # fan-out stops on the first throttle; full_ingest logs it once.
+          rescue Errors::Throttled
+            raise
+            # rubocop:enable Legion/RescueLogging/NoCapture
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'ProfileIngest#build_chat_member_index')
             {}
           end
 
+          def members_cache_ttl
+            return @members_cache_ttl if defined?(@members_cache_ttl)
+
+            @members_cache_ttl = if respond_to?(:settings, true) && settings.respond_to?(:dig)
+                                   settings.dig(:cache, :members_ttl) || 86_400
+                                 else
+                                   86_400
+                                 end
+          end
+
           def fetch_new_messages(conn:, chat_id:, depth: 50)
             hwm = get_extended_hwm(chat_id: chat_id)
             params = { '$top' => depth, '$orderby' => 'createdDateTime desc' }
-            params['$filter'] = "createdDateTime gt #{hwm[:last_message_at]}" if hwm&.dig(:last_message_at)
 
             resp = conn.get("chats/#{chat_id}/messages", params)
-            (resp.body || {}).fetch('value', [])
+
+            unless (200..299).cover?(resp.status)
+              error_code = resp.body&.dig('error', 'code')
+              log.warn('[microsoft_teams][profile_ingest] fetch_new_messages non-2xx: ' \
+                       "chat_id=#{chat_id} status=#{resp.status} error_code=#{error_code}")
+              @fetch_failures = (@fetch_failures || 0) + 1
+              return []
+            end
+
+            messages = (resp.body || {}).fetch('value', [])
+            hwm_client_side_cut(messages: messages, hwm: hwm)
+          # rubocop:disable Legion/RescueLogging/NoCapture
+          # Re-raise unlogged: propagate to full_ingest so the per-chat
+          # fan-out stops on the first throttle; full_ingest logs it once.
+          rescue Errors::Throttled
+            raise
+            # rubocop:enable Legion/RescueLogging/NoCapture
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'ProfileIngest#fetch_new_messages',
                              chat_id: chat_id)
+            @fetch_failures = (@fetch_failures || 0) + 1
             []
           end
 
+          def hwm_client_side_cut(messages:, hwm:)
+            return messages unless hwm&.dig(:last_message_at)
+
+            cutoff = hwm[:last_message_at]
+            seen = Set.new
+            messages.take_while { |m| m['createdDateTime'] && m['createdDateTime'] > cutoff }
+                    .select { |m| seen.add?(m['id'] || Digest::SHA256.hexdigest(m.dig('body', 'content').to_s)[0, 16]) }
+          end
+
           def extract_conversation(messages:, peer_name:)
             return nil if messages.empty?
 
@@ -265,7 +319,7 @@ module Legion
               llm_ask(message: "#{definition[:prompt]}\n\nConversation with #{peer_name}:\n#{text}")
             end
           rescue StandardError => e
-            handle_exception(e, level: :debug, operation: 'ProfileIngest#extract_conversation')
+            handle_exception(e, level: :warn, operation: 'ProfileIngest#extract_conversation')
             nil
           end
 

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.51'
+      VERSION = '0.6.53'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -4,6 +4,7 @@ require 'legion/extensions/identity/entra/helpers/token_manager'
 require 'legion/extensions/microsoft_teams/version'
 require 'legion/extensions/microsoft_teams/errors'
 require 'legion/extensions/microsoft_teams/faraday/retry_after'
+require 'legion/extensions/microsoft_teams/helpers/throttle_aware'
 require 'legion/extensions/microsoft_teams/helpers/client'
 require 'legion/extensions/microsoft_teams/runners/auth'
 require 'legion/extensions/microsoft_teams/runners/teams'
@@ -106,7 +107,8 @@ module Legion
             interval: 60
           },
           cache:                {
-            graph_ttl: 300
+            graph_ttl:   300,
+            members_ttl: 86_400
           },
           client:               {
             throttle_circuit: {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.51
+  version: 0.6.53
 platform: ruby
 authors:
 - Esity
@@ -218,6 +218,7 @@ files:
 - lib/legion/extensions/microsoft_teams/helpers/prompt_resolver.rb
 - lib/legion/extensions/microsoft_teams/helpers/session_manager.rb
 - lib/legion/extensions/microsoft_teams/helpers/subscription_registry.rb
+- lib/legion/extensions/microsoft_teams/helpers/throttle_aware.rb
 - lib/legion/extensions/microsoft_teams/helpers/trace_retriever.rb
 - lib/legion/extensions/microsoft_teams/helpers/transform_definitions.rb
 - lib/legion/extensions/microsoft_teams/local_cache/extractor.rb