appoptics-api-ruby 2.1.3

data/lib/appoptics/metrics/smart_json.rb

@@ -0,0 +1,43 @@
+module Appoptics
+  module Metrics
+    class SmartJSON
+      if defined?(::MultiJson)
+        def self.read(json)
+          # MultiJSON >= 1.3.0
+          if MultiJson.respond_to?(:load)
+            MultiJson.load(json)
+          else
+            MultiJson.decode(json)
+          end
+        end
+
+        def self.write(json)
+          # MultiJSON <= 1.2.0
+          if MultiJson.respond_to?(:dump)
+            MultiJson.dump(json)
+          else
+            MultiJson.encode(json)
+          end
+        end
+
+        def self.handler
+          :multi_json
+        end
+      else
+        require "json"
+
+        def self.read(json)
+          JSON.parse(json)
+        end
+
+        def self.write(json)
+          JSON.generate(json)
+        end
+
+        def self.handler
+          :json
+        end
+      end
+    end
+  end
+end

data/lib/appoptics/metrics/util.rb

@@ -0,0 +1,25 @@
+module Appoptics
+  module Metrics
+
+    class Util
+      SEPARATOR = "%%"
+
+      # Builds a Hash key from metric name and tags.
+      #
+      # @param metric_name [String] The unique identifying metric name of the property being tracked.
+      # @param tags [Hash] A set of name=value tag pairs that describe the particular data stream.
+      # @return [String] the Hash key
+      def self.build_key_for(metric_name, tags)
+        key_name = metric_name
+        tags.sort.each do |key, value|
+          k = key.to_s.downcase
+          v = value.is_a?(String) ? value.downcase : value
+          key_name = "#{key_name}#{SEPARATOR}#{k}=#{v}"
+        end
+        key_name
+      end
+
+    end
+
+  end
+end

data/lib/appoptics/metrics/version.rb

@@ -0,0 +1,5 @@
+module Appoptics
+  module Metrics
+    VERSION = "2.1.3"
+  end
+end

data/spec/integration/metrics/annotator_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+module Appoptics
+  module Metrics
+
+    describe Annotator do
+      before(:all) { prep_integration_tests }
+      before(:each) { delete_all_annotations }
+
+      describe "#add" do
+        it "creates new annotation" do
+          subject.add :deployment, "deployed v68"
+          annos = subject.fetch(:deployment, start_time: Time.now.to_i-60)
+          expect(annos["events"]["unassigned"].length).to eq(1)
+          expect(annos["events"]["unassigned"][0]["title"]).to eq('deployed v68')
+        end
+        it "supports sources" do
+          subject.add :deployment, 'deployed v69', source: 'box1'
+          annos = subject.fetch(:deployment, start_time: Time.now.to_i-60)
+          expect(annos["events"]["box1"].length).to eq(1)
+          first = annos["events"]["box1"][0]
+          expect(first['title']).to eq('deployed v69')
+        end
+        it "supports start and end times" do
+          start_time = Time.now.to_i-120
+          end_time = Time.now.to_i-30
+          subject.add :deployment, 'deployed v70', start_time: start_time,
+                      end_time: end_time
+          annos = subject.fetch(:deployment, start_time: Time.now.to_i-180)
+          expect(annos["events"]["unassigned"].length).to eq(1)
+          first = annos["events"]["unassigned"][0]
+          expect(first['title']).to eq('deployed v70')
+          expect(first['start_time']).to eq(start_time)
+          expect(first['end_time']).to eq(end_time)
+        end
+        it "supports description" do
+          subject.add :deployment, 'deployed v71', description: 'deployed foobar!'
+          annos = subject.fetch(:deployment, start_time: Time.now.to_i-180)
+          expect(annos["events"]["unassigned"].length).to eq(1)
+          first = annos["events"]["unassigned"][0]
+          expect(first['title']).to eq('deployed v71')
+          expect(first['description']).to eq('deployed foobar!')
+        end
+        it "has an id for further use" do
+          annotation = subject.add :deployment, "deployed v23"
+          expect(annotation['id']).not_to be_nil
+        end
+
+        context "with a block" do
+          it "sets both start and end times" do
+            annotation = subject.add 'deploys', 'v345' do
+              sleep 1.0
+            end
+            data = subject.fetch_event 'deploys', annotation['id']
+            expect(data['start_time']).not_to be_nil
+            expect(data['end_time']).not_to be_nil
+          end
+        end
+      end
+
+      describe "#delete" do
+        it "removes annotation streams" do
+          subject.add :deployment, "deployed v45"
+          subject.fetch :deployment # should exist
+          subject.delete :deployment
+          expect {
+            subject.fetch(:deployment)
+          }.to raise_error(Metrics::NotFound)
+        end
+      end
+
+      describe "#delete_event" do
+        it "removes an annotation event" do
+          subject.add :deployment, 'deployed v46'
+          subject.add :deployment, 'deployed v47'
+          events = subject.fetch(:deployment, start_time: Time.now.to_i-60)
+          events = events['events']['unassigned']
+          ids = events.reduce({}) do |hash, event|
+            hash[event['title']] = event['id']
+            hash
+          end
+          subject.delete_event :deployment, ids['deployed v47']
+          events = subject.fetch(:deployment, start_time: Time.now.to_i-60)
+          events = events['events']['unassigned']
+          expect(events.length).to eq(1)
+          expect(events[0]['title']).to eq('deployed v46')
+        end
+      end
+
+      describe "#fetch" do
+        context "without a time frame" do
+          it "returns stream properties" do
+            subject.add :backups, "backup 21"
+            properties = subject.fetch :backups
+            expect(properties['name']).to eq('backups')
+          end
+        end
+
+        context "with a time frame" do
+          it "returns set of annotations" do
+            subject.add :backups, "backup 22"
+            subject.add :backups, "backup 23"
+            annos = subject.fetch :backups, start_time: Time.now.to_i-60
+            events = annos['events']['unassigned']
+            expect(events[0]['title']).to eq('backup 22')
+            expect(events[1]['title']).to eq('backup 23')
+          end
+          it "respects source limits" do
+            subject.add :backups, "backup 24", source: 'server_1'
+            subject.add :backups, "backup 25", source: 'server_2'
+            subject.add :backups, "backup 26", source: 'server_3'
+            annos = subject.fetch :backups, start_time: Time.now.to_i-60,
+                                  sources: %w{server_1 server_3}
+            expect(annos['events']['server_1']).not_to be_nil
+            expect(annos['events']['server_2']).to be_nil
+            expect(annos['events']['server_3']).not_to be_nil
+          end
+        end
+
+        it "returns exception if annotation is missing" do
+          expect {
+            subject.fetch :backups
+          }.to raise_error(Metrics::NotFound)
+        end
+      end
+
+      describe "#fetch_event" do
+        context "with existing event" do
+          it "returns event properties" do
+            annotation = subject.add 'deploys', 'v69'
+            data = subject.fetch_event 'deploys', annotation['id']
+            expect(data['title']).to eq('v69')
+          end
+        end
+        context "when event doesn't exist" do
+          it "raises NotFound" do
+            expect {
+              data = subject.fetch_event 'deploys', 324
+            }.to raise_error(Metrics::NotFound)
+          end
+        end
+      end
+
+      describe "#list" do
+        before(:each) do
+          subject.add :backups, 'backup 1'
+          subject.add :deployment, 'deployed v74'
+        end
+
+        context "without arguments" do
+          it "lists annotation streams" do
+            streams = subject.list
+            expect(streams['annotations'].length).to eq(2)
+            streams = streams['annotations'].map{|i| i['name']}
+            expect(streams).to include('backups')
+            expect(streams).to include('deployment')
+          end
+        end
+        context "with an argument" do
+          it "lists annotation streams which match" do
+            streams = subject.list name: 'back'
+            expect(streams['annotations'].length).to eq(1)
+            streams = streams['annotations'].map{|i| i['name']}
+            expect(streams).to include('backups')
+          end
+        end
+      end
+
+      describe "#update_event" do
+        context "when event exists" do
+          it "updates event" do
+            end_time = (Time.now + 60).to_i
+            annotation = subject.add 'deploys', 'v24'
+            subject.update_event 'deploys', annotation['id'],
+              end_time: end_time, title: 'v28'
+            data = subject.fetch_event 'deploys', annotation['id']
+
+            expect(data['title']).to eq('v28')
+            expect(data['end_time']).to eq(end_time)
+          end
+        end
+        context "when event does not exist" do
+
+        end
+      end
+
+    end
+
+  end
+end

data/spec/integration/metrics/connection_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Appoptics
+  module Metrics
+
+    describe Connection do
+
+      # TODO: test retry support
+      # TODO: test status code support
+
+    end
+
+  end
+end

data/spec/integration/metrics/middleware/count_requests_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Appoptics
+  module Metrics
+    module Middleware
+
+      describe CountRequests do
+        before(:all) { prep_integration_tests }
+
+        it "counts requests" do
+          CountRequests.reset
+          Metrics.submit foo: 123
+          Metrics.submit foo: 135
+          expect(CountRequests.total_requests).to eq(2)
+        end
+
+        it "is resettable" do
+          Metrics.submit foo: 123
+          expect(CountRequests.total_requests).to be > 0
+          CountRequests.reset
+          expect(CountRequests.total_requests).to eq(0)
+        end
+
+      end
+
+    end
+  end
+end

data/spec/integration/metrics/queue_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module Appoptics
+  module Metrics
+
+    describe Queue do
+      before(:all) { prep_integration_tests }
+      before(:each) do
+        delete_all_metrics
+      end
+
+      context "with a large number of metrics" do
+        it "submits them in multiple requests" do
+          Middleware::CountRequests.reset
+          queue = Queue.new(per_request: 3)
+          (1..10).each do |i|
+            queue.add "gauge_#{i}" => 1
+          end
+          queue.submit
+          expect(Middleware::CountRequests.total_requests).to eq(4)
+        end
+
+        it "persists all metrics" do
+          queue = Queue.new(per_request: 2)
+          (1..5).each do |i|
+            queue.add "gauge_#{i}" => i
+          end
+          (1..3).each do |i|
+            queue.add "counter_#{i}" => {type: :counter, value: i}
+          end
+          queue.submit
+
+          metrics = Metrics.metrics
+          expect(metrics.length).to eq(8)
+          counter = Metrics.get_measurements :counter_3, count: 1
+          expect(counter['unassigned'][0]['value']).to eq(3)
+          gauge = Metrics.get_measurements :gauge_5, count: 1
+          expect(gauge['unassigned'][0]['value']).to eq(5)
+        end
+
+        it "applies globals to each request" do
+          source = 'yogi'
+          measure_time = Time.now.to_i-3
+          queue = Queue.new(
+            per_request: 3,
+            source: source,
+            measure_time: measure_time,
+            skip_measurement_times: true
+          )
+          (1..5).each do |i|
+            queue.add "gauge_#{i}" => 1
+          end
+          queue.submit
+
+          # verify globals have persisted for all requests
+          gauge = Metrics.get_measurements :gauge_5, count: 1
+          expect(gauge[source][0]["value"]).to eq(1.0)
+          expect(gauge[source][0]["measure_time"]).to eq(measure_time)
+        end
+      end
+
+      it "respects default and individual sources" do
+        queue = Queue.new(source: 'default')
+        queue.add foo: 123
+        queue.add bar: {value: 456, source: 'barsource'}
+        queue.submit
+
+        foo = Metrics.get_measurements :foo, count: 2
+        expect(foo['default'][0]['value']).to eq(123)
+
+        bar = Metrics.get_measurements :bar, count: 2
+        expect(bar['barsource'][0]['value']).to eq(456)
+      end
+
+      context "with tags" do
+        let(:queue) { Queue.new(tags: { hostname: "metrics-web-stg-1" }) }
+
+        it "respects default and individual tags" do
+          queue.add test_1: 123
+          queue.add test_2: { value: 456, tags: { hostname: "metrics-web-stg-2" }}
+          queue.submit
+
+          test_1 = Appoptics::Metrics.get_series :test_1, resolution: 1, duration: 3600
+          expect(test_1[0]["tags"]["hostname"]).to eq("metrics-web-stg-1")
+          expect(test_1[0]["measurements"][0]["value"]).to eq(123)
+
+          test_2 = Appoptics::Metrics.get_series :test_2, resolution: 1, duration: 3600
+          expect(test_2[0]["tags"]["hostname"]).to eq("metrics-web-stg-2")
+          expect(test_2[0]["measurements"][0]["value"]).to eq(456)
+        end
+      end
+
+    end
+
+  end
+end

data/spec/integration/metrics_spec.rb

@@ -0,0 +1,375 @@
+require 'spec_helper'
+
+module Appoptics
+  describe Metrics do
+    before(:all) { prep_integration_tests }
+
+    describe "#annotate" do
+      before(:all) { @annotator = Metrics::Annotator.new }
+      before(:each) { delete_all_annotations }
+
+      it "creates new annotation" do
+        Metrics.annotate :deployment, "deployed v68"
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-60)
+        expect(annos["events"]["unassigned"].length).to eq(1)
+        expect(annos["events"]["unassigned"][0]["title"]).to eq('deployed v68')
+      end
+      it "supports sources" do
+        Metrics.annotate :deployment, 'deployed v69', source: 'box1'
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-60)
+        expect(annos["events"]["box1"].length).to eq(1)
+        first = annos["events"]["box1"][0]
+        expect(first['title']).to eq('deployed v69')
+      end
+      it "supports start and end times" do
+        start_time = Time.now.to_i-120
+        end_time = Time.now.to_i-30
+        Metrics.annotate :deployment, 'deployed v70', start_time: start_time,
+                    end_time: end_time
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-180)
+        expect(annos["events"]["unassigned"].length).to eq(1)
+        first = annos["events"]["unassigned"][0]
+        expect(first['title']).to eq('deployed v70')
+        expect(first['start_time']).to eq(start_time)
+        expect(first['end_time']).to eq(end_time)
+      end
+      it "supports description" do
+        Metrics.annotate :deployment, 'deployed v71', description: 'deployed foobar!'
+        annos = @annotator.fetch(:deployment, start_time: Time.now.to_i-180)
+        expect(annos["events"]["unassigned"].length).to eq(1)
+        first = annos["events"]["unassigned"][0]
+        expect(first['title']).to eq('deployed v71')
+        expect(first['description']).to eq('deployed foobar!')
+      end
+    end
+
+    describe "#delete_metrics" do
+      before(:each) { delete_all_metrics }
+
+      context 'with names' do
+
+        context "with a single argument" do
+          it "deletes named metric" do
+            Metrics.submit foo: 123
+            expect(Metrics.metrics(name: :foo)).not_to be_empty
+            Metrics.delete_metrics :foo
+            expect(Metrics.metrics(name: :foo)).to be_empty
+          end
+        end
+
+        context "with multiple arguments" do
+          it "deletes named metrics" do
+            Metrics.submit foo: 123, bar: 345, baz: 567
+            Metrics.delete_metrics :foo, :bar
+            expect(Metrics.metrics(name: :foo)).to be_empty
+            expect(Metrics.metrics(name: :bar)).to be_empty
+            expect(Metrics.metrics(name: :baz)).not_to be_empty
+          end
+        end
+
+        context "with missing metric" do
+          it "runs cleanly" do
+            # the API currently returns success even if
+            # the metric has already been deleted or is absent.
+            Metrics.delete_metrics :missing
+          end
+        end
+
+        context "with no arguments" do
+          it "does not make request" do
+            expect {
+              Metrics.delete_metrics
+            }.to raise_error(Metrics::NoMetricsProvided)
+          end
+        end
+
+      end
+
+      context 'with patterns' do
+        it "filters properly" do
+          Metrics.submit foo: 1, foobar: 2, foobaz: 3, bar: 4
+          Metrics.delete_metrics names: 'fo*', exclude: ['foobar']
+
+          %w{foo foobaz}.each do |name|
+            expect {
+              Metrics.get_metric name
+            }.to raise_error(Appoptics::Metrics::NotFound)
+          end
+
+          %w{foobar bar}.each do |name|
+            Metrics.get_metric name # stil exist
+          end
+        end
+      end
+    end
+
+    describe "#get_metric" do
+      before(:all) do
+        delete_all_metrics
+        Metrics.submit my_counter: {type: :counter, value: 0, measure_time: Time.now.to_i-60}
+        1.upto(2).each do |i|
+          measure_time = Time.now.to_i - (5+i)
+          opts = {measure_time: measure_time, type: :counter}
+          Metrics.submit my_counter: opts.merge(value: i)
+          Metrics.submit my_counter: opts.merge(source: 'baz', value: i+1)
+        end
+      end
+
+      context "without arguments" do
+        it "gets metric attributes" do
+          metric = Metrics.get_metric :my_counter
+          expect(metric['name']).to eq('my_counter')
+          expect(metric['type']).to eq('counter')
+        end
+      end
+
+      context "with a start_time" do
+        it "returns entries since that time" do
+          # 1 hr ago
+          metric = Metrics.get_metric :my_counter, start_time: Time.now-3600
+          data = metric['measurements']
+          expect(data['unassigned'].length).to eq(3)
+          expect(data['baz'].length).to eq(2)
+        end
+      end
+
+      context "with a count limit" do
+        it "returns that number of entries per source" do
+          metric = Metrics.get_metric :my_counter, count: 2
+          data = metric['measurements']
+          expect(data['unassigned'].length).to eq(2)
+          expect(data['baz'].length).to eq(2)
+        end
+      end
+
+      context "with a source limit" do
+        it "only returns that source" do
+          metric = Metrics.get_metric :my_counter, source: 'baz', start_time: Time.now-3600
+          data = metric['measurements']
+          expect(data['baz'].length).to eq(2)
+          expect(data['unassigned']).to be_nil
+        end
+      end
+
+    end
+
+    describe "#metrics" do
+      before(:all) do
+        delete_all_metrics
+        Metrics.submit foo: 123, bar: 345, baz: 678, foo_2: 901
+      end
+
+      context "without arguments" do
+        it "lists all metrics" do
+          metric_names = Metrics.metrics.map { |metric| metric['name'] }
+          expect(metric_names.sort).to eq(%w{foo bar baz foo_2}.sort)
+        end
+      end
+
+      context "with a name argument" do
+        it "lists metrics that match" do
+          metric_names = Metrics.metrics(name: 'foo').map { |metric| metric['name'] }
+          expect(metric_names.sort).to eq(%w{foo foo_2}.sort)
+        end
+      end
+
+    end
+
+    describe "#submit" do
+
+      context "with a gauge" do
+        before(:all) do
+          delete_all_metrics
+          Metrics.submit foo: 123
+        end
+
+        it "creates the metrics" do
+          metric = Metrics.metrics[0]
+          expect(metric['name']).to eq('foo')
+          expect(metric['type']).to eq('gauge')
+        end
+
+        it "stores their data" do
+          data = Metrics.get_measurements :foo, count: 1
+          expect(data).not_to be_empty
+          data['unassigned'][0]['value'] == 123.0
+        end
+      end
+
+      context "with a counter" do
+        before(:all) do
+          delete_all_metrics
+          Metrics.submit bar: {type: :counter, source: 'baz', value: 456}
+        end
+
+        it "creates the metrics" do
+          metric = Metrics.metrics[0]
+          expect(metric['name']).to eq('bar')
+          expect(metric['type']).to eq('counter')
+        end
+
+        it "stores their data" do
+          data = Metrics.get_measurements :bar, count: 1
+          expect(data).not_to be_empty
+          data['baz'][0]['value'] == 456.0
+        end
+      end
+
+      it "does not retain errors" do
+        delete_all_metrics
+        Metrics.submit foo: {type: :counter, value: 12}
+        expect {
+          Metrics.submit foo: 15 # submitting as gauge
+        }.to raise_error(Appoptics::Metrics::ClientError)
+        expect {
+          Metrics.submit foo: {type: :counter, value: 17}
+        }.not_to raise_error
+      end
+
+    end
+
+    describe "#update_metric[s]" do
+
+      context 'with a single metric' do
+        context "with an existing metric" do
+          before do
+            delete_all_metrics
+            Metrics.submit foo: 123
+          end
+
+          it "updates the metric" do
+            Metrics.update_metric :foo, display_name: "Foo Metric",
+                                        period: 15,
+                                        attributes: {
+                                          display_max: 1000
+                                        }
+            foo = Metrics.get_metric :foo
+            expect(foo['display_name']).to eq('Foo Metric')
+            expect(foo['period']).to eq(15)
+            expect(foo['attributes']['display_max']).to eq(1000)
+          end
+        end
+
+        context "without an existing metric" do
+          it "creates the metric if type specified" do
+            delete_all_metrics
+            Metrics.update_metric :foo, display_name: "Foo Metric",
+                                        type: 'gauge',
+                                        period: 15,
+                                        attributes: {
+                                        display_max: 1000
+                                      }
+            foo = Metrics.get_metric :foo
+            expect(foo['display_name']).to eq('Foo Metric')
+            expect(foo['period']).to eq(15)
+            expect(foo['attributes']['display_max']).to eq(1000)
+          end
+
+          it "raises error if no type specified" do
+            delete_all_metrics
+            expect {
+              Metrics.update_metric :foo, display_name: "Foo Metric",
+                                          period: 15,
+                                          attributes: {
+                                            display_max: 1000
+                                          }
+            }.to raise_error(Appoptics::Metrics::ClientError)
+          end
+        end
+
+      end
+
+      context 'with multiple metrics' do
+        before do
+          delete_all_metrics
+          Metrics.submit 'my.1' => 1, 'my.2' => 2, 'my.3' => 3, 'my.4' => 4
+        end
+
+        it "supports named list" do
+          names = ['my.1', 'my.3']
+          Metrics.update_metrics names: names, period: 60
+
+          names.each do |name|
+             metric = Metrics.get_metric name
+             expect(metric['period']).to eq(60)
+           end
+        end
+
+        it "supports patterns" do
+          Metrics.update_metrics names: 'my.*', exclude: ['my.3'],
+            display_max: 100
+
+          %w{my.1 my.2 my.4}.each do |name|
+            metric = Metrics.get_metric name
+            expect(metric['attributes']['display_max']).to eq(100)
+          end
+
+          excluded = Metrics.get_metric 'my.3'
+          expect(excluded['attributes']['display_max']).not_to eq(100)
+        end
+      end
+    end
+
+    describe "Sources API" do
+      before do
+        Metrics.update_source("sources_api_test", display_name: "Sources Api Test")
+      end
+
+      describe "#sources" do
+        it "works" do
+          sources = Metrics.sources
+          expect(sources).to be_an(Array)
+          test_source = sources.detect { |s| s["name"] == "sources_api_test" }
+          expect(test_source["display_name"]).to eq("Sources Api Test")
+        end
+
+        it "allows filtering by name" do
+          sources = Metrics.sources name: 'sources_api_test'
+          expect(sources.all? {|s| s['name'] =~ /sources_api_test/}).to be_truthy
+        end
+      end
+
+      describe "#get_source" do
+        it "works" do
+          test_source = Metrics.get_source("sources_api_test")
+          expect(test_source["display_name"]).to eq("Sources Api Test")
+        end
+      end
+
+      describe "#update_source" do
+        it "updates an existing source" do
+          Metrics.update_source("sources_api_test", display_name: "Updated Source Name")
+
+          test_source = Metrics.get_source("sources_api_test")
+          expect(test_source["display_name"]).to eq("Updated Source Name")
+        end
+
+        it "creates new sources" do
+          source_name = "sources_api_test_#{Time.now.to_f}"
+          expect {
+            no_source = Metrics.get_source(source_name)
+          }.to raise_error(Appoptics::Metrics::NotFound)
+
+          Metrics.update_source(source_name, display_name: "New Source")
+
+          test_source = Metrics.get_source(source_name)
+          expect(test_source).not_to be_nil
+          expect(test_source["display_name"]).to eq("New Source")
+        end
+      end
+
+    end
+
+    describe "#get_series" do
+      before { Metrics.submit test_series: { value: 123, tags: { hostname: "metrics-web-stg-1" } } }
+
+      it "gets series" do
+        series = Metrics.get_series :test_series, resolution: 1, duration: 3600
+
+        expect(series[0]["tags"]["hostname"]).to eq("metrics-web-stg-1")
+        expect(series[0]["measurements"][0]["value"]).to eq(123)
+      end
+    end
+
+  end
+end