lex-microsoft_teams 0.6.45 → 0.6.47

data/lib/legion/extensions/microsoft_teams/absorbers/meeting.rb

@@ -11,6 +11,7 @@ module Legion
           description 'Absorbs Teams meeting transcripts, AI insights, and participants into Apollo'
 
           def absorb(url: nil, content: nil, metadata: {}, context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            log.debug("Meeting#absorb url=#{url.inspect}")
             report_progress(message: 'resolving meeting from link')
             meeting = resolve_meeting(url)
             return { success: false, error: 'could not resolve meeting' } unless meeting
@@ -26,9 +27,10 @@ module Legion
             ingest_participants(meeting, subject, results)
 
             report_progress(message: 'done', percent: 100)
+            log.info("Meeting#absorb complete meeting_id=#{meeting_id} subject=#{subject} chunks=#{results[:chunks]}")
             results.merge(success: true)
           rescue StandardError => e
-            log.error("Meeting absorber failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'Meeting#absorb', url: url)
             { success: false, error: e.message }
           end
 
@@ -47,17 +49,14 @@ module Legion
           end
 
           def graph_token
-            return @graph_token if defined?(@graph_token)
-
-            @graph_token = begin
-              Helpers::TokenCache.instance.cached_graph_token if defined?(Helpers::TokenCache)
-            rescue StandardError => e
-              log.warn("graph_token unavailable: #{e.message}")
-              nil
-            end
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
+          rescue StandardError => e
+            handle_exception(e, level: :debug, operation: 'Meeting#graph_token')
+            nil
           end
 
           def resolve_meeting(url)
+            log.debug("Meeting#resolve_meeting url=#{url.inspect}")
             thread_id = extract_meeting_thread_id(url)
             if thread_id
               report_progress(message: 'resolving meeting from chat thread', percent: 5)
@@ -67,7 +66,7 @@ module Legion
             report_progress(message: 'looking up meeting by join URL', percent: 5)
             resolve_meeting_by_join_url(url)
           rescue StandardError => e
-            log.warn("Could not resolve meeting: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'Meeting#resolve_meeting', url: url)
             nil
           end
 
@@ -76,11 +75,12 @@ module Legion
             match = uri.path.match(%r{/l/chat/(19:meeting_[^/]+)})
             match&.[](1)
           rescue URI::InvalidURIError => e
-            log.debug("extract_meeting_thread_id: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'Meeting#extract_meeting_thread_id', url: url)
             nil
           end
 
           def resolve_meeting_from_chat(thread_id)
+            log.debug("Meeting#resolve_meeting_from_chat thread_id=#{thread_id}")
             chats_runner = Object.new.extend(Runners::Chats)
             response = chats_runner.get_chat(chat_id: thread_id, token: graph_token)
             body = response.is_a?(Hash) ? response[:result] : nil
@@ -95,6 +95,7 @@ module Legion
           end
 
           def resolve_meeting_by_join_url(url)
+            log.debug("Meeting#resolve_meeting_by_join_url url=#{url.inspect}")
             response = meetings_runner.get_meeting_by_join_url(join_url: url, token: graph_token)
             return nil unless response.is_a?(Hash)
 
@@ -108,6 +109,7 @@ module Legion
           end
 
           def ingest_transcript(meeting_id, subject, results)
+            log.debug("Meeting#ingest_transcript meeting_id=#{meeting_id} subject=#{subject}")
             report_progress(message: 'fetching transcripts', percent: 20)
             transcripts_response = transcripts_runner.list_transcripts(meeting_id: meeting_id, token: graph_token)
             transcripts_body     = transcripts_response.is_a?(Hash) ? transcripts_response[:result] : nil
@@ -136,11 +138,13 @@ module Legion
               )
               results[:chunks] += 1
             end
+            log.info("Meeting#ingest_transcript stored #{results[:chunks]} transcript(s) for meeting_id=#{meeting_id}")
           rescue StandardError => e
-            log.warn("Transcript ingest failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'Meeting#ingest_transcript', meeting_id: meeting_id)
           end
 
           def ingest_ai_insights(meeting_id, subject, results)
+            log.debug("Meeting#ingest_ai_insights meeting_id=#{meeting_id}")
             report_progress(message: 'fetching AI insights', percent: 60)
             insights = ai_insights_runner.list_meeting_ai_insights(meeting_id: meeting_id, token: graph_token)
             return unless insights.is_a?(Hash)
@@ -150,8 +154,9 @@ module Legion
             return unless items.is_a?(Array) && items.any?
 
             items.each { |item| absorb_insight_item(item, meeting_id, subject, results) }
+            log.info("Meeting#ingest_ai_insights processed #{items.length} insight(s) for meeting_id=#{meeting_id}")
           rescue StandardError => e
-            log.warn("AI insights ingest failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'Meeting#ingest_ai_insights', meeting_id: meeting_id)
           end
 
           def absorb_insight_item(item, meeting_id, subject, results)
@@ -175,6 +180,7 @@ module Legion
           end
 
           def ingest_participants(meeting, subject, results)
+            log.debug("Meeting#ingest_participants subject=#{subject}")
             report_progress(message: 'recording participants', percent: 80)
             participants = meeting.dig('participants', 'attendees') || meeting.dig(:participants, :attendees)
             return unless participants.is_a?(Array) && participants.any?
@@ -192,8 +198,9 @@ module Legion
               metadata:     { meeting_id: meeting_id, participant_count: names.length }
             )
             results[:chunks] += 1
+            log.info("Meeting#ingest_participants stored #{names.length} participants for meeting_id=#{meeting_id}")
           rescue StandardError => e
-            log.warn("Participant ingest failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'Meeting#ingest_participants', subject: subject)
           end
         end
       end

data/lib/legion/extensions/microsoft_teams/actors/absorb_channel.rb

@@ -14,11 +14,12 @@ module Legion
             defined?(Legion::Extensions::Absorbers::Base) &&
               defined?(Legion::Extensions::MicrosoftTeams::Absorbers::Channel)
           rescue StandardError => e
-            log.debug("AbsorbChannel#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'AbsorbChannel#enabled?')
             false
           end
 
           def work(payload)
+            log.debug("AbsorbChannel#work payload=#{payload.inspect[0, 100]}")
             parsed   = parse_payload(payload)
             absorber = Absorbers::Channel.new
             result   = absorber.absorb(
@@ -30,7 +31,8 @@ module Legion
               if result[:success]
                 ack!
               else
-                log.error("AbsorbChannel actor absorb failed: #{result.inspect}")
+                handle_exception(RuntimeError.new(result.inspect), level:     :error,
+                                                                   operation: 'AbsorbChannel#work')
                 reject!(requeue: false)
               end
             else
@@ -38,19 +40,20 @@ module Legion
             end
             result
           rescue StandardError => e
-            log.error("AbsorbChannel actor error: #{e.message}")
+            handle_exception(e, level: :error, operation: 'AbsorbChannel#work')
             reject!(requeue: false)
           end
 
           private
 
           def parse_payload(payload)
+            log.debug('AbsorbChannel#parse_payload')
             data = payload.is_a?(String) ? json_load(payload) : payload
             return {} unless data.is_a?(Hash)
 
             data.transform_keys(&:to_sym)
           rescue StandardError => e
-            log.debug("AbsorbChannel#parse_payload: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'AbsorbChannel#parse_payload')
             {}
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/absorb_chat.rb

@@ -14,11 +14,12 @@ module Legion
             defined?(Legion::Extensions::Absorbers::Base) &&
               defined?(Legion::Extensions::MicrosoftTeams::Absorbers::Chat)
           rescue StandardError => e
-            log.debug("AbsorbChat#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'AbsorbChat#enabled?')
             false
           end
 
           def work(payload)
+            log.debug("AbsorbChat#work payload=#{payload.inspect[0, 100]}")
             parsed   = parse_payload(payload)
             absorber = Absorbers::Chat.new
             result   = absorber.absorb(
@@ -30,7 +31,8 @@ module Legion
               if result[:success]
                 ack!
               else
-                log.error("AbsorbChat actor absorb failed: #{result.inspect}")
+                handle_exception(RuntimeError.new(result.inspect), level:     :error,
+                                                                   operation: 'AbsorbChat#work')
                 reject!(requeue: false)
               end
             else
@@ -38,19 +40,20 @@ module Legion
             end
             result
           rescue StandardError => e
-            log.error("AbsorbChat actor error: #{e.message}")
+            handle_exception(e, level: :error, operation: 'AbsorbChat#work')
             reject!(requeue: false)
           end
 
           private
 
           def parse_payload(payload)
+            log.debug('AbsorbChat#parse_payload')
             data = payload.is_a?(String) ? json_load(payload) : payload
             return {} unless data.is_a?(Hash)
 
             data.transform_keys(&:to_sym)
           rescue StandardError => e
-            log.debug("AbsorbChat#parse_payload: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'AbsorbChat#parse_payload')
             {}
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/absorb_meeting.rb

@@ -14,11 +14,12 @@ module Legion
             defined?(Legion::Extensions::Absorbers::Base) &&
               defined?(Legion::Extensions::MicrosoftTeams::Absorbers::Meeting)
           rescue StandardError => e
-            log.debug("AbsorbMeeting#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'AbsorbMeeting#enabled?')
             false
           end
 
           def work(payload)
+            log.debug("AbsorbMeeting#work payload=#{payload.inspect[0, 100]}")
             parsed   = parse_payload(payload)
             absorber = Absorbers::Meeting.new
             result   = absorber.absorb(
@@ -30,7 +31,8 @@ module Legion
               if result[:success]
                 ack!
               else
-                log.error("AbsorbMeeting actor absorb failed: #{result.inspect}")
+                handle_exception(RuntimeError.new(result.inspect), level:     :error,
+                                                                   operation: 'AbsorbMeeting#work')
                 reject!(requeue: false)
               end
             else
@@ -38,19 +40,20 @@ module Legion
             end
             result
           rescue StandardError => e
-            log.error("AbsorbMeeting actor error: #{e.message}")
+            handle_exception(e, level: :error, operation: 'AbsorbMeeting#work')
             reject!(requeue: false)
           end
 
           private
 
           def parse_payload(payload)
+            log.debug('AbsorbMeeting#parse_payload')
             data = payload.is_a?(String) ? json_load(payload) : payload
             return {} unless data.is_a?(Hash)
 
             data.transform_keys(&:to_sym)
           rescue StandardError => e
-            log.debug("AbsorbMeeting#parse_payload: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'AbsorbMeeting#parse_payload')
             {}
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/api_ingest.rb

@@ -18,13 +18,12 @@ module Legion
           def run_now? = true
 
           def delay
-            if defined?(Legion::Extensions::MicrosoftTeams::Actor::AuthValidator)
-              auth_validator = Legion::Extensions::MicrosoftTeams::Actor::AuthValidator.allocate
-              base_delay = auth_validator.respond_to?(:delay) ? auth_validator.delay.to_f : 90.0
-              [base_delay + 5.0, 30].max
-            else
-              30
-            end
+            auth_validator = Legion::Extensions::Identity::Entra::Delegated::Actor::AuthValidator.allocate
+            base_delay = auth_validator.respond_to?(:delay) ? auth_validator.delay.to_f : 9.0
+            [base_delay + 5.0, 14].max
+          rescue StandardError => e
+            handle_exception(e, level: :debug, operation: 'ApiIngest#delay')
+            14
           end
 
           def time
@@ -35,11 +34,12 @@ module Legion
           def enabled?
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
           rescue StandardError => e
-            log.warn("ApiIngest#enabled?: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#enabled?')
             false
           end
 
           def manual
+            log.debug('ApiIngest#manual starting')
             token = resolve_token
             unless token
               log.warn('ApiIngest: no delegated token, skipping')
@@ -58,7 +58,7 @@ module Legion
             log.info("ApiIngest: #{result.inspect[0, 200]}")
             result
           rescue StandardError => e
-            log.error("ApiIngest: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ApiIngest#manual')
           end
 
           private
@@ -68,11 +68,9 @@ module Legion
           end
 
           def resolve_token
-            if defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-              Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance.cached_delegated_token
-            end
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
           rescue StandardError => e
-            log.warn("ApiIngest#resolve_token: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#resolve_token')
             nil
           end
 
@@ -81,7 +79,7 @@ module Legion
 
             Legion::Settings[:microsoft_teams] || {}
           rescue StandardError => e
-            log.warn("ApiIngest#teams_settings: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ApiIngest#teams_settings')
             {}
           end
 
@@ -90,7 +88,7 @@ module Legion
 
             Legion::Extensions::Coldstart::Helpers::Bootstrap.new.imprint_active?
           rescue StandardError => e
-            log.debug("ApiIngest#imprint_active?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ApiIngest#imprint_active?')
             false
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/cache_bulk_ingest.rb

@@ -24,10 +24,10 @@ module Legion
           def manual
             log.info('CacheBulkIngest firing')
             result = runner_class.ingest_cache(**args)
-            log.info("Complete: #{result.inspect[0, 200]}")
+            log.info("CacheBulkIngest complete: #{result.inspect[0, 200]}")
             result
           rescue StandardError => e
-            log.error("CacheBulkIngest error: #{e.message}")
+            handle_exception(e, level: :error, operation: 'CacheBulkIngest#manual')
           end
 
           def args
@@ -41,7 +41,7 @@ module Legion
 
             Legion::Extensions::Coldstart::Helpers::Bootstrap.new.imprint_active?
           rescue StandardError => e
-            log.debug("CacheBulkIngest#imprint_active?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'CacheBulkIngest#imprint_active?')
             false
           end
         end

data/lib/legion/extensions/microsoft_teams/actors/cache_sync.rb

@@ -33,6 +33,7 @@ module Legion
           end
 
           def manual
+            log.debug('CacheSync#manual starting')
             result = runner_class.send(runner_function, since: @last_sync_time, skip_bots: true)
             if result.is_a?(Hash) && result[:result]
               latest = result[:result][:latest_time]
@@ -41,7 +42,7 @@ module Legion
               log.info("CacheSync: ingested #{stored} new Teams messages") if stored.positive?
             end
           rescue StandardError => e
-            log.error("CacheSync: #{e.message}")
+            handle_exception(e, level: :error, operation: 'CacheSync#manual')
           end
         end
       end

data/lib/legion/extensions/microsoft_teams/actors/channel_poller.rb

@@ -36,52 +36,49 @@ module Legion
           end
 
           def enabled?
-            return false unless defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-
             channel_setting(:enabled, false) == true
           rescue StandardError => e
-            log.debug("ChannelPoller#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ChannelPoller#enabled?')
             false
           end
 
-          def token_cache
-            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
-          end
-
           def manual
             log.info('ChannelPoller polling team channels')
-            token = token_cache.cached_delegated_token
+            token = delegated_token
             unless token
               log.debug('No token available, skipping poll')
               return
             end
 
             teams = fetch_joined_teams(token: token)
-            log.debug("Found #{teams.length} joined team(s)")
+            log.debug("ChannelPoller#manual found #{teams.length} joined team(s)")
 
             teams.first(max_teams).each do |team|
               poll_team(team: team, token: token)
             rescue StandardError => e
-              log.error("Error polling team #{team['displayName']}: #{e.message}")
+              handle_exception(e, level: :error, operation: 'ChannelPoller#manual',
+                               team: team['displayName'])
             end
           rescue StandardError => e
-            log.error("ChannelPoller: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ChannelPoller#manual')
           end
 
           private
 
           def fetch_joined_teams(token:)
+            log.debug('ChannelPoller#fetch_joined_teams')
             conn = graph_connection(token: token)
             response = conn.get('me/joinedTeams')
             response.body&.dig('value') || []
           rescue StandardError => e
-            log.error("Failed to fetch joined teams: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ChannelPoller#fetch_joined_teams')
             []
           end
 
           def poll_team(team:, token:)
             team_id   = team['id']
             team_name = team['displayName'] || team_id
+            log.debug("ChannelPoller#poll_team team_id=#{team_id} team_name=#{team_name}")
 
             channels = fetch_channels(team_id: team_id, token: token)
             selected = select_channels(channels)
@@ -89,16 +86,18 @@ module Legion
             selected.first(max_channels_per_team).each do |channel|
               poll_channel(team_id: team_id, team_name: team_name, channel: channel, token: token)
             rescue StandardError => e
-              log.error("Error polling channel #{channel['displayName']} in #{team_name}: #{e.message}")
+              handle_exception(e, level: :error, operation: 'ChannelPoller#poll_team',
+                               channel: channel['displayName'], team: team_name)
             end
           end
 
           def fetch_channels(team_id:, token:)
+            log.debug("ChannelPoller#fetch_channels team_id=#{team_id}")
             conn = graph_connection(token: token)
             response = conn.get("teams/#{team_id}/channels")
             response.body&.dig('value') || []
           rescue StandardError => e
-            log.error("Failed to fetch channels for team #{team_id}: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ChannelPoller#fetch_channels', team_id: team_id)
             []
           end
 
@@ -112,6 +111,7 @@ module Legion
           def poll_channel(team_id:, team_name:, channel:, token:)
             channel_id   = channel['id']
             channel_name = channel['displayName'] || channel_id
+            log.debug("ChannelPoller#poll_channel team_id=#{team_id} channel_name=#{channel_name}")
 
             conn     = graph_connection(token: token)
             response = conn.get(
@@ -155,12 +155,19 @@ module Legion
             channel_setting(:max_channels_per_team, DEFAULT_MAX_CHANNELS)
           end
 
+          def delegated_token
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'ChannelPoller#delegated_token')
+            nil
+          end
+
           def channel_setting(key, default)
             return default unless defined?(Legion::Settings)
 
             Legion::Settings.dig(:microsoft_teams, :channels, key) || default
           rescue StandardError => e
-            log.debug("ChannelPoller#channel_setting(#{key}): #{e.message}")
+            handle_exception(e, level: :debug, operation: "ChannelPoller#channel_setting(#{key})")
             default
           end
 
@@ -169,6 +176,7 @@ module Legion
           end
 
           def store_channel_message_trace(team_name:, channel_name:, msg:)
+            log.debug("ChannelPoller#store_channel_message_trace team=#{team_name} channel=#{channel_name}")
             sender = msg.dig('from', 'user', 'displayName') || 'Unknown'
             content = (msg.dig('body', 'content') || '').gsub(/<[^>]+>/, '').strip
             memory_runner.store_trace(
@@ -179,7 +187,8 @@ module Legion
               confidence:      0.7
             )
           rescue StandardError => e
-            log.error("Failed to store channel message trace: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ChannelPoller#store_channel_message_trace',
+                             team: team_name, channel: channel_name)
           end
         end
       end

data/lib/legion/extensions/microsoft_teams/actors/direct_chat_poller.rb

@@ -30,16 +30,13 @@ module Legion
             defined?(Legion::Extensions::MicrosoftTeams::Runners::Bot) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.debug("DirectChatPoller#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'DirectChatPoller#enabled?')
             false
           end
 
-          def token_cache
-            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
-          end
-
           def manual
-            token = token_cache.cached_delegated_token
+            log.debug('DirectChatPoller#manual starting')
+            token = delegated_token
             unless token
               log.debug('No token available, skipping poll')
               return
@@ -47,21 +44,23 @@ module Legion
 
             log.info('Polling bot DM chats')
             chats = fetch_bot_chats(token: token)
-            log.info("Found #{chats.length} bot chats")
+            log.info("DirectChatPoller found #{chats.length} bot chats")
             chats.each { |chat| poll_chat(chat_id: chat[:id], token: token) }
           rescue StandardError => e
-            log.error("DirectChatPoller: #{e.message}")
+            handle_exception(e, level: :error, operation: 'DirectChatPoller#manual')
           end
 
           private
 
           def fetch_bot_chats(token:)
+            log.debug('DirectChatPoller#fetch_bot_chats')
             conn = graph_connection(token: token)
             response = conn.get('me/chats', { '$filter' => "chatType eq 'oneOnOne'", '$top' => 50 })
             response.body&.dig('value') || []
           end
 
           def poll_chat(chat_id:, token:)
+            log.debug("DirectChatPoller#poll_chat chat_id=#{chat_id}")
             conn = graph_connection(token: token)
             response = conn.get("chats/#{chat_id}/messages",
                                 { '$top' => 10, '$orderby' => 'createdDateTime desc' })
@@ -71,7 +70,7 @@ module Legion
             new_msgs.reject! { |m| m[:from_id] == @bot_id }
             return if new_msgs.empty?
 
-            log.info("Chat #{chat_id}: #{new_msgs.length} new message(s)")
+            log.info("DirectChatPoller chat #{chat_id}: #{new_msgs.length} new message(s)")
             new_msgs.each { |msg| publish_message(msg.merge(chat_id: chat_id, mode: :direct)) }
             update_hwm_from_messages(chat_id: chat_id, messages: new_msgs)
           end
@@ -79,7 +78,7 @@ module Legion
           def publish_message(payload)
             Legion::Extensions::MicrosoftTeams::Transport::Messages::TeamsMessage.new.publish(payload)
           rescue StandardError => e
-            log.error("DirectChatPoller publish failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'DirectChatPoller#publish_message')
           end
 
           def normalize_messages(messages)
@@ -101,6 +100,13 @@ module Legion
             Legion::Settings.dig(:microsoft_teams, :bot, :bot_id)
           end
 
+          def delegated_token
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'DirectChatPoller#delegated_token')
+            nil
+          end
+
           def settings_interval(key, default)
             return default unless defined?(Legion::Settings)
 

data/lib/legion/extensions/microsoft_teams/actors/incremental_sync.rb

@@ -17,7 +17,7 @@ module Legion
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
             rescue StandardError => e
-              log.debug("IncrementalSync#time: #{e.message}")
+              handle_exception(e, level: :debug, operation: 'IncrementalSync#time')
               {}
             end
             settings.dig(:ingest, :incremental_interval) || 120
@@ -27,17 +27,19 @@ module Legion
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces) &&
               token_available?
           rescue StandardError => e
-            log.debug("IncrementalSync#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'IncrementalSync#enabled?')
             false
           end
 
           def manual
+            log.debug('IncrementalSync#manual starting')
             token = resolve_token
             return unless token
 
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
-            rescue StandardError => _e
+            rescue StandardError => e
+              handle_exception(e, level: :debug, operation: 'IncrementalSync#manual settings')
               {}
             end
             ingest = settings[:ingest] || {}
@@ -47,7 +49,7 @@ module Legion
               message_depth: ingest.fetch(:message_depth, 50)
             )
           rescue StandardError => e
-            log.error("IncrementalSync: #{e.message}")
+            handle_exception(e, level: :error, operation: 'IncrementalSync#manual')
           end
 
           private
@@ -57,11 +59,9 @@ module Legion
           end
 
           def resolve_token
-            if defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-              Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance.cached_delegated_token
-            end
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
           rescue StandardError => e
-            log.warn("IncrementalSync#resolve_token: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'IncrementalSync#resolve_token')
             nil
           end
         end