sensu-transport-snssqs 2.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a825c80ab314cedefd551d4960c5922bda96a618
-  data.tar.gz: d97c573f4356d8032614c70701b865d61af71956
+  metadata.gz: d5c8cbded309051beefe6b54d1f24cb03d4ffc86
+  data.tar.gz: 5f6b15bd2c9e180280f8908e842622d395e4a682
 SHA512:
-  metadata.gz: 688227148a7821e3ae420697b3056db3823fa9ab52f6e76d57052d8604707fc414b80becd740680a862b60d341131cdb2386c4b026c6d3c1c2387578cc743d6f
-  data.tar.gz: 83daa1a61c26f42fe40b3c64bd92d01a6dcf63144d42b78d656b68c10b2416d51e00a3419d21c6a012affb7552a5d4af55a69af001925754b1e091c8f581002a
+  metadata.gz: 7823b085e8a8504b3024bd8d88134e0ea59b7931566189362acf1ce54ee72224fb2f78b7269ad703eb3dc2894010e28070d4a1c0b66d1bf3bf02d957f2df47be
+  data.tar.gz: 36bf0b6222f0386ccad49d7f5b74ed6f131f1da3461890bef49dde8ac587584d6c9b62782154f81b6f64e304221270a40156e66ae65dab6e14b8fe31075280fa

data/lib/sensu/transport/snssqs.rb

@@ -0,0 +1,174 @@
+require 'sensu/transport/base'
+require 'aws-sdk'
+require 'statsd-ruby'
+
+module Sensu
+  module Transport
+    class SNSSQS < Sensu::Transport::Base
+      attr_accessor :logger
+
+      STRING_STR     = "String".freeze
+      KEEPALIVES_STR = "keepalives".freeze
+      PIPE_STR       = "pipe".freeze
+      TYPE_STR       = "type".freeze
+
+      def initialize
+        @connected = false
+        @subscribing = false
+
+        # as of sensu 0.23.0 we need to call succeed when we have
+        # successfully connected to SQS.
+        #
+        # we already have our own logic to maintain the connection to
+        # SQS, so we can always say we're connected.
+        #
+        # See:
+        # https://github.com/sensu/sensu/blob/cdc25b29169ef2dcd2e056416eab0e83dbe000bb/CHANGELOG.md#0230---2016-04-04
+        succeed()
+      end
+
+      def connected?; @connected; end
+
+      def connect(settings)
+        @settings = settings
+        @connected = true
+        @results_callback = proc {}
+        @keepalives_callback = proc {}
+        @sqs = Aws::SQS::Client.new(region: @settings[:region])
+        @sns = Aws::SNS::Client.new(region: @settings[:region])
+
+        # connect to statsd, if necessary
+        @statsd = nil
+        if @settings[:statsd_addr] != ""
+          pieces = @settings[:statsd_addr].split(':')
+          @statsd = Statsd.new(pieces[0], pieces[1].to_i).tap { |sd|
+            sd.namespace = @settings[:statsd_namespace]
+          }
+          @statsd_sample_rate = @settings[:statsd_sample_rate].to_f
+        end
+      end
+
+      def statsd_incr(stat)
+        @statsd.increment(stat, @statsd_sample_rate) unless @statsd.nil?
+      end
+
+      def statsd_time(stat)
+        # always measure + run the block, but only if @statsd is set
+        # do we actually report it.
+        start = Time.now
+        result = yield
+        if !@statsd.nil?
+          @statsd.timing(stat, ((Time.now - start) * 1000).round(5), @statsd_sample_rate)
+        end
+        result
+      end
+
+      # subscribe will begin "subscribing" to the consuming sqs queue.
+      #
+      # What this really means is that we will start polling for
+      # messages from the SQS queue, and, depending on the message
+      # type, it will call the appropriate callback.
+      #
+      # This assumes that the SQS Queue is consuming "Raw" messages
+      # from SNS.
+      #
+      # "subscribing" means that the "callback" parameter will be
+      # called when there is a message for you to consume.
+      #
+      # "funnel" and "type" parameters are completely ignored.
+      def subscribe(type, pipe, funnel = nil, options = {}, &callback)
+        self.logger.info("subscribing to type=#{type}, pipe=#{pipe}, funnel=#{funnel}")
+
+        if pipe == KEEPALIVES_STR
+          @keepalives_callback = callback
+        else
+          @results_callback = callback
+        end
+
+        unless @subscribing
+          do_all_the_time {
+            EM::Iterator.new(receive_messages, 10).each do |msg, iter|
+              statsd_time("sqs.#{@settings[:consuming_sqs_queue_url]}.process_timing") {
+                if msg.message_attributes[PIPE_STR].string_value == KEEPALIVES_STR
+                  @keepalives_callback.call(msg, msg.body)
+                else
+                  @results_callback.call(msg, msg.body)
+                end
+              }
+              iter.next
+            end
+          }
+          @subscribing = true
+        end
+      end
+
+      # acknowledge will delete the given message from the SQS queue.
+      def acknowledge(info, &callback)
+        EM.defer {
+          @sqs.delete_message(
+            queue_url: @settings[:consuming_sqs_queue_url],
+            receipt_handle: info.receipt_handle,
+          )
+          statsd_incr("sqs.#{@settings[:consuming_sqs_queue_url]}.message.deleted")
+          callback.call(info) if callback
+        }
+      end
+
+      # publish publishes a message to the SNS topic.
+      #
+      # The type, pipe, and options are transformed into SNS message
+      # attributes and included with the message.
+      def publish(type, pipe, message, options = {}, &callback)
+        attributes = {
+          TYPE_STR => str_attr(type),
+          PIPE_STR => str_attr(pipe)
+        }
+        options.each do |k, v|
+          attributes[k.to_s] = str_attr(v.to_s)
+        end
+        EM.defer { send_message(message, attributes, &callback) }
+      end
+
+      private
+
+      def str_attr(str)
+        { :data_type => STRING_STR, :string_value => str }
+      end
+
+      def do_all_the_time(&blk)
+        callback = proc {
+          do_all_the_time(&blk)
+        }
+        EM.defer(blk, callback)
+      end
+
+      def send_message(msg, attributes, &callback)
+        resp = @sns.publish(
+          target_arn: @settings[:publishing_sns_topic_arn],
+          message: msg,
+          message_attributes: attributes
+        )
+        statsd_incr("sns.#{@settings[:publishing_sns_topic_arn]}.message.published")
+        callback.call({ :response => resp }) if callback
+      end
+
+      PIPE_ARR = [PIPE_STR]
+
+      # receive_messages returns an array of SQS messages
+      # for the consuming queue
+      def receive_messages
+        begin
+          resp = @sqs.receive_message(
+            message_attribute_names: PIPE_ARR,
+            queue_url: @settings[:consuming_sqs_queue_url],
+            wait_time_seconds: @settings[:wait_time_seconds],
+            max_number_of_messages: @settings[:max_number_of_messages],
+          )
+          resp.messages
+        rescue Aws::SQS::Errors::ServiceError => e
+          self.logger.info(e)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: sensu-transport-snssqs
 version: !ruby/object:Gem::Version
-  version: '2.0'
+  version: 2.0.1
 platform: ruby
 authors:
-- ''
+- Tom Wanielista
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -57,7 +57,8 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/sensu/transport/snssqs.rb
 homepage: https://github.com/SimpleFinance/sensu-transport-snssqs
 licenses: []
 metadata: {}
@@ -80,6 +81,6 @@ rubyforge_project:
 rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
-summary: ''
+summary: Sensu transport over Amazon SNS & SQS
 test_files: []
 has_rdoc: