copperegg-revealmetrics 0.7.1 → 0.8.0

data/lib/copperegg/revealmetrics/metric_sample.rb

@@ -0,0 +1,26 @@
+module Copperegg
+  module Revealmetrics
+
+    class MetricSample
+      include Copperegg::Revealmetrics::Mixins::Persistence
+
+      resource "samples"
+
+      def self.save(group_name, identifier, timestamp, metric_values)
+        request(:id => group_name, :identifier => identifier, :timestamp => timestamp, :values => metric_values, :request_type => "post")
+      end
+
+      def self.samples(group_name, metrics, starttime=nil, duration=nil, sample_size=nil)
+        metrics = [metrics] unless metrics.is_a?(Array)
+        params = {}
+        params[:starttime] = starttime if starttime
+        params[:duration] = duration if duration
+        params[:sample_size] = sample_size if sample_size
+        params[:queries] = {group_name => [{:metrics => metrics}]}
+
+        request(params.merge(:request_type => "get"))
+      end
+    end
+
+  end
+end

data/lib/copperegg/revealmetrics/mixins/persistence.rb

@@ -0,0 +1,124 @@
+module Copperegg
+  module Revealmetrics
+
+    class ValidationError < Exception;
+    end
+
+    class HttpError < Exception;
+    end
+
+    module Mixins
+      module Persistence
+        def self.included(klass)
+          klass.class_eval do
+            class << self
+              attr_reader :resource_name
+
+              def find(*args)
+                params = args.last.class == Hash ? args.pop : {}
+                id = args.first
+                response = request(params.merge(:request_type => "get", :id => id))
+                if response.code == "200"
+                  json = JSON.parse(response.body)
+                  if json.is_a?(Array)
+                    json.map { |attributes| new(attributes) }
+                  else
+                    new(json)
+                  end
+                end
+              end
+
+              def create(params)
+                params.delete(:id)
+                params.delete("id")
+                new(params).save
+              end
+
+              def delete(id)
+                request(:id => id, :request_type => "delete")
+              end
+
+              def request(params={})
+                request_type = params.delete(:request_type)
+                raise "invalid type `#{request_type}`" if !%w(get post put delete).include?(request_type)
+                id = params.delete(:id)
+
+                uri = id ? URI.parse("#{Api.uri}/#{self.resource_name}/#{id}.json") : URI.parse("#{Api.uri}/#{self.resource_name}.json")
+
+                http = Net::HTTP.new(uri.host, uri.port)
+                http.use_ssl = uri.scheme == 'https'
+                http.verify_mode = OpenSSL::SSL::VERIFY_NONE if !Api.ssl_verify_peer
+
+                request = Net::HTTP.const_get(request_type.capitalize).new(uri.request_uri)
+                request.body = JSON.generate(params) unless params.empty?
+                request.basic_auth(Api.apikey, "U")
+                request["Content-Type"] = "application/json"
+
+                begin
+                  response = http.request(request)
+                rescue Exception => e
+                  raise e
+                end
+
+                response
+              end
+
+              def request_200(params={})
+                response = request(params)
+                unless response.code === "200"
+                  raise HttpError.new("HTTP request failed with code `#{response.code}`: `#{response.body}`")
+                end
+                response
+              end
+
+              private
+
+              def resource(value)
+                @resource_name = value
+              end
+            end
+          end
+        end
+
+        attr_reader :id, :error
+
+        def initialize(attributes={})
+          load_attributes(attributes)
+        end
+
+        def save
+          if valid?
+            response = persisted? ? update : create
+            attributes = JSON.parse(response.body)
+            if response.code != "200"
+              @error = attributes.merge("code" => response.code)
+            else
+              load_attributes(attributes)
+            end
+          else
+            raise ValidationError.new(@error)
+          end
+        end
+
+        def delete
+          self.class.request(:id => @id, :request_type => "delete")
+        end
+
+        def persisted?
+          !@id.nil?
+        end
+
+        private
+
+        def create
+          self.class.request(to_hash.merge(:request_type => "post"))
+        end
+
+        def update
+          self.class.request(to_hash.merge(:id => @id, :request_type => "put"))
+        end
+      end
+    end
+
+  end
+end

data/lib/copperegg/revealmetrics/tag.rb

@@ -0,0 +1,97 @@
+module Copperegg
+  module Revealmetrics
+
+    class Tag
+      include Copperegg::Revealmetrics::Mixins::Persistence
+
+      resource "tags"
+
+      attr_accessor :name, :objects
+
+      def load_attributes(attributes)
+        @objects_original = []
+
+        attributes.each do |name, value|
+          if name.to_s == "id"
+            @id = value
+          elsif !respond_to?("#{name}=")
+            next
+          elsif name.to_s == "objects"
+            @objects = value.map { |object| object["idv"].to_s.gsub(/\|$/, "") }
+            @objects_original = @objects.clone
+          else
+            send "#{name}=", value
+          end
+        end
+      end
+
+      def name
+        @name || @id
+      end
+
+      def valid?
+        @error = nil
+
+        if self.name.nil? || self.name.to_s.strip.empty?
+          @error = "Name can't be blank."
+          return false
+        end
+
+        if self.name.to_s.match(/[^\w-]/)
+          @error = "Name contains invalid characters."
+          return false
+        end
+
+        if self.objects.nil? || self.objects.empty?
+          @error = "You must define at least one object."
+          return false
+        end
+
+        unless self.objects.kind_of?(Array)
+          @error = "Invalid objects field."
+          return false
+        end
+
+        if self.objects.any? { |object| !object.kind_of?(String) }
+          @error = "Invalid object identifier."
+          return false
+        end
+
+        true
+      end
+
+      def delete
+        self.class.request_200({:id => name, :request_type => "delete"})
+      end
+
+      def save
+        unless valid?
+          raise ValidationError.new(@error)
+        end
+
+        remove_objects(@objects_original - @objects)
+        add_objects(@objects - @objects_original)
+        @objects_original = @objects
+      end
+
+      def update
+        save
+      end
+
+      def to_hash
+        {"tag" => name, "ids" => objects}
+      end
+
+      private
+
+      def remove_objects(ids)
+        self.class.request_200({:id => name, :ids => ids, :request_type => "delete"}) unless ids.empty?
+      end
+
+      def add_objects(ids)
+        self.class.request_200({:tag => name, :ids => ids, :request_type => "post"}) unless ids.empty?
+      end
+    end
+
+  end
+end

data/lib/copperegg/revealmetrics/ver.rb

@@ -0,0 +1,7 @@
+module Copperegg
+  module Revealmetrics
+
+    GEM_VERSION = "0.8.0"
+
+  end
+end

data/test/custom_dashboard_test.rb

@@ -1,108 +1,108 @@
 require "test/unit"
-require "copperegg"
+require "copperegg/revealmetrics"
 
 class CustomDashboardTest < Test::Unit::TestCase
 
 	def test_name_accessor_and_setter
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 
 		assert_equal "My Dashboard", dashboard.name
 	end
 
 	def test_save_should_fail_if_name_is_not_set
-		dashboard = CopperEgg::CustomDashboard.new
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_equal "Name can't be blank.", error.message
 	end
 
 	def test_save_should_fail_for_an_invalid_widget_type
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
-		dashboard.data["widgets"]["0"] = {:type => "foo", :style => "value", :match => "tag", :match_param => ["test"], 
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
+		dashboard.data["widgets"]["0"] = {:type => "foo", :style => "value", :match => "tag", :match_param => ["test"],
 																	:metric => {"my_metric_group" => [[0, "metric1"]]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_equal "Invalid widget type foo.", error.message
 	end
 
 	def test_save_should_fail_for_an_invalid_widget_style
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
-		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "foo", :match => "tag", :match_param => ["test"], 
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
+		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "foo", :match => "tag", :match_param => ["test"],
 																	:metric => {"my_metric_group" => [[0, "metric1"]]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_equal "Invalid widget style foo.", error.message
 	end
 
 	def test_save_should_ail_for_an_invalidvwidget_match
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "foo", :match_param => ["test"],
 																	:metric => {"my_metric_group" => [[0, "metric1"]]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_equal "Invalid widget match foo.", error.message
 	end
 
 	def test_save_should_fail_for_a_missing_match_parameter
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "select", :metric => {"my_metric_group" => [[0, "metric1"]]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_equal "Missing match parameter.", error.message
 	end
 
 	def test_save_should_fail_if_metric_is_not_a_hash
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => ["my_metric_group", 0, "metric1"]}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_match /invalid widget metric/i, error.message
 	end
 
 	def test_save_should_fail_if_metric_does_not_contain_an_array
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => "metric1"}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_match /invalid widget metric/i, error.message
 	end
 
 	def test_save_should_fail_if_metric_contains_an_empty_array
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => []}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_match /invalid widget metric/i, error.message
 	end
 
 	def test_save_should_fail_if_metric_contains_an_array_with_invalid_values
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => ["metric1"]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_match /invalid widget metric/i, error.message
 	end
 
 	def test_save_should_fail_if_metric_contains_an_array_with_an_invalid_position
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => [["four", "metric1"]]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_match /invalid widget metric/i, error.message
 	end
 
 	def test_save_should_fail_if_metric_contains_an_array_with_no_metric_name
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => [[0]]}}
 
-		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { dashboard.save }
 		assert_match /invalid widget metric/i, error.message
 	end
 
 	def test_to_hash
-		dashboard = CopperEgg::CustomDashboard.new(:name => "My Dashboard")
+		dashboard = Copperegg::Revealmetrics::CustomDashboard.new(:name => "My Dashboard")
 		dashboard.data["widgets"]["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => [[1, "metric1"]]}}
-		
+
 		assert dashboard.valid?
 
 		hash = dashboard.to_hash

data/test/metric_group_test.rb

@@ -1,44 +1,44 @@
 require "test/unit"
-require "copperegg"
+require "copperegg/revealmetrics"
 
 class MetricGroupTest < Test::Unit::TestCase
 
 	def test_name_accessor_and_setter
-		metric_group = CopperEgg::MetricGroup.new(:name => "my_metric_group")
+		metric_group = Copperegg::Revealmetrics::MetricGroup.new(:name => "my_metric_group")
 
 		assert_equal "my_metric_group", metric_group.name
 	end
 
 	def test_save_should_fail_if_name_is_blank
-		metric_group = CopperEgg::MetricGroup.new
+		metric_group = Copperegg::Revealmetrics::MetricGroup.new
 
-		error = assert_raise(CopperEgg::ValidationError) { metric_group.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { metric_group.save }
 		assert_equal "Name can't be blank.", error.message
 	end
 
 	def test_save_should_fail_if_no_metrics_are_declared
-		metric_group = CopperEgg::MetricGroup.new(:name => "my_metric_group")
+		metric_group = Copperegg::Revealmetrics::MetricGroup.new(:name => "my_metric_group")
 
-		error = assert_raise(CopperEgg::ValidationError) { metric_group.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { metric_group.save }
 		assert_equal "You must define at least one metric.", error.message
 	end
 
 	def test_save_should_fail_if_metrics_include_non_metric
-		metric_group = CopperEgg::MetricGroup.new(:name => "my_metric_group", :metrics => ["metric"])
+		metric_group = Copperegg::Revealmetrics::MetricGroup.new(:name => "my_metric_group", :metrics => ["metric"])
 
-		error = assert_raise(CopperEgg::ValidationError) { metric_group.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { metric_group.save }
 		assert_equal "Metric expected.", error.message
 	end
 
 	def test_save_should_fail_for_invalid_metric
-		metric_group = CopperEgg::MetricGroup.new(:name => "my_metric_group", :metrics => [{:name => "test", :type => "invalid"}])
+		metric_group = Copperegg::Revealmetrics::MetricGroup.new(:name => "my_metric_group", :metrics => [{:name => "test", :type => "invalid"}])
 
-		error = assert_raise(CopperEgg::ValidationError) { metric_group.save }
+		error = assert_raise(Copperegg::Revealmetrics::ValidationError) { metric_group.save }
 		assert_equal "Invalid metric type invalid.", error.message
 	end
 
 	def test_to_hash
-		metric_group = CopperEgg::MetricGroup.new(:name => "test", :label => "Test Metric", :frequency => 5)
+		metric_group = Copperegg::Revealmetrics::MetricGroup.new(:name => "test", :label => "Test Metric", :frequency => 5)
 		metric_group.metrics << {:type => "ce_counter", :name => "metric1", :label => "Metric 1", :unit => "ticks"}
 		metric_group.metrics << {:type => "ce_counter_f", :name => "metric2", :label => "Metric 2"}