rollbar-notification-rules-generator 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7741d04c00243c59a3451ae2626619c1950012aae49833d0354e65a378312eb9
+  data.tar.gz: 2295ce6a7e025b9f51b9080bc3e39e87fbcdafdbe1798f5a7621a1078be85a96
+SHA512:
+  metadata.gz: 7b43b62215e964fbe5e3790ba57573c1a93ed56745ee1eb6adabc2add13cfde0a23decb78d0289e78fb92f97b30a47623839780cbe8ac330153f047bcb2d999d
+  data.tar.gz: d2ee76d26ae45c3be12dcd972cc7d69b6fcd8c72d6dd96a922b364b601be90fa958609d8971cf6056bafc23ceca8cdec51611ec24bf2255a0a262c5d623fd46e

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rollbar-notification-rules-generator.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 abicky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,170 @@
+# rollbar-notification-rules-generator
+
+`rollbar-notification-rules-generator` is a CLI tool that generates Rollbar notification rules
+that are mutually exclusive from a simple YAML file.
+If you outputs the rules in the Terraform language, you can create the rules with Terraform.
+
+For example, assume that you want to notify errors whose title contains the substring "foo"
+to the Slack channel "alert-foo" every time they occur and other errors to the default channel.
+You can write the Rollbar notification rules in the Terraform language as follows:
+
+```terraform
+resource "rollbar_notification" "slack_occurrence_0" {
+  channel = "slack"
+
+  rule {
+    trigger = "occurrence"
+    filters {
+      type      = "level"
+      operation = "gte"
+      value     = "error"
+    }
+    filters {
+      type      = "title"
+      operation = "within"
+      value     = "foo"
+    }
+  }
+  config {
+    channel = "alert-foo"
+  }
+}
+
+resource "rollbar_notification" "slack_occurrence_1" {
+  channel = "slack"
+
+  rule {
+    trigger = "occurrence"
+    filters {
+      type      = "level"
+      operation = "gte"
+      value     = "error"
+    }
+    filters {
+      type      = "title"
+      operation = "nwithin"
+      value     = "foo"
+    }
+  }
+}
+```
+
+As you can see, you have to add the filter whose operation is "nwithin" to the second rule.
+If there are more rules, you have to write complicated rules to make them mutually exclusive
+and struggle to maintain them.
+With this tool, you can write the rules in YAML format as follows:
+
+```yaml
+channel: "slack"
+triggers:
+  occurrence:
+    - conditions:
+        - type: "level"
+          operation: "gte"
+          value: "error"
+        - type: "title"
+          operation: "within"
+          value: "foo"
+      configs:
+        - channel: "alert-foo"
+    - conditions:
+        - type: "level"
+          operation: "gte"
+          value: "error"
+```
+
+You don't have to add another condition to the second rule because the tool generates rules
+to make Rollbar behave as if it tries to find the first rule from the top down that matches
+all the conditions.
+
+## Installation
+
+    $ gem install rollbar-notification-rules-generator
+
+## Usage
+
+```
+Usage: rollbar-notification-rules-generator [options] <input>
+        --format FORMAT              terraform|text (default: terraform)
+```
+
+The input file is in YAML format like the following: 
+
+```yaml
+channel: "slack" # slack or pagerduty
+# This optional value is used as provider meta-argument of Terraform.
+terraform_provider: rollbar.alias_value
+# You can define variables, and they are expanded with the syntax "${{ var.variable_name }}".
+variables:
+  slack_channel_for_foo: "alert-foo"
+triggers:
+  # You can specify the following triggers:
+  #   * new_item
+  #   * deploy
+  #   * reactivated_item
+  #   * reopened_item
+  #   * occurrence_rate
+  #   * exp_repeat_item
+  #   * resolved_item
+  #   * occurrence
+  occurrence:
+    # Each element corresponds to a Rollbar notification rule.
+    # For more details, the following documents help:
+    #  * https://docs.rollbar.com/reference/post_api-1-notifications-slack-rules
+    #  * https://docs.rollbar.com/reference/post_api-1-notifications-pagerduty
+    #  * https://registry.terraform.io/providers/rollbar/rollbar/latest/docs/resources/notification
+    # Note that the tool hasn't supported some types yet.
+    - conditions:
+        - type: "level"
+          operation: "gte"
+          value: "error"
+        - type: "title"
+          operation: "within"
+          value: "foo"
+      # Each element corresponds to "config."
+      # If you specify multiple elements, as many rules as the elements are created,
+      # and Rollbar notifies items according to each configuration.
+      configs:
+        - channel: ${{ var.slack_channel_for_foo }}
+    - conditions:
+        - type: "level"
+          operation: "gte"
+          value: "error"
+```
+
+The text format makes it easier to read the generated rules as follows:
+
+```
+# Slack
+## Every Occurrence
+### Rule 0
+conditions:
+  level >= error
+  title contains substring "foo"
+
+config:
+    channel = "alert-foo"
+
+### Rule 1
+conditions:
+  level >= error
+  title does not contain substring "foo"
+```
+
+## Examples
+
+See the YAML files in [spec/files/yaml](spec/files/yaml). Their output files are in [spec/files/tf](spec/files/tf) and [spec/files/txt](spec/files/txt).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `rollbar-notification-rules-generator.gemspec`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/abicky/rollbar-notification-rules-generator.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/exe/rollbar-notification-rules-generator

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+require "optparse"
+
+require "rollbar/notification"
+
+FORMATS = %w[terraform text]
+
+opts = { format: "terraform" }
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: #{File.basename(__FILE__)} [options] <input>"
+  opt.on("--format FORMAT", FORMATS, "#{FORMATS.join("|")} (default: #{opts[:format]})")
+end
+
+begin
+  opt_parser.parse!(into: opts)
+rescue OptionParser::ParseError => e
+  $stderr.puts "Error: #{e.message}\n\n"
+  $stderr.puts opt_parser.help
+  exit 1
+end
+
+input = ARGV[0]
+unless input
+  $stderr.puts opt_parser.help
+  exit 1
+end
+
+notification = Rollbar::Notification.new(input)
+case opts[:format]
+when "terraform"
+  puts notification.to_tf
+when "text"
+  puts notification.to_s
+end

data/lib/rollbar/notification/channel.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require "rollbar/notification/trigger"
+
+module Rollbar
+  class Notification
+    class Channel
+      SUPPORTED_CHANNELS = %w[slack pagerduty]
+
+      # @param channel [String]
+      # @param triggers [Hash{String => Array<Hash>}]
+      # @param variables [Hash{String => String}]
+      def initialize(channel, triggers, variables)
+        unless SUPPORTED_CHANNELS.include?(channel)
+          raise ArgumentError, "Unsupported channel: #{channel}"
+        end
+
+        @triggers = triggers.map do |trigger, rules|
+          Rollbar::Notification::Trigger.new(channel, trigger, rules, variables)
+        end
+      end
+
+      # @return [String]
+      def to_s
+        @triggers.map(&:to_s).join.chomp
+      end
+
+      # @param provider [String]
+      def to_tf(provider)
+        @triggers.map { |t| t.to_tf(provider) }.join("\n")
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rollbar
+  class Notification
+    module Condition
+      class Base
+        attr_reader :type, :operation, :value
+
+        # @param operation [String]
+        # @param value [String]
+        def initialize(operation, value)
+          unless self.class::SUPPORTED_OPERATIONS.include?(operation)
+            raise ArgumentError, "Unsupported operation: #{operation}"
+          end
+
+          @operation = operation
+          @value = value
+        end
+
+        def to_tf
+          <<~TF
+            filters {
+              type      = "#{@type}"
+              operation = "#{@operation}"
+              value     = "#{@value}"
+            }
+          TF
+        end
+
+        # @param other [Base]
+        # @return [Boolean]
+        def redundant_to?(other)
+          self.class == other.class &&
+            @operation == "neq" &&
+            other.operation == "eq" &&
+            @value != other.value
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/environment.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require "rollbar/notification/condition/base"
+
+module Rollbar
+  class Notification
+    module Condition
+      class Environment < Base
+        SUPPORTED_OPERATIONS = %w[eq neq]
+
+        def initialize(operation, value)
+          super
+          @type = "environment"
+        end
+
+        # @return [String]
+        def to_s
+          "#{@type} #{@operation == "eq" ? "==" : "!="} #{@value}"
+        end
+
+        # @return [Environment]
+        def build_complement_condition
+          self.class.new(@operation == "eq" ? "neq" : "eq", @value)
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/framework.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require "rollbar/notification/condition/base"
+
+module Rollbar
+  class Notification
+    module Condition
+      class Framework < Base
+        SUPPORTED_OPERATIONS = %w[eq]
+
+        def initialize(operation, value)
+          super
+          @type = "framework"
+        end
+
+        # @return [String]
+        def to_s
+          "#{@type} #{@value}"
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/level.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "rollbar/notification/condition/base"
+
+module Rollbar
+  class Notification
+    module Condition
+      class Level < Base
+        SUPPORTED_OPERATIONS = %w[eq gte]
+        SUPPORTED_VALUES = %w[debug info warning error critical]
+
+        # @param lowest_target_level [Integer]
+        # @return [Array<Level>]
+        def self.build_eq_conditions_from(lowest_target_level)
+          SUPPORTED_VALUES[lowest_target_level..].map do |value|
+            new("eq", value)
+          end
+        end
+
+        attr_reader :level
+
+        # @param operation [String]
+        # @param value [String]
+        def initialize(operation, value)
+          super
+          @type = "level"
+
+          @level = SUPPORTED_VALUES.index(value)
+          unless @level
+            raise ArgumentError, "Unsupported value: #{value}"
+          end
+        end
+
+        # @return [String]
+        def to_s
+          "#{@type} #{@operation == "eq" ? "==" : ">="} #{@value}"
+        end
+
+        # @return [Array<String>]
+        def target_level_values
+          @operation == "eq" ? [@value] : SUPPORTED_VALUES[@level..]
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/path.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "rollbar/notification/condition/base"
+
+module Rollbar
+  class Notification
+    module Condition
+      class Path < Base
+        SUPPORTED_OPERATIONS = %w[eq neq within nwithin regex nregex exists nexists]
+        OPERATION_TO_TEXT = {
+          "eq" => "==",
+          "neq" => "!=",
+          "within" => "contains substring",
+          "nwithin" => "does not contain substring",
+          "regex" => "contains substring matching regex",
+          "nregex" => "does not contain substring matching regex",
+          "exists" => "exists",
+          "nexists" => "does not exist",
+        }
+
+        attr_reader :path
+
+        # @param path [String]
+        # @param operation [String]
+        # @param value [String]
+        def initialize(path, operation, value)
+          super(operation, value)
+          @type = "path"
+          @path = path
+        end
+
+        def to_tf
+          <<~TF
+            filters {
+              type      = "#{@type}"
+              path      = "#{@path}"
+              operation = "#{@operation}"
+              value     = "#{@value}"
+            }
+          TF
+        end
+
+        # @return [String]
+        def to_s
+          %Q{#{@type} #{@path} #{OPERATION_TO_TEXT[@operation]} "#{@value}"}
+        end
+
+        # @return [Path]
+        def build_complement_condition
+          new_operation = @operation.start_with?("n") ? @operation.delete_prefix("n") : "n#{@operation}"
+          self.class.new(@path, new_operation, @value)
+        end
+
+        # @return [Boolean]
+        def redundant_to?(other)
+          super && @path == other.path
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/rate.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rollbar
+  class Notification
+    module Condition
+      class Rate
+        PERIOD_TO_TEXT = {
+          60 => "1 minute",
+          300 => "5 minutes",
+          1800 => "30 minutes",
+          3600 => "1 hour",
+          86400 => "1 day",
+        }
+
+        attr_reader :type
+
+        # @param count [Integer]
+        # @param period [Integer]
+        def initialize(count, period)
+          @type = "rate"
+          @count = count
+          @period = period
+        end
+
+        # @return [String]
+        def to_s
+          "At least #{@count} occurrences within #{PERIOD_TO_TEXT[@period]}"
+        end
+
+        def to_tf
+          <<~TF
+            filters {
+              type   = "#{@type}"
+              count  = #{@count}
+              period = #{@period}
+            }
+          TF
+        end
+
+        # @param other [Base]
+        # @return [Boolean]
+        def redundant_to?(other)
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/condition/title.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require "rollbar/notification/condition/base"
+
+module Rollbar
+  class Notification
+    module Condition
+      class Title < Base
+        SUPPORTED_OPERATIONS = %w[within nwithin regex nregex]
+        OPERATION_TO_TEXT = {
+          "within" => "contains substring",
+          "nwithin" => "does not contain substring",
+          "regex" => "contains substring matching regex",
+          "nregex" => "does not contain substring matching regex",
+        }
+
+        def initialize(operation, value)
+          super
+          @type = "title"
+        end
+
+        # @return [String]
+        def to_s
+          %Q{#{@type} #{OPERATION_TO_TEXT[@operation]} "#{@value}"}
+        end
+
+        def build_complement_condition
+          new_operation = @operation.start_with?("n") ? @operation.delete_prefix("n") : "n#{@operation}"
+          self.class.new(new_operation, @value)
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/notification/rule.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+require "rollbar/notification/condition/environment"
+require "rollbar/notification/condition/framework"
+require "rollbar/notification/condition/level"
+require "rollbar/notification/condition/path"
+require "rollbar/notification/condition/rate"
+require "rollbar/notification/condition/title"
+
+module Rollbar
+  class Notification
+    class Rule
+      attr_reader :conditions, :configs
+
+      # @param rule [Hash]
+      def initialize(rule)
+        @conditions = rule.fetch("conditions").map do |condition|
+          case condition.fetch("type")
+          when "environment"
+            Rollbar::Notification::Condition::Environment.new(condition.fetch("operation"), condition.fetch("value"))
+          when "framework"
+            Rollbar::Notification::Condition::Framework.new(condition.fetch("operation"), condition.fetch("value"))
+          when "level"
+            Rollbar::Notification::Condition::Level.new(condition.fetch("operation"), condition.fetch("value"))
+          when "path"
+            Rollbar::Notification::Condition::Path.new(condition.fetch("path"), condition.fetch("operation"), condition.fetch("value"))
+          when "rate"
+            Rollbar::Notification::Condition::Rate.new(condition.fetch("count"), condition.fetch("period"))
+          when "title"
+            Rollbar::Notification::Condition::Title.new(condition.fetch("operation"), condition.fetch("value"))
+          else
+            raise ArgumentError, "Unsupported condition type: #{condition.fetch("type")}"
+          end
+        end
+        @configs = rule.fetch("configs", [{}])
+      end
+
+      def initialize_dup(original)
+        @conditions = original.conditions.dup
+        remove_instance_variable(:@level_condition)
+        super
+      end
+
+      # @return [Rule]
+      def remove_redundant_conditions!
+        @conditions.delete_if do |condition|
+          @conditions.any? { |other| condition.redundant_to?(other) }
+        end
+        self
+      end
+
+      # @param old_condition [Condition::Base]
+      # @param new_condition [Condition::Base]
+      # @return [Rule]
+      def replace_condition!(old_condition, new_condition)
+        @conditions[@conditions.index(old_condition)] = new_condition
+        self
+      end
+
+      # @return [Integer]
+      def lowest_target_level
+        level_condition&.level || 0
+      end
+
+      # @return [String]
+      def lowest_target_level_value
+        Rollbar::Notification::Condition::Level::SUPPORTED_VALUES[lowest_target_level]
+      end
+
+      # Splits rules if necessary.
+      # Assuming the following two rules:
+      #   level = critical, title contains substring "bar"
+      #   level >= error,   title contains substring "baz"
+      # the second rule will be split into two rules with "eq" operation:
+      #   level = critical, title contains substring "bar"
+      #   level = critical, title contains substring "baz"
+      #   level = error,    title contains substring "baz"
+      # whereas assuming the following two rules:
+      #   level = warning, title contains substring "bar"
+      #   level >= error,   title contains substring "baz"
+      # this method doesn't split the second rule because each rule
+      # is already mutually exclusive.
+      #
+      # @param highest_lowest_target_level [Integer] the highest lowest_target_level
+      #   among the preceding rules.
+      # @return [Array<Rule>]
+      def split_rules(highest_lowest_target_level)
+        return [dup] if level_condition&.operation == "eq" || highest_lowest_target_level <= lowest_target_level
+
+        new_level_conditions = Rollbar::Notification::Condition::Level.build_eq_conditions_from(lowest_target_level)
+        if level_condition
+          new_level_conditions.map do |condition|
+            dup.replace_condition!(level_condition, condition)
+          end
+        else
+          new_level_conditions.map do |condition|
+            dup.add_conditions!(condition)
+          end
+        end
+      end
+
+      # @param new_conditions [Condition::Base, Array<Condition::Base>]
+      # @return [Rule]
+      def add_conditions!(new_conditions)
+        Array(new_conditions).each do |new_condition|
+          @conditions << new_condition
+        end
+        self
+      end
+
+      # @return [Hash{String => Array<Condition::Base>}]
+      def build_additional_conditions_set_for_subsequent_rules
+        target_levels = level_condition&.target_level_values || Rollbar::Notification::Condition::Level::SUPPORTED_VALUES
+
+        conditions_with_complement = @conditions.select { |c| c.respond_to?(:build_complement_condition) }
+        return {} if conditions_with_complement.empty?
+
+        if conditions_with_complement.size == 1
+          additional_conditions = [[conditions_with_complement.first.build_complement_condition]]
+        else
+          # [cond1, cond2, cond3]
+          # => [
+          #     [cond1, cond2, not-cond3],
+          #     [cond1, not-cond2, cond3],
+          #     [cond1, not-cond2, not-cond3],
+          #     [not-cond1, cond2, cond3],
+          #     [not-cond1, cond2, not-cond3],
+          #     [not-cond1, not-cond2, cond3],
+          #     [not-cond1, not-cond2, not-cond3],
+          #   ]
+          additional_conditions = conditions_with_complement.map do |condition|
+            [condition, condition.build_complement_condition]
+          end.reduce(&:product).map(&:flatten) - [conditions_with_complement]
+        end
+        target_levels.zip([additional_conditions].cycle).to_h
+      end
+
+      private
+
+      def level_condition
+        return @level_condition if defined?(@level_condition)
+        @level_condition = @conditions.find { |c| c.type == "level" }
+      end
+    end
+  end
+end

data/lib/rollbar/notification/trigger.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require "erb"
+
+require "rollbar/notification/rule"
+
+module Rollbar
+  class Notification
+    class Trigger
+      TRIGGER_TO_TEXT = {
+        "deploy" => "Deploy",
+        "exp_repeat_item" => "10^nth Occurrence",
+        "occurrence_rate" => "High Occurrence Rate",
+        "new_item" => "New Item",
+        "occurrence" => "Every Occurrence",
+        "reactivated_item" => "Item Reactivated",
+        "reopened_item" => "Item Reopened",
+        "resolved_item" => "Item Resolved",
+      }
+
+      TEXT_TEMPLATE = ERB.new(<<~TEXT)
+          conditions:
+          <%= conditions.map { |condition| condition.to_s.gsub(/^/, "  ") }.join("\n").chomp %><% unless config.empty? %><% max_key_len = config.keys.map(&:size).max %>
+
+          config:
+          <%= config.compact.map { |key, value| '    %-*s = %s' % [max_key_len, key, value.inspect] }.join("\n") %><% end %>
+      TEXT
+
+      TF_TEMPLATE = ERB.new(<<~TF)
+          resource "rollbar_notification" "<%= resource_name %>" {<% if provider %>
+            provider = <%= provider %>
+          <% end %>
+            channel = "<%= channel %>"
+
+            rule {
+              trigger = "<%= trigger %>"
+          <%= conditions.map { |condition| condition.to_tf.gsub(/^/, "    ") }.join.chomp %>
+            }<% unless config.empty? %><% max_key_len = config.keys.map(&:size).max %>
+            config {
+          <%= config.compact.map { |key, value| '    %-*s = %s' % [max_key_len, key, value.inspect] }.join("\n") %>
+            }<% end %>
+          }
+      TF
+
+      # @param channel [String]
+      # @param name [String]
+      # @param rules [Array<Hash>]
+      def initialize(channel, name, rules, variables)
+        @channel = channel
+        @name = name
+        @rules = rules.map do |rule|
+          Rollbar::Notification::Rule.new(rule)
+        end
+        @variables = variables
+      end
+
+      def to_s
+        str = +"## #{TRIGGER_TO_TEXT.fetch(@name)}\n"
+        i = -1
+        build_mutually_exclusive_rules.each do |rule|
+          rule.configs.map do |config|
+            i += 1
+            str << "### Rule #{i}\n"
+            str << TEXT_TEMPLATE.result_with_hash({
+              conditions: rule.conditions,
+              config: config,
+            }).gsub(/\${{\s*var\.(\w+)\s*}}/) { @variables.fetch($1) }
+          end
+          str << "\n"
+        end
+
+        str
+      end
+
+      def to_tf(provider)
+        i = -1
+        build_mutually_exclusive_rules.flat_map do |rule|
+          rule.configs.map do |config|
+            i += 1
+            TF_TEMPLATE.result_with_hash({
+              resource_name: "#{@channel}_#{@name}_#{i}",
+              provider: provider,
+              channel: @channel,
+              trigger: @name,
+              conditions: rule.conditions,
+              config: config,
+            }).gsub(/\${{\s*var\.(\w+)\s*}}/) { @variables.fetch($1) }
+          end
+        end.join("\n")
+      end
+
+      private
+
+      # @return [Array<Rule>]
+      def build_mutually_exclusive_rules
+        new_rules = []
+        level_value_to_additional_conditions_set = Hash.new([])
+        highest_lowest_target_level = 0
+        @rules.each do |rule|
+          rule.split_rules(highest_lowest_target_level).each do |new_rule|
+            additional_conditions_set = level_value_to_additional_conditions_set[new_rule.lowest_target_level_value]
+            if additional_conditions_set.empty?
+              new_rules << new_rule
+            else
+              additional_conditions_set.each do |additional_conditions|
+                new_rules << new_rule.dup
+                               .add_conditions!(additional_conditions)
+                               .remove_redundant_conditions!
+              end
+            end
+          end
+
+          lowest_target_level = rule.lowest_target_level
+          if lowest_target_level > highest_lowest_target_level
+            highest_lowest_target_level = lowest_target_level
+          end
+          level_value_to_additional_conditions_set.merge!(rule.build_additional_conditions_set_for_subsequent_rules) do |_, v1, v2|
+            v1.product(v2).map(&:flatten)
+          end
+        end
+
+        new_rules
+      end
+    end
+  end
+end

data/lib/rollbar/notification.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require "yaml"
+
+require "rollbar/notification/channel"
+
+module Rollbar
+  class Notification
+    CHANNEL_TO_TEXT = {
+      "slack" => "Slack",
+      "pagerduty" => "PagerDuty",
+    }
+
+    # @param config_file [String]
+    def initialize(config_file)
+      @config = YAML.load_file(config_file)
+      @channel = Rollbar::Notification::Channel.new(
+        @config.fetch("channel"),
+        @config.fetch("triggers"),
+        @config.fetch("variables", {})
+      )
+    end
+
+    # @return [String]
+    def to_s
+      "# #{CHANNEL_TO_TEXT.fetch(@config.fetch("channel"))}\n#{@channel.to_s}"
+    end
+
+    # @return [String]
+    def to_tf
+      @channel.to_tf(@config["terraform_provider"])
+    end
+  end
+end

data/rollbar-notification-rules-generator.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "rollbar-notification-rules-generator"
+  spec.version = "0.2.0"
+  spec.authors = ["abicky"]
+  spec.email = ["takeshi.arabiki@gmail.com"]
+
+  spec.summary = "A CLI tool that generates Rollbar notification rules that are mutually exclusive from a simple YAML file"
+  spec.description = "This tool generates Rollbar notification rules that are mutually exclusive from a simple YAML file."
+
+  spec.homepage = "https://github.com/abicky/rollbar-notification-rules-generator"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/abicky/rollbar-notification-rules-generator"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: rollbar-notification-rules-generator
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- abicky
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-12-14 00:00:00.000000000 Z
+dependencies: []
+description: This tool generates Rollbar notification rules that are mutually exclusive
+  from a simple YAML file.
+email:
+- takeshi.arabiki@gmail.com
+executables:
+- rollbar-notification-rules-generator
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/rollbar-notification-rules-generator
+- lib/rollbar/notification.rb
+- lib/rollbar/notification/channel.rb
+- lib/rollbar/notification/condition/base.rb
+- lib/rollbar/notification/condition/environment.rb
+- lib/rollbar/notification/condition/framework.rb
+- lib/rollbar/notification/condition/level.rb
+- lib/rollbar/notification/condition/path.rb
+- lib/rollbar/notification/condition/rate.rb
+- lib/rollbar/notification/condition/title.rb
+- lib/rollbar/notification/rule.rb
+- lib/rollbar/notification/trigger.rb
+- rollbar-notification-rules-generator.gemspec
+homepage: https://github.com/abicky/rollbar-notification-rules-generator
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/abicky/rollbar-notification-rules-generator
+  source_code_uri: https://github.com/abicky/rollbar-notification-rules-generator
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: A CLI tool that generates Rollbar notification rules that are mutually exclusive
+  from a simple YAML file
+test_files: []