pagerduty.rb

# frozen_string_literal: true

module CustomerScripts
  class accountIncidentImport
    extend Callable

    def call
      results = unprocessed_issues

      if results.empty?
        Rails.logger.info("No unprocessed issues found.")
      else
        Rails.logger.info("Processing #{results.size} unprocessed issues...")
        results.each do |issue|
          process_issue(issue)
        rescue StandardError => e
          Rails.logger.error("Failed to process issue #{issue[:reference_id]}: #{e.message}")
        end
        Rails.logger.info("Processed all issues.")
      end
    rescue StandardError => e
      Rails.logger.error("Error in accountIncidentImport: #{e.message}")
      Rails.logger.error(e.backtrace.join("\n"))
    end

    private

    def unprocessed_issues
      sql = <<~SQL
        WITH services as (
          SELECT#{" "}
            split_part(split_part(title, '[', 2), ']', 1) as service,
            COUNT(1) as count
          FROM pagerduty_incidents pi
          WHERE split_part(split_part(title, '[', 2), ']', 1) != ''
            AND split_part(split_part(title, '[', 2), ']', 1) NOT LIKE '%FIRING%'
          GROUP BY split_part(split_part(title, '[', 2), ']', 1)
          HAVING COUNT(1) > 12
        )
        SELECT#{" "}
          pi.incident_number AS reference_id,
          pi.created AS started_at,
          s.service AS services,
          pi.title AS name,
          pi.urgency AS priority,
          pi.source_url,
          pi.resolved AS resolved_at
        FROM services s
          INNER JOIN pagerduty_incidents pi ON split_part(split_part(pi.title, '[', 2), ']', 1) = s.service
          AND pi.resolved IS NOT NULL
          AND pi.incident_number::text NOT IN (
            SELECT source_id
            FROM incidents
          );
      SQL

      Rails.logger.debug("Executing SQL: #{sql}")
      ClientRecord.connection.execute(sql).map(&:symbolize_keys)
    end

    def process_issue(issue)
      services = parse_services(issue[:services])

      service_source_ids = services.map do |service_name|
        Rails.logger.info("Processing service: #{service_name}")

        identity = ServiceIdentity.find_or_create_by(
          name: service_name,
          source: "pagerduty",
          source_id: service_name,
        )

        Rails.logger.info("Found or created service identity: #{identity.inspect}")

        identity&.source_id
      end.compact

      sanitized_metadata = sanitize_metadata(issue[:metadata])
      processed_metadata = sanitized_metadata.present? ? process_metadata(sanitized_metadata) : []

      params = {
        source: "pagerduty",
        source_id: issue[:reference_id],
        name: issue[:name],
        source_url: issue[:source_url],
        started_at: issue[:started_at],
        resolved_at: issue[:resolved_at],
        priority: issue[:priority],
        service_source_ids: service_source_ids,
      }

      Rails.logger.info("Incident creation params: #{params}")

      Incident.transaction do
        incident = CreateIncident.call(params)

        if processed_metadata.any?
          row_created_at = row_updated_at = Time.current
          incident.metadata.upsert_all(
            processed_metadata.map { |item| item.merge(row_created_at: row_created_at, row_updated_at: row_updated_at) },
            unique_by: [:incident_id, :key],
          )
        end
      end

      Rails.logger.info("Incident created successfully for issue #{issue[:reference_id]}.")
    end

    def parse_services(services)
      services&.split(",")&.map(&:strip) || []
    end

    def sanitize_metadata(metadata)
      return {} if metadata.blank?

      JSON.parse(metadata).transform_keys do |key|
        key.to_s.strip.gsub(/\s+/, "_").gsub(/[^a-zA-Z0-9_-]/, "")
      end
    rescue JSON::ParserError => e
      Rails.logger.error("Failed to parse metadata JSON: #{e.message}")
      {}
    end

    def process_metadata(metadata)
      ProcessMetadata.call(metadata)
    rescue ProcessMetadata::TooDeep, ProcessMetadata::KeyFormatError, ProcessMetadata::UnableToProcess => e
      Rails.logger.warn("Failed to process metadata: #{e.message}")
      []
    end
  end
end