appoptics-api-ruby 2.1.3

data/lib/appoptics/metrics/errors.rb

@@ -0,0 +1,32 @@
+
+module Appoptics
+  module Metrics
+
+    class MetricsError < StandardError; end
+
+    class CredentialsMissing < MetricsError; end
+    class NoMetricsProvided < MetricsError; end
+    class NoClientProvided < MetricsError; end
+    class InvalidMeasureTime < MetricsError; end
+    class NotMergeable < MetricsError; end
+    class InvalidParameters < MetricsError; end
+
+    class NetworkError < StandardError
+      attr_reader :response
+
+      def initialize(msg, response = nil)
+        super(msg)
+        @response = response
+      end
+    end
+
+    class ClientError < NetworkError; end
+    class Unauthorized < ClientError; end
+    class Forbidden < ClientError; end
+    class NotFound < ClientError; end
+    class EntityAlreadyExists < ClientError; end
+
+    class ServerError < NetworkError; end
+
+  end
+end

data/lib/appoptics/metrics/middleware/count_requests.rb

@@ -0,0 +1,28 @@
+module Appoptics
+  module Metrics
+    module Middleware
+
+      class CountRequests < Faraday::Response::Middleware
+        @total_requests = 0
+
+        class << self
+          attr_reader :total_requests
+
+          def increment
+            @total_requests += 1
+          end
+
+          def reset
+            @total_requests = 0
+          end
+        end
+
+        def call(env)
+          self.class.increment
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end

data/lib/appoptics/metrics/middleware/expects_status.rb

@@ -0,0 +1,38 @@
+module Appoptics
+  module Metrics
+    module Middleware
+
+      class ExpectsStatus < Faraday::Response::Middleware
+
+        def on_complete(env)
+          sanitized = sanitize_request(env)
+          case env[:status]
+          when 401
+            raise Unauthorized.new(sanitized.to_s, sanitized)
+          when 403
+            raise Forbidden.new(sanitized.to_s, sanitized)
+          when 404
+            raise NotFound.new(sanitized.to_s, sanitized)
+          when 422
+            raise EntityAlreadyExists.new(sanitized.to_s, sanitized)
+          when 400..499
+            raise ClientError.new(sanitized.to_s, sanitized)
+          when 500..599
+            raise ServerError.new(sanitized.to_s, sanitized)
+          end
+        end
+
+        def sanitize_request(env)
+          {
+            status: env[:status],
+            url: env[:url].to_s,
+            user_agent: (env[:request_headers] || {})["User-Agent"],
+            request_body: env[:request_body],
+            response_headers: env[:response_headers],
+            response_body: env[:body]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/appoptics/metrics/middleware/request_body.rb

@@ -0,0 +1,18 @@
+module Appoptics
+  module Metrics
+    module Middleware
+
+      class RequestBody < Faraday::Response::Middleware
+
+        def call(env)
+          # duplicate request body so it is preserved through request
+          # in case we need it for exception output
+          env[:request_body] = env[:body]
+          @app.call(env)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/appoptics/metrics/middleware/retry.rb

@@ -0,0 +1,31 @@
+module Appoptics
+  module Metrics
+    module Middleware
+
+      class Retry < Faraday::Middleware
+
+        def initialize(app, retries = 3)
+          @retries = retries
+          super(app)
+        end
+
+        def call(env)
+          retries = @retries
+          request_body = env[:body]
+          begin
+            env[:body] = request_body # after failure is set to response body
+            @app.call(env)
+          rescue Appoptics::Metrics::ServerError, Timeout::Error,
+                 Faraday::Error::ConnectionFailed
+            if retries > 0
+              retries -= 1 and retry
+            end
+            raise
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/appoptics/metrics/persistence.rb

@@ -0,0 +1,2 @@
+require 'metrics/persistence/direct'
+require 'metrics/persistence/test'

data/lib/appoptics/metrics/persistence/direct.rb

@@ -0,0 +1,73 @@
+
+# Manages direct persistence with the Appoptics API
+
+module Appoptics
+  module Metrics
+    module Persistence
+      class Direct
+        # Persist the queued metrics directly to the
+        # Metrics web API.
+        #
+        def persist(client, queued, options={})
+          per_request = options[:per_request]
+          if per_request
+            requests = chunk_queued(queued, per_request)
+          else
+            requests = [queued]
+          end
+          requests.each do |request|
+            resource =
+              if queued[:gauges] || queued[:counters]
+                "metrics"
+              else
+                "measurements"
+              end
+            payload = SmartJSON.write(request)
+            # expects 200
+            client.connection.post(resource, payload)
+          end
+        end
+
+      private
+
+        def chunk_queued(queued, per_request)
+          return [queued] if queue_count(queued) <= per_request
+          reqs = []
+          # separate metric-containing values from global values
+          globals = fetch_globals(queued)
+          top_level_keys.each do |key|
+            metrics = queued[key]
+            next unless metrics
+            if metrics.size <= per_request
+              # we can fit all of this metric type in a single request
+              reqs << build_request(key, metrics, globals)
+            else
+              # going to have to split things up
+              metrics.each_slice(per_request) do |elements|
+                reqs << build_request(key, elements, globals)
+              end
+            end
+          end
+          reqs
+        end
+
+        def build_request(type, metrics, globals)
+          {type => metrics}.merge(globals)
+        end
+
+        def top_level_keys
+          [Appoptics::Metrics::PLURAL_TYPES, :measurements].flatten
+        end
+
+        def fetch_globals(queued)
+          queued.reject { |k, v| top_level_keys.include?(k) }
+        end
+
+        def queue_count(queued)
+          queued.inject(0) { |result, data| result + data.last.size }
+        end
+
+      end
+    end
+  end
+end

data/lib/appoptics/metrics/persistence/test.rb

@@ -0,0 +1,27 @@
+# Use for testing the interface with persistence methods
+
+module Appoptics
+  module Metrics
+    module Persistence
+      class Test
+
+        # persist the given metrics
+        def persist(client, metrics, options={})
+          @persisted = metrics
+          return !@return_value.nil? ? @return_value : true
+        end
+
+        # return what was persisted
+        def persisted
+          @persisted
+        end
+
+        # force a return value from persistence
+        def return_value(value)
+          @return_value = value
+        end
+
+      end
+    end
+  end
+end

data/lib/appoptics/metrics/processor.rb

@@ -0,0 +1,130 @@
+require "set"
+
+module Appoptics
+  module Metrics
+
+    # Mixin which provides common logic between {Queue} and {Aggregator}
+    # objects.
+    module Processor
+      MEASUREMENTS_PER_REQUEST = 500
+
+      attr_reader :per_request, :last_submit_time
+      attr_accessor :prefix, :tags
+
+      def tags
+        @tags ||= {}
+      end
+
+      # The current Client instance this queue is using to authenticate
+      # and connect to Appoptics. This will default to the primary
+      # client used by the Appoptics::Metrics module unless it has been
+      # set to something else.
+      #
+      # @return [Appoptics::Metrics::Client]
+      def client
+        @client ||= Appoptics::Metrics.client
+      end
+
+      def has_tags?
+        !@tags.empty?
+      end
+      alias :tags? :has_tags?
+
+      # The object this MetricSet will use to persist
+      #
+      def persister
+        @persister ||= create_persister
+      end
+
+      # Persist currently queued metrics
+      #
+      # @return Boolean
+      def submit
+        return true if self.empty?
+        options = {per_request: @per_request}
+        if persister.persist(self.client, self.queued, options)
+          @last_submit_time = Time.now
+          clear and return true
+        end
+        false
+      rescue ClientError
+        # clean up if we hit exceptions if asked to
+        clear if @clear_on_failure
+        raise
+      end
+
+      # Capture execution time for a block and queue
+      # it as the value for a metric. Times are recorded
+      # in milliseconds.
+      #
+      # Options are the same as for #add.
+      #
+      # @example Queue API request response time
+      #   queue.time :api_request_time do
+      #     # API request..
+      #   end
+      #
+      # @example Queue API request response time w/ source
+      #   queue.time :api_request_time, source: 'app1' do
+      #     # API request..
+      #   end
+      #
+      # @param [Symbol|String] name Metric name
+      # @param [Hash] options Metric options
+      def time(name, options={})
+        start = Time.now
+        yield.tap do
+          duration = (Time.now - start) * 1000.0 # milliseconds
+          metric = {name => options.merge({value: duration})}
+          add metric
+        end
+      end
+      alias :benchmark :time
+
+    private
+
+      def create_persister
+        type = self.client.persistence.to_s.capitalize
+        Appoptics::Metrics::Persistence.const_get(type).new
+      end
+
+      def epoch_time
+        Time.now.to_i
+      end
+
+      def setup_common_options(options)
+        validate_parameters(options)
+        @autosubmit_interval = options[:autosubmit_interval]
+        @client = options[:client] || Appoptics::Metrics.client
+        @per_request = options[:per_request] || MEASUREMENTS_PER_REQUEST
+        @source = options[:source]
+        @tags = options.fetch(:tags, {})
+        @time = (options[:time] && options[:time].to_i || options[:measure_time] && options[:measure_time].to_i)
+        @create_time = Time.now
+        @clear_on_failure = options[:clear_failures] || false
+        @prefix = options[:prefix]
+      end
+
+      def autosubmit_check
+        if @autosubmit_interval
+          last = @last_submit_time || @create_time
+          self.submit if (Time.now - last).to_i >= @autosubmit_interval
+        end
+      end
+
+      def validate_parameters(options)
+        invalid_combinations = [
+          [:source, :tags],
+        ]
+        opts = options.keys.to_set
+        invalid_combinations.each do |combo|
+          if combo.to_set.subset?(opts)
+            raise InvalidParameters, "#{combo} cannot be simultaneously set"
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/appoptics/metrics/queue.rb

@@ -0,0 +1,191 @@
+require 'metrics/processor'
+
+module Appoptics
+  module Metrics
+    class Queue
+      include Processor
+
+      attr_accessor :skip_measurement_times
+
+      # @option opts [Integer] :autosubmit_count If set the queue will auto-submit any time it hits this number of measurements.
+      # @option opts [Integer] :autosubmit_interval If set the queue will auto-submit if the given number of seconds has passed when a new metric is added.
+      # @option opts [Boolean] :clear_failures Should the queue remove any queued measurements from its queue if it runs into problems with a request? (default: false)
+      # @option opts [Client] :client The client object to use to connect to Metrics. (default: Appoptics::Metrics.client)
+      # @option opts [Time|Integer] :measure_time A default measure_time to use for measurements added.
+      # @option opts [String] :prefix If set will apply the given prefix to all metric names of measurements added.
+      # @option opts [Boolean] :skip_measurement_times If true will not assign measurement_time to each measure as they are added.
+      # @option opts [String] :source The default source to use for measurements added.
+      def initialize(opts={})
+        @queued = {}
+        @autosubmit_count = opts[:autosubmit_count]
+        @skip_measurement_times = opts[:skip_measurement_times]
+        setup_common_options(opts)
+      end
+
+      # Add a metric entry to the metric set:
+      #
+      # @param [Hash] measurements measurements to add
+      # @return [Queue] returns self
+      def add(measurements)
+        measurements.each do |key, value|
+          multidimensional = has_tags?
+          if value.respond_to?(:each)
+            validate_parameters(value)
+            metric = value
+            metric[:name] = key.to_s
+            type = metric.delete(:type) || metric.delete('type') || 'gauge'
+          else
+            metric = {name: key.to_s, value: value}
+            type = :gauge
+          end
+          if @prefix
+            metric[:name] = "#{@prefix}.#{metric[:name]}"
+          end
+          multidimensional = true if metric[:tags] || metric[:time]
+          type = ("#{type}s").to_sym
+          time_key = multidimensional ? :time : :measure_time
+          metric[:time] = metric.delete(:measure_time) if multidimensional && metric[:measure_time]
+
+          if metric[time_key]
+            metric[time_key] = metric[time_key].to_i
+            check_measure_time(metric)
+          elsif !skip_measurement_times
+            metric[time_key] = epoch_time
+          end
+          if multidimensional
+            @queued[:measurements] ||= []
+            @queued[:measurements] << metric
+          else
+            @queued[type] ||= []
+            @queued[type] << metric
+          end
+        end
+        submit_check
+        self
+      end
+
+      # Currently queued counters
+      #
+      # @return [Array]
+      def counters
+        @queued[:counters] || []
+      end
+
+      # Are any metrics currently queued?
+      #
+      # @return Boolean
+      def empty?
+        gauges.empty? && counters.empty? && measurements.empty?
+      end
+
+      # Remove all queued metrics
+      #
+      def clear
+        @queued = {}
+      end
+      alias :flush :clear
+
+      # Currently queued gauges
+      #
+      # @return Array
+      def gauges
+        @queued[:gauges] || []
+      end
+
+      def measurements
+        @queued[:measurements] || []
+      end
+
+      # Combines queueable measures from the given object
+      # into this queue.
+      #
+      # @example Merging queues for more performant submission
+      #   queue1.merge!(queue2)
+      #   queue1.submit  # submits combined contents
+      #
+      # @return self
+      def merge!(mergeable)
+        if mergeable.respond_to?(:queued)
+          to_merge = mergeable.queued
+        elsif mergeable.respond_to?(:has_key?)
+          to_merge = mergeable
+        else
+          raise NotMergeable
+        end
+        Metrics::PLURAL_TYPES.each do |type|
+          if to_merge[type]
+            payload = reconcile(to_merge[type], to_merge[:source])
+            if @queued[type]
+              @queued[type] += payload
+            else
+              @queued[type] = payload
+            end
+          end
+        end
+
+        if to_merge[:measurements]
+          payload = reconcile(to_merge[:measurements], to_merge[:tags])
+          if @queued[:measurements]
+            @queued[:measurements] += payload
+          else
+            @queued[:measurements] = payload
+          end
+        end
+
+        submit_check
+        self
+      end
+
+      # All currently queued metrics
+      #
+      # @return Hash
+      def queued
+        return {} if @queued.empty?
+        globals = {}
+        time = has_tags? ? :time : :measure_time
+        globals[time] = @time if @time
+        globals[:source] = @source if @source
+        globals[:tags] = @tags if has_tags?
+        @queued.merge(globals)
+      end
+
+      # Count of metrics currently queued
+      #
+      # @return Integer
+      def size
+        self.queued.inject(0) { |result, data| result + data.last.size }
+      end
+      alias :length :size
+
+    private
+
+      def check_measure_time(data)
+        time_keys = [:measure_time, :time]
+
+        if time_keys.any? { |key| data[key] && data[key] < Metrics::MIN_MEASURE_TIME }
+          raise InvalidMeasureTime, "Measure time for submitted metric (#{data}) is invalid."
+        end
+      end
+
+      def reconcile(measurements, val)
+        arr = val.is_a?(Hash) ? [@tags, :tags] : [@source, :source]
+        return measurements if !val || val == arr.first
+        measurements.map! do |measurement|
+          unless measurement[arr.last]
+            measurement[arr.last] = val
+          end
+          measurement
+        end
+        measurements
+      end
+
+      def submit_check
+        autosubmit_check # in Processor
+        if @autosubmit_count && self.length >= @autosubmit_count
+          self.submit
+        end
+      end
+
+    end
+  end
+end