pager_tree-integrations 1.1.5 → 1.1.7

data/app/models/pager_tree/integrations/email/v3.rb

@@ -1,17 +1,37 @@
 module PagerTree::Integrations
   class Email::V3 < Integration
+    extend ::PagerTree::Integrations::Env
+
+    # the source log (if created) - Its what shows on the integration page (different from deferred request)
+    attribute :adapter_source_log
+
     OPTIONS = [
       {key: :allow_spam, type: :boolean, default: false},
-      {key: :dedup_threads, type: :boolean, default: true}
+      {key: :dedup_threads, type: :boolean, default: true},
+      {key: :sanitize_level, type: :string, default: "relaxed"},
+      {key: :custom_definition, type: :string, default: nil},
+      {key: :custom_definition_enabled, type: :boolean, default: false}
     ]
+
     store_accessor :options, *OPTIONS.map { |x| x[:key] }.map(&:to_s), prefix: "option"
 
+    SANITIZE_LEVELS = ["basic", "default", "relaxed", "relaxed_2", "restricted"]
+
     validates :option_allow_spam, inclusion: {in: [true, false]}
     validates :option_dedup_threads, inclusion: {in: [true, false]}
+    validates :option_sanitize_level, inclusion: {in: SANITIZE_LEVELS}
+    validates :option_custom_definition, presence: true, if: ->(record) { record.option_custom_definition_enabled == true }
+
+    def self.custom_webhook_v3_service_url
+      ::PagerTree::Integrations.integration_custom_webhook_v3_service_url.presence ||
+        find_value_by_name("integration_custom_webhook_v3", "service_url")
+    end
 
     after_initialize do
       self.option_allow_spam = false if option_allow_spam.nil?
       self.option_dedup_threads = true if option_dedup_threads.nil?
+      self.option_sanitize_level = "relaxed" if option_sanitize_level.nil?
+      self.option_custom_definition_enabled = false if option_custom_definition_enabled.nil?
     end
 
     # SPECIAL: override integration endpoint
@@ -23,7 +43,24 @@ module PagerTree::Integrations
       postfix = "_tst" if Rails.env.test?
       postfix = "_dev" if Rails.env.development?
 
-      "#{inbox}#{postfix}+#{id}@#{domain}"
+      if Rails.env.production?
+        if created_at&.after?(DateTime.parse("2023-09-01"))
+          # new emails
+          # int_abc123@domain.com
+          "#{(v == 3) ? prefix_id : id}@#{domain}"
+        else
+          # legacy emails
+          # a+int_abc123@domain.com
+          "#{inbox}#{postfix}+#{(v == 3) ? prefix_id : id}@#{domain}"
+        end
+      else
+        # staging, test, development
+        "#{inbox}#{postfix}+#{(v == 3) ? prefix_id : id}@#{domain}"
+      end
+    end
+
+    def custom_definition?
+      option_custom_definition_enabled && option_custom_definition.present?
     end
 
     def adapter_should_block?
@@ -47,23 +84,120 @@ module PagerTree::Integrations
     end
 
     def adapter_action
-      :create
+      if custom_definition?
+        case custom_response_result.dig("type")&.downcase
+        when "create"
+          :create
+        when "acknowledge"
+          :acknowledge
+        when "resolve"
+          :resolve
+        else
+          :other
+        end
+      else
+        :create
+      end
     end
 
     def adapter_process_create
-      Alert.new(
-        title: _title,
-        description: _description,
-        urgency: urgency,
-        thirdparty_id: _thirdparty_id,
-        dedup_keys: _dedup_keys,
-        additional_data: _additional_datums,
-        attachments: _attachments
-      )
+      if custom_definition?
+        Alert.new(
+          title: _title,
+          description: _description,
+          urgency: _urgency,
+          thirdparty_id: _thirdparty_id,
+          dedup_keys: _dedup_keys,
+          incident: _incident,
+          incident_severity: _incident_severity,
+          incident_message: _incident_message,
+          tags: _tags,
+          meta: _meta,
+          additional_data: _additional_datums,
+          attachments: _attachments
+        )
+      else
+        Alert.new(
+          title: _title,
+          description: _description,
+          urgency: urgency,
+          thirdparty_id: _thirdparty_id,
+          dedup_keys: _dedup_keys,
+          additional_data: _additional_datums,
+          attachments: _attachments
+        )
+      end
     end
 
     private
 
+    def _custom_response
+      return @_custom_response ||= {} unless custom_definition?
+
+      @_custom_response ||= begin
+        log_hash = {
+          subject: _mail.subject,
+          body: _body,
+          from: _mail.from,
+          to: _mail.to
+        }
+
+        body_hash = {
+          log: log_hash,
+          config: JSON.parse(PagerTree::Integrations::FormatConverters::YamlJsonConverter.convert_to_json(option_custom_definition))
+        }
+
+        response = HTTParty.post(
+          self.class.custom_webhook_v3_service_url,
+          body: body_hash.to_json,
+          headers: {"Content-Type" => "application/json"},
+          timeout: 2
+        )
+
+        unless response.success?
+          if response.parsed_response.dig("error").present?
+            adapter_source_log&.sublog({
+              message: "Custom Webhook Service Error:",
+              parsed_response: response.parsed_response
+            })
+            adapter_source_log&.save
+          end
+          raise "Custom Webhook Service HTTP error: #{response.code} - #{response.message} - #{response.body}"
+        end
+
+        adapter_source_log&.sublog({
+          message: "Custom Webhook Service Response:",
+          parsed_response: response.parsed_response
+        })
+        adapter_source_log&.save
+
+        response.parsed_response
+      rescue JSON::ParserError => e
+        Rails.logger.error("Custom Webhook YAML to JSON conversion error: #{e.message}")
+        adapter_source_log&.sublog("Custom Webhook YAML to JSON conversion error: #{e.message}")
+        adapter_source_log&.save
+        raise "Invalid YAML configuration: #{e.message}"
+      rescue HTTParty::Error, SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+        Rails.logger.error("Custom Webhook Service error: #{e.message}")
+        adapter_source_log&.sublog("Custom Webhook Service error: #{e.message}")
+        adapter_source_log&.save
+        raise "Custom Webhook Service error: #{e.message}"
+      rescue => e
+        Rails.logger.error("Unexpected error in Custom Webhook: #{e.message}")
+        adapter_source_log&.sublog("Unexpected error in Custom Webhook: #{e.message}")
+        adapter_source_log&.save
+        raise e
+      end
+    end
+
+    def _custom_response_status
+      @_custom_response_status ||= _custom_response.dig("status")
+    end
+
+    def custom_response_result
+      @_custom_response_result ||= _custom_response.dig("results")&.first || {}
+    end
+
     def _mail
       @_mail ||= adapter_incoming_request_params.dig("mail")
     end
@@ -73,28 +207,83 @@ module PagerTree::Integrations
     end
 
     def _thirdparty_id
-      _mail.message_id
+      if custom_definition?
+        @_thirdparty_id ||= custom_response_result.dig("thirdparty_id").to_s.presence
+      end
+
+      @_thirdparty_id ||= _mail.message_id || SecureRandom.uuid
     end
 
     def _dedup_keys
-      keys = [_thirdparty_id]
-      keys.concat(Array(_mail.references)) if option_dedup_threads
-      keys
+      return @_dedup_keys if @_dedup_keys
+
+      @_dedup_keys ||= []
+
+      if option_dedup_threads
+        @_dedup_keys.concat(Array(_thirdparty_id))
+        @_dedup_keys.concat(Array(_mail.references))
+      end
+
+      if custom_definition?
+        @_dedup_keys.concat(Array(custom_response_result.dig("dedup_keys")))
+      end
+
+      # only dedup the references per integration. Customer like sending one email to multiple integration inboxes
+      @_dedup_keys = @_dedup_keys.compact_blank.uniq.map { |x| "#{prefix_id}_#{x}" }
     end
 
     def _title
-      _mail.subject
+      if custom_definition?
+        @_title ||= custom_response_result.dig("title")&.to_s&.presence
+      end
+
+      @_title ||= _mail.subject.to_s.presence || "Incoming Email - Untitled Alert"
     end
 
     def _description
-      _body
+      if custom_definition?
+        @_description ||= custom_response_result.dig("description")&.to_s&.presence
+      end
+
+      @_description ||= _body.to_s
+    end
+
+    def _urgency
+      if custom_definition?
+        @_urgency ||= custom_response_result.dig("urgency")&.to_s&.presence
+      end
+
+      @_urgency ||= urgency
+    end
+
+    def _incident
+      @_incident ||= ActiveModel::Type::Boolean.new.cast(custom_response_result.dig("incident"))
+    end
+
+    def _incident_severity
+      custom_response_result.dig("incident_severity")&.to_s&.presence
+    end
+
+    def _incident_message
+      custom_response_result.dig("incident_message")&.to_s&.presence
+    end
+
+    def _tags
+      tags = custom_response_result.dig("tags")
+      tags = tags.split(",") if tags.is_a?(String)
+      Array(tags).compact_blank.map(&:to_s).uniq
+    end
+
+    def _meta
+      meta = custom_response_result.dig("meta")
+      meta.is_a?(Hash) ? meta : {}
     end
 
     def _body
       return @_body if @_body
 
       if _mail.multipart? && _mail.html_part
-        document = Nokogiri::HTML(_mail.html_part.body.decoded)
+        document = Nokogiri::HTML(_mail_body_part_to_utf8(_mail.html_part))
 
         _attachments_hash.map do |attachment_hash|
           attachment = attachment_hash[:original]
@@ -109,9 +298,11 @@ module PagerTree::Integrations
           end
         end
 
-        @_body = ::Sanitize.document(document, Sanitize::Config::RELAXED)
+        @_body = custom_definition? ?
+          (document.at_css("body")&.inner_html || document.to_html) :
+          ::Sanitize.fragment(document, _sanitize_config)
       elsif _mail.multipart? && _mail.text_part
-        @_body = _mail.text_part.body.decoded
+        @_body = _mail_body_part_to_utf8(_mail.text_part)
       else
         @_body = _mail.decoded
       end
@@ -119,6 +310,43 @@ module PagerTree::Integrations
       @_body
     end
 
+    def _sanitize_config
+      case option_sanitize_level
+      when "basic" then Sanitize::Config::BASIC
+      when "default" then Sanitize::Config::DEFAULT
+      when "relaxed" then Sanitize::Config::RELAXED
+      when "restricted" then Sanitize::Config::RESTRICTED
+      when "relaxed_2"
+        Sanitize::Config.merge(Sanitize::Config::RELAXED, elements: Sanitize::Config::RELAXED[:elements].excluding("style"))
+      end
+    end
+
+    # Encodings can cause lots of issues, so we try to convert to UTF-8
+    # https://github.com/mikel/mail#encodings
+    # https://stackoverflow.com/a/15818886/2903189
+    def _mail_body_part_to_utf8(part_to_use)
+      # get the message body without the header information
+      body = part_to_use.body.decoded
+
+      if body.encoding.name != "UTF-8"
+        # readout the encoding (charset) of the part
+        encoding = part_to_use.content_type_parameters["charset"] if part_to_use.content_type_parameters
+
+        # and convert it to UTF-8
+        if encoding
+          body = body.force_encoding(encoding).encode("UTF-8")
+        else
+          raise StandardError.new "Unknown encoding for mail body part"
+        end
+      end
+
+      # return the body
+      body
+    rescue
+      # if something goes wrong, just return the original body with characters replaced
+      body.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "?")
+    end
+
     def _attachments_hash
       @_attachments_hash ||= _mail.attachments.map do |attachment|
         blob = ActiveStorage::Blob.create_and_upload!(
@@ -136,7 +364,29 @@ module PagerTree::Integrations
 
     # TODO: Implement any additional data that should be shown in the alert with high priority (be picky as to 'very important' information)
     def _additional_datums
-      [
+      return @_additional_datums if @_additional_datums
+
+      if custom_definition?
+        @_additional_datums ||= begin
+          items = custom_response_result.dig("additional_data") || []
+          items = [items] unless items.is_a?(Array)
+
+          items.each_with_object([]) do |ad, result|
+            next unless ad.is_a?(Hash)
+
+            format = ad["format"].to_s
+            next unless PagerTree::Integrations::AdditionalDatum::FORMATS.include?(format)
+
+            result << AdditionalDatum.new(
+              format: format,
+              label: ad["label"].to_s.presence || "Untitled",
+              value: ad["value"]
+            )
+          end
+        end
+      end
+
+      @_additional_datums ||= [
         AdditionalDatum.new(format: "email", label: "From", value: _mail.from),
         AdditionalDatum.new(format: "email", label: "To", value: _mail.to),
         AdditionalDatum.new(format: "email", label: "CCs", value: _mail.cc)

data/app/models/pager_tree/integrations/email/v3_examples/example.yml

@@ -0,0 +1,24 @@
+---
+rules:
+- match:
+    log.body:
+      "$regex": "event_type=Automatic"
+      "$options": "i"
+  actions:
+  - type: "create"
+    title: "{{log.subject}}"
+    description: "{{{log.body}}}"
+    # Works for:
+    # event_url=https://...
+    # event_url=<a href="https://...">
+    thirdparty_id: >-
+      {{{itemAt (regexMatch log.body 'event_url=(?:<a\s+href=")?(https?://[^"\r\n>]+)') 1}}}
+
+- match:
+    log.body:
+      "$regex": "event_type=Manual"
+      "$options": "i"
+  actions:
+  - type: "resolve"
+    thirdparty_id: >-
+      {{{itemAt (regexMatch log.body 'event_url=(?:<a\s+href=")?(https?://[^"\r\n>]+)') 1}}}

data/app/models/pager_tree/integrations/form/v3.rb

@@ -50,15 +50,27 @@ module PagerTree::Integrations
     end
 
     def adapter_response_inactive_subscription
-      adapter_controller&.render(status: :payment_required, json: {code: Rack::Utils.status_code(:payment_required), errors: ["Customer must subscribe service plan to use this integration"]})
+      adapter_controller&.render(status: adapter_response_inactive_subscription_code, json: {code: Rack::Utils.status_code(adapter_response_inactive_subscription_code), errors: ["Customer must subscribe service plan to use this integration"]})
+    end
+
+    def adapter_response_inactive_subscription_code
+      :payment_required
     end
 
     def adapter_response_upgrade
-      adapter_controller&.render(status: :payment_required, json: {code: Rack::Utils.status_code(:payment_required), errors: ["Customer must upgrade service plan to use this integration"]})
+      adapter_controller&.render(status: adapter_response_upgrade_code, json: {code: Rack::Utils.status_code(adapter_response_upgrade_code), errors: ["Customer must upgrade service plan to use this integration"]})
+    end
+
+    def adapter_response_upgrade_code
+      :payment_required
     end
 
     def adapter_response_maintenance_mode
-      adapter_controller&.render(status: :service_unavailable, json: {code: Rack::Utils.status_code(:service_unavailable), errors: ["Integration currently in maintenance mode"]})
+      adapter_controller&.render(status: adapter_response_maintenance_mode_code, json: {code: Rack::Utils.status_code(adapter_response_maintenance_mode_code), errors: ["Integration currently in maintenance mode"]})
+    end
+
+    def adapter_response_maintenance_mode_code
+      :service_unavailable
     end
 
     def adapter_thirdparty_id

data/app/models/pager_tree/integrations/freshdesk/v3.rb

@@ -39,8 +39,10 @@ module PagerTree::Integrations
     def adapter_action
       status = _freshdesk_webhook.dig("ticket_status")
       status_i = status&.to_i
-      if status_i == FD_TICKET_STATUS[:open] || status == "Open" || status_i == FD_TICKET_STATUS[:pending] || status == "Pending"
+      if !adapter_alert.present? || status_i == FD_TICKET_STATUS[:open] || status == "Open"
         :create
+      elsif status_i == FD_TICKET_STATUS[:pending] || status == "Pending"
+        :acknowledge
       elsif status_i == FD_TICKET_STATUS[:resolved] || status == "Resolved" || status_i == FD_TICKET_STATUS[:closed] || status == "Closed"
         :resolve
       else
@@ -78,13 +80,13 @@ module PagerTree::Integrations
       priority_i = priority&.to_i
 
       if priority_i == FD_TICKET_PRIORITY[:low] || priority == "Low"
-        :low
+        "low"
       elsif priority_i == FD_TICKET_PRIORITY[:medium] || priority == "Normal"
-        :medium
+        "medium"
       elsif priority_i == FD_TICKET_PRIORITY[:high] || priority == "High"
-        :high
+        "high"
       elsif priority_i == FD_TICKET_PRIORITY[:urgent] || priority == "Urgent"
-        :critical
+        "critical"
       end
     end
 

data/app/models/pager_tree/integrations/freshservice/v3.rb

@@ -40,8 +40,10 @@ module PagerTree::Integrations
       status = _freshservice_webhook.dig("ticket_status")
       status_i = status&.to_i
 
-      if status_i == FS_TICKET_STATUS[:open] || status == "Open" || status_i == FS_TICKET_STATUS[:pending] || status == "Pending"
+      if status_i == FS_TICKET_STATUS[:open] || status == "Open" || status_i == FS_TICKET_STATUS[:pending]
         :create
+      elsif status_i == FS_TICKET_STATUS[:pending] || status == "Pending"
+        :acknowledge
       elsif status_i == FS_TICKET_STATUS[:resolved] || status == "Resolved" || status_i == FS_TICKET_STATUS[:closed] || status == "Closed"
         :resolve
       else
@@ -80,13 +82,13 @@ module PagerTree::Integrations
       priority_i = priority&.to_i
 
       if priority_i == FS_TICKET_PRIORITY[:low] || priority == "Low"
-        :low
+        "low"
       elsif priority_i == FS_TICKET_PRIORITY[:medium] || priority == "Normal" || priority == "Medium"
-        :medium
+        "medium"
       elsif priority_i == FS_TICKET_PRIORITY[:high] || priority == "High"
-        :high
+        "high"
       elsif priority_i == FS_TICKET_PRIORITY[:urgent] || priority == "Urgent"
-        :critical
+        "critical"
       end
     end
 

data/app/models/pager_tree/integrations/grafana/v3.rb

@@ -19,7 +19,7 @@ module PagerTree::Integrations
     end
 
     def adapter_thirdparty_id
-      adapter_incoming_request_params.dig("ruleId")
+      adapter_incoming_request_params.dig("ruleId") || adapter_incoming_request_params.dig("groupKey") || SecureRandom.uuid
     end
 
     def adapter_action
@@ -46,7 +46,7 @@ module PagerTree::Integrations
     private
 
     def _title
-      adapter_incoming_request_params.dig("ruleName")
+      adapter_incoming_request_params.dig("ruleName") || adapter_incoming_request_params.dig("title")
     end
 
     def _description

data/app/models/pager_tree/integrations/hetrix_tools/v3.rb

@@ -0,0 +1,160 @@
+module PagerTree::Integrations
+  class HetrixTools::V3 < Integration
+    OPTIONS = [
+      {key: :authentication_token, type: :string, default: nil}
+    ]
+    store_accessor :options, *OPTIONS.map { |x| x[:key] }.map(&:to_s), prefix: "option"
+
+    after_initialize do
+      self.option_authentication_token ||= nil
+    end
+
+    def adapter_should_block_incoming?(request)
+      option_authentication_token.present? && (request.headers["Authorization"] != "Bearer #{option_authentication_token}")
+    end
+
+    def adapter_supports_incoming?
+      true
+    end
+
+    def adapter_supports_outgoing?
+      false
+    end
+
+    def adapter_incoming_can_defer?
+      true
+    end
+
+    def adapter_thirdparty_id
+      try("_adapter_thirdparty_id_#{_webhook_type}") || SecureRandom.hex(16)
+    end
+
+    def adapter_action
+      try("_adapter_action_#{_webhook_type}") || :other
+    end
+
+    def _adapter_action_uptime
+      case adapter_incoming_request_params.dig("monitor_status")
+      when "online" then :resolve
+      when "offline" then :create
+      else
+        :other
+      end
+    end
+
+    def _adapter_action_blacklist
+      :create
+    end
+
+    def _adapter_action_resource_usage
+      :create
+    end
+
+    def adapter_process_create
+      Alert.new(
+        title: _title,
+        description: _description,
+        thirdparty_id: adapter_thirdparty_id,
+        dedup_keys: [],
+        additional_data: _additional_datums
+      )
+    end
+
+    def _adapter_thirdparty_id_uptime
+      adapter_incoming_request_params.dig("monitor_id")
+    end
+
+    def _adapter_thirdparty_id_blacklist
+      SecureRandom.hex(16)
+    end
+
+    def _adapter_thirdparty_id_resource_usage
+      adapter_incoming_request_params.dig("monitor_id")
+    end
+
+    def _webhook_type
+      @_webhook_type ||= if _webhook_type_uptime?
+        :uptime
+      elsif _webhook_type_resource_usage?
+        :resource_usage
+      elsif _webhook_type_blacklist?
+        :blacklist
+      else
+        :unknown
+      end
+    end
+
+    def _webhook_type_uptime?
+      adapter_incoming_request_params.dig("monitor_errors").present?
+    end
+
+    def _webhook_type_blacklist?
+      json = adapter_incoming_request_params.dig("_json")
+      json.present? && json.is_a?(Array)
+    end
+
+    def _webhook_type_resource_usage?
+      adapter_incoming_request_params.dig("resource_usage").present?
+    end
+
+    def _title
+      try("_title_#{_webhook_type}") || "HetrixTools Alert"
+    end
+
+    def _title_uptime
+      "#{adapter_incoming_request_params.dig("monitor_name")} is #{adapter_incoming_request_params.dig("monitor_status")}"
+    end
+
+    def _title_blacklist
+      "Blacklist Alert"
+    end
+
+    def _title_resource_usage
+      "#{adapter_incoming_request_params.dig("monitor_name")} usage alert"
+    end
+
+    def _description
+      try("_description_#{_webhook_type}") || "No description provided"
+    end
+
+    def _description_uptime
+      "<p>#{adapter_incoming_request_params.dig("monitor_target")} is #{adapter_incoming_request_params.dig("monitor_status")}</p>" +
+        adapter_incoming_request_params.dig("monitor_errors").map { |k, v| "<p>#{k}: #{v}</p>" }.join("")
+    end
+
+    def _description_blacklist
+      adapter_incoming_request_params.dig("_json").map { |x| "#{x["monitor"]} (#{x["blacklisted_now"]})" }.join("<br/>")
+    end
+
+    def _description_resource_usage
+      [
+        "<p>Resource Type: #{adapter_incoming_request_params.dig("resource_usage", "resource_type")}</p>",
+        "<p>Current Usage: #{adapter_incoming_request_params.dig("resource_usage", "current_usage")}</p>",
+        "<p>Average Usage: #{adapter_incoming_request_params.dig("resource_usage", "average_usage")} / #{adapter_incoming_request_params.dig("resource_usage", "average_minutes")}m</p>"
+      ].join("")
+    end
+
+    def _additional_datums
+      try("_additional_datums_#{_webhook_type}") || []
+    end
+
+    def _additional_datums_uptime
+      [
+        AdditionalDatum.new(format: "datetime", label: "Timestamp", value: Time.at(adapter_incoming_request_params.dig("timestamp"))),
+        AdditionalDatum.new(format: "text", label: "Monitor Type", value: adapter_incoming_request_params.dig("monitor_type")),
+        AdditionalDatum.new(format: "link", label: "Monitor Target", value: adapter_incoming_request_params.dig("monitor_target"))
+      ]
+    end
+
+    def _additional_datums_blacklist
+      []
+    end
+
+    def _additional_datums_resource_usage
+      [
+        AdditionalDatum.new(format: "text", label: "Resource Type", value: adapter_incoming_request_params.dig("resource_usage", "resource_type")),
+        AdditionalDatum.new(format: "text", label: "Current Usage", value: adapter_incoming_request_params.dig("resource_usage", "current_usage"))
+      ]
+    end
+  end
+end

data/app/models/pager_tree/integrations/honeybadger/v3.rb

@@ -11,7 +11,7 @@ module PagerTree::Integrations
     end
 
     def adapter_should_block_incoming?(request)
-      self.option_token.present? && (request.headers["honeybadger-token"] != self.option_token)
+      option_token.present? && (request.headers["honeybadger-token"] != option_token)
     end
 
     def adapter_supports_incoming?

data/app/models/pager_tree/integrations/hydrozen/v3.rb

@@ -0,0 +1,6 @@
+module PagerTree::Integrations
+  class Hydrozen::V3 < SixtySixUptime::V3
+    # we can just piggy back the SixtySixUptime::V3 since Hydrozen is a clone of SixtySixUptime
+    # both integrations have the same exact functionality
+  end
+end