slackert 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 69f9315335d1406edccde04e2ae402ef7f27b20a153593546415f9632c9b236a
+  data.tar.gz: abda8738fba7ea3a95b8b91742853893b9efde5e23394e105bec6ce02f8bff3e
+SHA512:
+  metadata.gz: fdd1c3ef7813a16917768a2997bae3171eec7854cac41f14997a76022b511caf0efdf9ba233800f77292a8ca2ef66f0f90a19efc64a04689ee42a0dc2202a4fb
+  data.tar.gz: 3ea15b1ba76fac9a88c6e94656e03a266d27e9c651d2b8dfdcb8d95a9dfb481ceaa7f03ce772947369e432a1b9fd5bf56f75811ecfc62082c80c558237107569

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.DS_Store
+*.gem
+Gemfile.lock
+
+.vscode/

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Braze
+
+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,146 @@
+# Slackert
+
+A simple way to create and send Slack messages through a webhook.
+
+Especially useful for logging and alerting, supports three logging levels `Error, Info, Debug` and templates to simplify sending the same layout message with different content.
+
+## Installation
+
+Add Slacker to your Gemfile
+
+    gem 'slackert', git: git@github.com:braze-inc/braze-growth-shares-slackert.git
+
+Then
+
+    $ bundle install
+
+<!-- TODO: Once posted to rubygems -->
+<!-- Or install it yourself as:
+
+    $ gem install slackert -->
+
+## Usage
+
+Slackert sends messages through an Incoming Webhook. To add a webhook to your channel, follow [this guide.](https://api.slack.com/messaging/webhooks)
+
+Initialize alert client that will handle sending out your messages:
+
+    alerts = Slackert::Alerter.new(<WebhookURL>)
+
+Create a message with a message builder:
+
+    message_builder = Slackert::MessageBuilder.new
+    message_builder.add_header('Message Title')
+    message_builder.add_plain_text('Description of the message.)
+    message = message_builder.build
+
+And send it out:
+
+    alerts.info(message)
+
+For more complex layouts, use `Blocks`.
+
+### Message Building
+
+We can also use a block initialization to simplify the process of creating a message
+
+    message = Slackert::MessageBuilder.build do |msg|
+      msg.add_header("Header)
+      msg.add_markdown_text("This is some *bold* text while _this_ is italics. :thumbsup:")
+      msg.add_divider
+
+      msg.notifiy_users(
+        ['slackMemberID1', 'slackMemberID2'],
+        msg_prefix = 'Look at my message guys, '
+      )
+
+Include any emojis, styling you want. Go wild!
+
+### Blocks
+
+Slack messages use blocks to group and style messages. Blocks allow to include pictures, buttons,
+interactivity and more.
+
+The blocks currently supported by slackert: `Divider, Header, Section`
+
+You can add a divider or a header directly from the builder:
+
+    builder.add_header('Header Text')
+
+    builder.add_divider
+
+In order to compose a section block, use `Slackert::Blocks::Section`
+
+    stats_section = Slackert::Blocks::Section.new
+
+    # Add section text - description like text, limited to only one per section
+    stats_section.add_section_text("The script executed with the following output:")
+
+    # Add field text - it is like a cell in an invisible 2-column grid on Desktop and 1-column grid one Mobile
+    stats_section.add_field_text("*Processed*:\n12345")
+    stats_section.add_field_text("*Failed Records*:\n3")
+
+Then simply add it to the builder:
+
+    builder.add_section(stats_section)
+
+We can also create a section straight from a hash of values, which simplifies creating sections for key: value type of data.
+
+    values = {
+        'Rows': 123,
+        'Tables': 2
+    }
+    section = Slackert::Blocks::Section.new_from_hash(values, bold_keys: true)
+
+### Templates
+
+Templates optimize the process of creating and sending alerts by providing layouts and an easy way to fill their content. As an example, to send a Slack message when a job finishes processing:
+
+    message = Slackert::Templates.job_finish(
+        title: "My Job Title",
+        desc: "The job is responsible for some real heavy work.",
+        result: "OK :thumbsup:",
+        stats: {
+            "Processed Rows": 10987,
+            "Updated Rows": 89,
+            "Deleted Rows": 0,
+            "Errors": 0
+        }
+    )
+
+    alerts.info(message)
+
+#### Examples
+
+#### Job Executed
+<br>
+<img src="./screenshots/job-executed.png" width="600" height="309">
+<br>
+
+#### Job Error
+<br>
+<img src="./screenshots/job-error.png" width="600" height="281">
+<br>
+
+### Logging Level
+
+To change the logging/reporting level, simply set `Slackert.level`.  
+For example, to only report errors:
+
+    Slackert.level = Slackert::Level::ERROR
+
+By default, slackert starts with level `INFO`
+
+<!-- ## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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 `version.rb`, 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 # repo link -->
+
+# License
+
+MIT. See [LICENSE](LICENSE)

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/bin/bundle

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+  module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../../Gemfile", __FILE__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_version
+    @bundler_version ||=
+      env_var_version || cli_arg_version ||
+        lockfile_version
+  end
+
+  def bundler_requirement
+    return "#{Gem::Requirement.default}.a" unless bundler_version
+
+    bundler_gem_version = Gem::Version.new(bundler_version)
+
+    requirement = bundler_gem_version.approximate_recommendation
+
+    return requirement unless Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.7.0")
+
+    requirement += ".a" if bundler_gem_version.prerelease?
+
+    requirement
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    activate_bundler
+  end
+
+  def activate_bundler
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_requirement
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "slackert"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/htmldiff

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'htmldiff' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("diff-lcs", "htmldiff")

data/bin/ldiff

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'ldiff' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("diff-lcs", "ldiff")

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/slackert.rb

@@ -0,0 +1,30 @@
+require 'slackert/alerter'
+require 'slackert/level'
+require 'slackert/builder'
+require 'slackert/blocks'
+require 'slackert/templates'
+
+# Namespace for classes and modules that handle creation and delivery of Slack messages and alerts
+module Slackert
+  @level = Level::INFO
+
+  # Sets logging level for messages. Logging level constants are defined in {Slackert::Level}
+  #
+  # @param level [Number] logging level
+  # @raise [ArgumentError] if the logging level is out of bounds
+  #
+  def self.level=(value)
+    log_values = Level.constants.map { |const| Level.const_get(const) }
+    min, max = log_values.minmax
+    raise ArgumentError, 'Invalid logging level' if value < min || value > max
+
+    @level = value
+  end
+
+  # Return current logging level
+  # @return [Number] current level
+  #
+  def self.level
+    @level
+  end
+end

data/lib/slackert/alerter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/https'
+require 'json'
+
+module Slackert
+  # Slack client responsible for sending composed Slack messages
+  # @param [String] Slack incoming webhook URL to a particular channel
+  #
+  class Alerter
+    def initialize(webhook_url)
+      @uri = URI.parse(webhook_url)
+      @https = configure_https
+    end
+
+    # Sends a debug Slack message if logging level is set at Level::DEBUG
+    # @param [Hash] Slack message
+    #
+    def debug(content)
+      return if Slackert.level < Level::DEBUG
+
+      post_to_slack(content)
+    end
+
+    # Sends an info Slack message if loggin level is set at Level::INFO or lower
+    # @param [Hash] Slack message
+    #
+    def info(content)
+      return if Slackert.level < Level::INFO
+
+      post_to_slack(content)
+    end
+
+    # Sends an error Slack message
+    # @param [Hash] Slack message
+    #
+    def error(content)
+      post_to_slack(content)
+    end
+
+    private
+
+    def configure_https
+      https = Net::HTTP.new(@uri.host, @uri.port)
+      https.use_ssl = true
+      https
+    end
+
+    def post_to_slack(content)
+      raise 'Message content cannot be empty.' if content.empty?
+
+      req = base_post_req
+      req.body = content.to_json
+      res = @https.request(req)
+      puts "Message sending unsuccesful (Code: #{res.code}, Message: #{res.message})" if res.code != '200'
+    end
+
+    def base_post_req
+      req = Net::HTTP::Post.new(@uri)
+      req['Content-type'] = 'application/json'
+      req
+    end
+  end
+end

data/lib/slackert/blocks.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Slackert
+  # Block elements that a Slack message can be composed of.
+  module Blocks
+    # Abstract BlockElement.
+    # Subclass and override +to_slack+ to add a new block element.
+    class BlockElement
+      def initialize(type)
+        @type = type
+      end
+
+      # Returns a hash of the element, ready to be added to the block formatted message.
+      # Abstract method that needs to be implemented in each subclassed element.
+      #
+      def to_slack
+        raise NoMethodError, 'Override this implementation'
+      end
+    end
+
+    # Header block element provides a title, rendered as a larger bold text on top of the message.
+    class Header < BlockElement
+      # @param text [String] header text
+      def initialize(text)
+        super('header')
+        @text = text
+      end
+
+      # See {BlockElement#to_slack}
+      def to_slack
+        {
+          'type': @type,
+          'text': {
+            'type': 'plain_text',
+            'text': @text
+          }
+        }
+      end
+    end
+
+    # Divider block element provides a horizontal separator, simlarly to HTML's +<hr>+
+    class Divider < BlockElement
+      def initialize
+        super('divider')
+      end
+
+      # See {BlockElement#to_slack}
+      def to_slack
+        {
+          'type': @type
+        }
+      end
+    end
+
+    # Section block element is a very flexible layout block that can serve as a simple text block but it also allows
+    # for adding block elements such as field text, buttons, images and more. Currently only section text and field
+    # texts are supported.
+    #
+    # To learn more, visit https://api.slack.com/reference/block-kit/blocks#section
+    #
+    class Section < BlockElement
+      def initialize
+        @text = {}
+        @fields = []
+        super('section')
+      end
+
+      # Initialize field text objects from a hash.
+      # @param [Hash] key, value pairs that each will become a field text object
+      # @param line_break [Boolean] add a line break after each key so values render right under the key
+      #                             instead of next to it
+      # @param bold_keys [Boolean] apply bold text formatting to the keys
+      # @return [Section]
+      def self.new_from_hash(values, line_break: true, bold_keys: true)
+        s = new
+
+        values.each do |key, value|
+          title = bold_keys ? "*#{key}*" : key
+          title = line_break ? "#{title}\n" : title
+          s.add_field_text("#{title}#{value}")
+        end
+
+        s
+      end
+
+      # Adds a text object on top of the section. There can only be one section text added. Adding more will replace
+      # the previously added section text. It is limited to 3000 characters.
+      # @param message [String] section text message
+      # @param type [String] can be either mrkdwn or plain_text
+      #
+      def add_section_text(message, type = 'mrkdwn')
+        @text = {
+          'type': type,
+          'text': message
+        }
+      end
+
+      # Adds a field text object to the message. Field texts render in two columns on desktop and are added left
+      # to right. They show as one column on mobile.
+      # There can only be 10 fields added in total and each text item has a limit of 2000 characters.
+      # @param message [String] field text message
+      # @param type [String] can be either mrkdwn or plain_text
+      # @raise [RuntimeError] if maximum capacity of 10 field objects has been reached
+      #
+      def add_field_text(message, type = 'mrkdwn')
+        raise 'Maximum field text objects has been reached.' if @fields.length == 10
+
+        @fields.push(
+          {
+            'type': type,
+            'text': message
+          }
+        )
+      end
+
+      # See {BlockElement#to_slack}
+      def to_slack
+        if @text.empty? && @fields.empty?
+          raise 'Either section text or field text needs to be filled in order to compose the section.'
+        end
+
+        section = { 'type': @type }
+        section['text'] = @text unless @text.empty?
+        section['fields'] = @fields unless @fields.empty?
+        section
+      end
+    end
+  end
+end

data/lib/slackert/builder.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'slackert/blocks'
+
+module Slackert
+  # Builder class that allows to build a Slack message piece by piece.
+  # After the message has been constructed, it is built with ++builder.build++ method and can be passed to Alerter 
+  # class for sending.
+  #
+  # Supports blocks initialization that returns a ready alert/message
+  #
+  #   msg = Slackert::MessageBuilder.build do |b|
+  #     b.add_header('header')
+  #     ...
+  #   end
+  #
+  class MessageBuilder
+    # Block initialization
+    # @return [Hash] built message
+    #
+    def self.build
+      builder = new
+      yield(builder)
+      builder.build
+    end
+
+    def initialize
+      @content = []
+    end
+
+    # Add a header to the message. It formats as a large title on top of the message.
+    # @param text [String] header text, plain text only
+    #
+    def add_header(text)
+      return if text.empty?
+
+      @content.push(Blocks::Header.new(text).to_slack)
+    end
+
+    # Adds a horizontal divider.
+    #
+    def add_divider
+      @content.push(Blocks::Divider.new.to_slack)
+    end
+
+    # Adds markdown text to the message.
+    # @param text [String] markdown text
+    #
+    def add_markdown_text(text)
+      return if text.empty?
+
+      mkd_section = Blocks::Section.new
+      mkd_section.add_field_text(text)
+      add_section(mkd_section)
+    end
+
+    # Adds plain text to the message.
+    # @param text [String] plain text
+    #
+    def add_plain_text(text)
+      return if text.empty?
+
+      text_section = Blocks::Section.new
+      text_section.add_section_text(text)
+      add_section(text_section)
+    end
+
+    # Adds Slack user notifications.
+    # @param user_ids [Array<String>] Slack member IDs
+    # @param msg_prefix [String] message added inline before the notifications
+    # @param delim [String] delimiter to separate Slack users
+    #
+    def notify_users(user_ids, msg_prefix = 'Please look into this: ', delim = ' | ')
+      return if user_ids.empty?
+
+      tag_section = Blocks::Section.new
+      user_notifs = user_ids.map { |user_id| "<@#{user_id}>" }
+      notifs_msg = user_notifs.join(delim)
+      tag_section.add_section_text(msg_prefix + notifs_msg)
+      add_section(tag_section)
+    end
+
+    # Adds a {Blocks::Section} block element to the message.
+    # @param section [Blocks::Section] section block
+    #
+    def add_section(section)
+      @content.push(section.to_slack)
+    end
+
+    # Inserts a {Blocks::Section} block element on top of the message.
+    # @param section [Blocks::Section] section block
+    #
+    def prepend_section(section)
+      @content.unshift(section.to_slack)
+    end
+
+    # Builds a message. Creates a hash object from the added fields in the builder.
+    # @return [Hash] Slack message
+    #
+    def build
+      {
+        'blocks': @content
+      }
+    end
+  end
+end

data/lib/slackert/level.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Slackert
+  # Logging level constants for Slackert
+  module Level
+    ERROR = 0
+    INFO = 1
+    DEBUG = 2
+  end
+end

data/lib/slackert/templates.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'slackert/blocks'
+
+module Slackert
+  # Pre-defined Slack message templates that you can use for a quick message layout
+  # instead of building one from scratch. Most of the templates are customizable and you can
+  # include or exclude fields like title, description or extra data that will appear in the message.
+  #
+  # Example Usage
+  #
+  #   message = Slackert::Templates.job_start(
+  #     title: 'Job Title',
+  #     desc: 'This job does this and that',
+  #     overview: {
+  #       'Job Type': 'Refresh',
+  #       'Action': 'Update',
+  #       'Start Time': Time.now.strftime("%Y/%m/%d %H:%M:%S")
+  #     }
+  #   )
+  #
+  #   alerts = Slackert::Alerter.new('mywebhook')
+  #   alerts.info(message)
+  #
+  module Templates
+    # Message layout for a quick notification.
+    #
+    # @param title [String] optional title
+    # @param text [String] notification text, accepts markdown
+    #
+    # @return [Hash] Slack message
+    #
+    def self.notification(text:, title: '')
+      MessageBuilder.build do |alert|
+        alert.add_header(title) unless title.empty?
+        alert.add_markdown_text(text)
+      end
+    end
+
+    # Message layout to notify of a job start.
+    #
+    # @param title [String] title of the message, plain text only
+    # @param desc [String] description of the message, accepts markdown
+    # @param overview [Hash] extra identifiable key: value section fields to be included in the message,
+    #                        both keys and values accept markdown and keys are bold by default
+    # @return [Hash] Slack message
+    #
+    def self.job_start(
+      title: '',
+      desc: '',
+      overview: {}
+    )
+      MessageBuilder.build do |alert|
+        alert.add_header(title) unless title.empty?
+        alert.add_plain_text(desc) unless desc.empty?
+        add_section_from_hash(alert, overview) unless overview.empty?
+      end
+    end
+
+    # Message layout to notify of a job finish.
+    #
+    # @param title [String] title of the message, plain text only
+    # @param desc [String] description of the message, accepts markdown
+    # @param result [String] result of the job, accepts markdown
+    # @param stats [Hash] extra execution key: value section fields to be included in the message,
+    #                     both keys and values accept markdown and keys are bold by default
+    # @return [Hash] Slack message
+    #
+    def self.job_finish(
+      title: '',
+      desc: '',
+      result: '',
+      stats: {}
+    )
+      MessageBuilder.build do |alert|
+        alert.add_header(title)
+        alert.add_plain_text(desc)
+        alert.add_markdown_text("*Result*: #{result}")
+        add_section_from_hash(alert, stats) unless stats.empty?
+      end
+    end
+
+    # Combines both job start and job finish into a single message. Best for quick jobs where a separate start
+    # and finish alerts are unnecessary.
+    #
+    # @param title [String] title of the message, plain text only
+    # @param desc [String] description of the message, accepts markdown
+    # @param result [String] result of the job, accepts markdown
+    # @param overview [Hash] a section of key: value fields, both keys and values accept markdown
+    #                        and keys are bold by default
+    # @param stats [Hash] a separate section of key: value fields, both keys and values accept markdown
+    #                     and keys are bold by default
+    # @return [Hash] Slack message
+    #
+    def self.job_executed(
+      title: '',
+      desc: '',
+      result: '',
+      overview: {},
+      stats: {}
+    )
+      MessageBuilder.build do |alert|
+        alert.add_header(title) unless title.empty?
+        alert.add_plain_text(desc) unless desc.empty?
+        alert.add_markdown_text("*Result*: #{result}") unless result.empty?
+        add_section_from_hash(alert, overview) unless overview.empty?
+        add_section_from_hash(alert, stats) unless stats.empty?
+      end
+    end
+
+    # Message on job error that notifies specified users by tagging them in the alert.
+    #
+    # @param title [String] title of the job/alert, plain text only
+    # @param error [String] error message
+    # @param notify_user_ids Array<String> Slack member IDs that will be tagged and notified
+    # @param extra [Hash] additional section of key: value fields, both accept markdown and keys are bold by default
+    # @param add_alert_emoji [Boolean] adds rotating light emoji in the title
+    #
+    # @return [Hash] Slack message
+    #
+    def self.job_error(
+      title:,
+      error:,
+      notify_user_ids: [],
+      extra: {},
+      add_alert_emoji: true
+    )
+      MessageBuilder.build do |alert|
+        header = "Error while processing #{title}"
+        header = add_alert_emoji ? ":rotating_light: #{header}" : header
+
+        alert.add_header(header)
+        alert.notify_users(notify_user_ids) unless notify_user_ids.empty?
+        alert.add_divider
+        alert.add_markdown_text('*Result*: Fail')
+        alert.add_markdown_text("*Error Output*:\n```#{error}```")
+        add_section_from_hash(alert, extra) unless extra.empty?
+      end
+    end
+
+    def self.add_section_from_hash(alert, values)
+      alert.add_divider
+      section = Blocks::Section.new_from_hash(values, bold_keys: true)
+      alert.add_section(section)
+    end
+
+    private_class_method :add_section_from_hash
+  end
+end

data/lib/slackert/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Slackert
+  VERSION = "0.1.0"
+end

data/slackert.gemspec

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lib/slackert/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'slackert'
+  spec.version       = Slackert::VERSION
+  spec.authors       = ['Maciej Olko']
+  spec.summary       = 'Quick and simple way to send message through Slack webhook.'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+  spec.homepage      = 'https://github.com/braze-inc/braze-growth-shares-slackert'
+  spec.license       = 'MIT'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rspec', '~> 3.10.0'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: slackert
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maciej Olko
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/bundle
+- bin/console
+- bin/htmldiff
+- bin/ldiff
+- bin/rake
+- bin/rspec
+- bin/setup
+- lib/slackert.rb
+- lib/slackert/alerter.rb
+- lib/slackert/blocks.rb
+- lib/slackert/builder.rb
+- lib/slackert/level.rb
+- lib/slackert/templates.rb
+- lib/slackert/version.rb
+- screenshots/job-error.png
+- screenshots/job-executed.png
+- slackert.gemspec
+homepage: https://github.com/braze-inc/braze-growth-shares-slackert
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Quick and simple way to send message through Slack webhook.
+test_files: []