Improve bugsnag notification in jobs

Author: dapi

app/jobs/application_job.rb

@@ -5,19 +5,105 @@ class ApplicationJob < ActiveJob::Base
   # Most jobs are safe to ignore if the underlying records are no longer available
   discard_on ActiveJob::DeserializationError
 
-  # Global error handling
+  # Handle record not found errors - log and notify but don't fail the job
+  rescue_from ActiveRecord::RecordNotFound do |exception|
+    handle_error(exception, action: 'record_not_found', severity: :warn, reraise: false)
+  end
+
+  # Handle record validation errors - log validation details
+  rescue_from ActiveRecord::RecordInvalid do |exception|
+    metadata = {
+      action: 'record_invalid',
+      record_errors: exception.record&.errors&.full_messages&.join(', ')
+    }
+    handle_error(exception, metadata: metadata, severity: :error, reraise: false)
+  end
+
+  # Handle all other standard errors
   rescue_from StandardError do |exception|
+    handle_error(exception, action: 'job_failed', severity: :error, reraise: true)
+  end
+
+  private
+
+  # Unified error handling with Bugsnag notification and logging
+  def handle_error(exception, metadata: {}, action: nil, severity: :error, reraise: true)
+    # Build metadata for Bugsnag and logging
+    error_metadata = build_error_metadata(metadata.merge(action: action))
+
+    # Send to Bugsnag
+    Bugsnag.notify(exception) do |b|
+      b.metadata = error_metadata
+      b.severity = severity
+    end
+
     # Log the error with context
-    Rails.logger.error(
-      "Job failed: #{self.class.name}",
+    log_error(exception, error_metadata, severity)
+
+    # Re-raise if requested to allow retry logic to work
+    raise exception if reraise
+  end
+
+  # Build base error metadata with job context
+  def build_error_metadata(additional_metadata = {})
+    base_metadata = {
+      job_class: self.class.name,
       job_id: job_id,
-      arguments: arguments,
-      error: exception.class.name,
-      message: exception.message,
-      backtrace: exception.backtrace.first(5)
-    )
-
-    # Re-raise to allow retry logic to work
-    raise exception
+      arguments: sanitized_arguments,
+      error_class: exception_class_name(additional_metadata[:exception])
+    }
+
+    base_metadata.merge(additional_metadata.compact)
+  end
+
+  # Sanitize arguments for logging (remove sensitive data)
+  def sanitized_arguments
+    return [] unless arguments.respond_to?(:map)
+
+    arguments.map do |arg|
+      case arg
+      when String
+        arg.length > 100 ? "#{arg[0..97]}..." : arg
+      when Hash
+        arg.slice(:id, :user_id, :channel_id, :post_id, :action)
+      else
+        arg.class.name
+      end
+    end
+  end
+
+  # Extract exception class name safely
+  def exception_class_name(exception)
+    exception&.class&.name || 'Unknown'
+  end
+
+  # Log error with appropriate level and context
+  def log_error(exception, metadata, severity)
+    log_message = "#{severity.to_s.capitalize} in #{metadata[:job_class]}: #{exception.message}"
+
+    case severity
+    when :debug
+      Rails.logger.debug(log_message, metadata)
+    when :info
+      Rails.logger.info(log_message, metadata)
+    when :warn
+      Rails.logger.warn(log_message, metadata)
+    else
+      Rails.logger.error(log_message, metadata)
+      Rails.logger.error(exception.backtrace&.first(10)&.join("\n"))
+    end
+  end
+
+  # Helper method to add context to error handling
+  def with_error_context(context)
+    @error_context = context
+    yield
+  ensure
+    @error_context = nil
+  end
+
+  # Get current error context if set
+  def current_error_context
+    @error_context || {}
   end
 end

app/jobs/channels/fetch_posts_job.rb

@@ -5,62 +5,71 @@ class Channels::FetchPostsJob < ApplicationJob
   retry_on StandardError, wait: 1.minute, attempts: 3
 
   def perform(channel_id)
-    channel = Channel.find(channel_id)
+    with_error_context(channel_id: channel_id, action: 'fetch_posts') do
+      channel = Channel.find(channel_id)
 
-    Rails.logger.info "Fetching posts for channel #{channel.username}"
+      Rails.logger.info "Fetching posts for channel #{channel.username}"
 
-    # Получаем Telegram ID канала
-    chat_id = channel.telegram_id.to_s
+      # Получаем Telegram ID канала
+      chat_id = channel.telegram_id.to_s
 
-    # Инициализируем клиент
-    bot = Telegram.bots[:default]
-    fetcher = TelegramClient::ChannelFetcher.new(bot)
+      # Инициализируем клиент
+      bot = Telegram.bots[:default]
+      fetcher = TelegramClient::ChannelFetcher.new(bot)
 
-    # Проверяем доступность канала
-    unless fetcher.channel_available?(channel.username)
-      Rails.logger.warn "Channel #{channel.username} is not available, deactivating"
-      channel.deactivate!
-      return
-    end
+      # Проверяем доступность канала
+      unless fetcher.channel_available?(channel.username)
+        Rails.logger.warn "Channel #{channel.username} is not available, deactivating"
+        channel.deactivate!
+        return
+      end
 
-    # Получаем последние посты
-    posts_data = fetcher.get_channel_posts(channel.username, limit: 20)
+      # Получаем последние посты
+      posts_data = fetcher.get_channel_posts(channel.username, limit: 20)
 
-    Rails.logger.info "Fetched #{posts_data.count} posts from channel #{channel.username}"
+      Rails.logger.info "Fetched #{posts_data.count} posts from channel #{channel.username}"
 
-    # Обновляем время последнего поста если есть посты
-    if posts_data.any?
-      channel.update_last_post!
-    end
+      # Обновляем время последнего поста если есть посты
+      if posts_data.any?
+        channel.update_last_post!
+      end
 
-    # Обрабатываем каждый пост
-    posts_data.each do |post_data|
-      begin
-        # Проверяем, нет ли уже такого поста в БД
-        existing_post = Post.find_by(
-          channel: channel,
-          telegram_message_id: post_data[:telegram_message_id]
-        )
-
-        if existing_post
-          Rails.logger.debug "Post #{post_data[:telegram_message_id]} already exists, skipping"
-          next
-        end
-
-        # Запускаем задачу для сохранения и обработки поста
-        Content::ProcessPostJob.perform_later(channel.id, post_data)
-
-        Rails.logger.debug "Scheduled processing for post #{post_data[:telegram_message_id]}"
-      rescue StandardError => e
-        Rails.logger.error "Error processing post #{post_data[:telegram_message_id]}: #{e.message}"
+      # Обрабатываем каждый пост
+      posts_data.each do |post_data|
+        process_single_post(channel, post_data)
       end
+
+      Rails.logger.info "Completed fetching posts for channel #{channel.username}"
     end
+  end
+
+  private
+
+  def process_single_post(channel, post_data)
+    # Проверяем, нет ли уже такого поста в БД
+    existing_post = Post.find_by(
+      channel: channel,
+      telegram_message_id: post_data[:telegram_message_id]
+    )
+
+    if existing_post
+      Rails.logger.debug "Post #{post_data[:telegram_message_id]} already exists, skipping"
+      return
+    end
+
+    # Запускаем задачу для сохранения и обработки поста
+    Content::ProcessPostJob.perform_later(channel.id, post_data)
 
-    Rails.logger.info "Completed fetching posts for channel #{channel.username}"
-  rescue ActiveRecord::RecordNotFound => e
-    Rails.logger.error "Channel #{channel_id} not found: #{e.message}"
+    Rails.logger.debug "Scheduled processing for post #{post_data[:telegram_message_id]}"
   rescue StandardError => e
-    Rails.logger.error "Error fetching posts for channel #{channel_id}: #{e.message}"
-    raise
+    # Handle individual post processing errors without failing the entire job
+    handle_error(e,
+                 metadata: {
+                   channel_id: channel.id,
+                   message_id: post_data[:telegram_message_id],
+                   action: 'process_single_post'
+                 },
+                 severity: :warn,
+                 reraise: false)
   end
 end

app/jobs/channels/monitor_job.rb

@@ -18,16 +18,14 @@ def perform(*args)
     Rails.logger.info "Found #{channels.count} channels to monitor"
 
     channels.each do |channel|
-      begin
+      with_error_context(channel_id: channel.id, channel_username: channel.username) do
         # Запускаем задачу для получения постов из канала
         Channels::FetchPostsJob.perform_later(channel.id)
 
         # Обновляем время последней проверки
         channel.mark_as_monitored!
 
         Rails.logger.debug "Scheduled fetch job for channel #{channel.username}"
-      rescue StandardError => e
-        Rails.logger.error "Error scheduling fetch for channel #{channel.username}: #{e.message}"
       end
     end
 

app/jobs/content/deliver_posts_job.rb

@@ -5,51 +5,69 @@ class Content::DeliverPostsJob < ApplicationJob
   retry_on StandardError, wait: 30.seconds, attempts: 3
 
   def perform(user_id, post_ids)
-    user = TelegramUser.find(user_id)
-    posts = Post.where(id: post_ids)
-
-    Rails.logger.info "Delivering #{posts.count} posts to user #{user.username}"
-
-    # Получаем инстанс бота
-    bot = Telegram.bots[:default]
-
-    posts.each do |post|
-      begin
-        # Форвардим сообщение пользователю
-        response = bot.api.forward_message(
-          chat_id: user.telegram_id, # chat_id пользователя
-          from_chat_id: post.channel.telegram_id, # ID канала
-          message_id: post.telegram_message_id # ID сообщения в канале
-        )
-
-        if response['ok']
-          Rails.logger.debug "Successfully forwarded post #{post.id} to user #{user.username}"
-        else
-          Rails.logger.error "Failed to forward post #{post.id} to user #{user.username}: #{response["description"]}"
-        end
-
-        # Небольшая задержка между сообщениями чтобы избежать rate limits
-        sleep(0.1)
-
-      rescue StandardError => e
-        Rails.logger.error "Error forwarding post #{post.id} to user #{user.username}: #{e.message}"
-
-        # Если ошибка связана с отсутствием прав или удаленным постом, логируем и продолжаем
-        if e.message.include?('Bad Request') || e.message.include?('not found')
-          Rails.logger.warn "Skipping post #{post.id} due to access restrictions or deletion"
-          next
-        else
-          # Для других ошибок пробуем еще раз (retry_on обработает)
-          raise
-        end
+    with_error_context(user_id: user_id, post_ids: post_ids, action: 'deliver_posts') do
+      user = TelegramUser.find(user_id)
+      posts = Post.where(id: post_ids)
+
+      Rails.logger.info "Delivering #{posts.count} posts to user #{user.username}"
+
+      # Получаем инстанс бота
+      bot = Telegram.bots[:default]
+
+      posts.each do |post|
+        deliver_single_post(user, post, bot)
       end
+
+      Rails.logger.info "Completed delivery to user #{user.username}"
     end
+  end
+
+  private
+
+  def deliver_single_post(user, post, bot)
+    # Форвардим сообщение пользователю
+    response = bot.api.forward_message(
+      chat_id: user.telegram_id, # chat_id пользователя
+      from_chat_id: post.channel.telegram_id, # ID канала
+      message_id: post.telegram_message_id # ID сообщения в канале
+    )
 
-    Rails.logger.info "Completed delivery to user #{user.username}"
-  rescue ActiveRecord::RecordNotFound => e
-    Rails.logger.error "User #{user_id} or posts not found: #{e.message}"
+    if response['ok']
+      Rails.logger.debug "Successfully forwarded post #{post.id} to user #{user.username}"
+    else
+      Rails.logger.error "Failed to forward post #{post.id} to user #{user.username}: #{response["description"]}"
+    end
+
+    # Небольшая задержка между сообщениями чтобы избежать rate limits
+    sleep(0.1)
   rescue StandardError => e
-    Rails.logger.error "Error delivering posts to user #{user_id}: #{e.message}"
-    raise
+    # Handle individual post delivery errors
+    handle_post_delivery_error(e, user, post)
+  end
+
+  def handle_post_delivery_error(error, user, post)
+    # Если ошибка связана с отсутствием прав или удаленным постом, логируем и продолжаем
+    if error.message.include?('Bad Request') || error.message.include?('not found')
+      Rails.logger.warn "Skipping post #{post.id} due to access restrictions or deletion"
+      handle_error(error,
+                   metadata: {
+                     user_id: user.id,
+                     post_id: post.id,
+                     action: 'skip_post_delivery'
+                   },
+                   severity: :warn,
+                   reraise: false)
+      return
+    end
+
+    # Для других ошибок пробуем еще раз (retry_on обработает)
+    handle_error(error,
+                 metadata: {
+                   user_id: user.id,
+                   post_id: post.id,
+                   action: 'forward_post'
+                 },
+                 severity: :error,
+                 reraise: true)
   end
 end