copperegg 0.5.3 → 0.6.0.pre

data/Gemfile

@@ -1,4 +1,3 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
-# gems dependencies should be in copperegg.gemspec
-gemspec
+gemspec

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    copperegg (0.5.3.pre2)
-      multi_json (>= 1.3.0)
+    copperegg (0.6.0.pre)
+      json_pure (~> 1.7.6)
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    multi_json (1.5.0)
+    json_pure (1.7.6)
 
 PLATFORMS
   ruby

data/README.md

@@ -1,10 +1,6 @@
 # CopperEgg Gem
-The CopperEgg gem allows programmatic access to the CopperEgg API.  
 
-
-## Usage
-
-### Requirements
+The CopperEgg gem allows programmatic access to the CopperEgg API.
 
 ## Install
 
@@ -17,9 +13,8 @@ $ gem install copperegg-ruby
 To build and install the development branch yourself from the latest source:
 
 ```
-$ git clone git@github.com:copperegg/copperegg-ruby.git
+$ git clone git://github.com/CopperEgg/copperegg-ruby.git -b develop
 $ cd copperegg-ruby
-$ git checkout develop
 $ gem build copperegg.gemspec
 $ gem install copperegg-{version}.gem
 ```
@@ -31,49 +26,104 @@ $ gem install copperegg-{version}.gem
 ``` ruby
 require 'rubygems' # not necessary with ruby 1.9 but included for completeness
 require 'copperegg'
-
-# Get a Metrics object:
-apikey = 'sdf87xxxxxxxxxxxxxxxxxxxxx' # from the web UI
-metrics = CopperEgg::Metrics.new(apikey)
+CopperEgg::Api.apikey = "sdf87xxxxxxxxxxxxxxxxxxxxx" # from the web UI
 ```
 
-### Get a metrics group:
+### Get a metric group:
 
 ``` ruby
-group_name = "my_new_metrics_group"
-mg = metrics.metric_group(group_name)
+metric_group = CopperEgg::MetricGroup.find("my_metric_group")
+metric_group.name
+# => "my_metric_group"
+metric_group.label
+# => "My Metric Group"
+metric_group.metrics
+# => [#<CopperEgg::MetricGroup::Metric:0x007fb43aab2570 @position=0, @type="ce_gauge", @name="metric1", @label="Metric 1", @unit="b">]
 ```
 
 ### Create a metric group:
 
 ``` ruby
-  group_name = "this_is_a_new_group"
-  groupcfg = {}
-  groupcfg["name"] = group_name
-  groupcfg["label"] = "Cool New Group Visible Name"
-  groupcfg["frequency"] = "60"  # data is sent every 60s
-  groupcfg["metrics"] = [{"type"=>"ce_gauge",   "name"=>"active_connections",     "unit"=>"Connections"},
-                         {"type"=>"ce_gauge",   "name"=>"connections_accepts",    "unit"=>"Connections"},
-                         {"type"=>"ce_gauge",   "name"=>"connections_handled",    "unit"=>"Connections"},
-                         {"type"=>"ce_gauge",   "name"=>"connections_requested",  "unit"=>"Connections"},
-                         {"type"=>"ce_gauge",   "name"=>"reading",                "unit"=>"Connections"},
-                         {"type"=>"ce_gauge",   "name"=>"writing",                "unit"=>"Connections"},
-                         {"type"=>"ce_gauge",   "name"=>"waiting",                "unit"=>"Connections"}
-                       ]
-
-  res = metrics.create_metric_group(group_name, groupcfg)
+metric_group = CopperEgg::MetricGroup.new(:name => "my_new_metric_group", :label => "Cool New Group Visible Name", :frequency => 60) # data is sent every 60 seconds
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"active_connections",     "unit"=>"Connections"}
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"connections_accepts",    "unit"=>"Connections"}
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"connections_handled",    "unit"=>"Connections"}
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"connections_requested",  "unit"=>"Connections"}
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"reading",                "unit"=>"Connections"}
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"writing",                "unit"=>"Connections"}
+metric_group.metrics << {"type"=>"ce_gauge",   "name"=>"waiting",                "unit"=>"Connections"}
+metric_group.save
 ```
 
-## Questions / Problems?
+### Post samples for a metric group
+
+```ruby
+CopperEgg::MetricSample.save(metric_group.name, "custom_identifier1", Time.now.to_i, "active_connections" => 2601, "connections_accepts" => 154, "connections_handled" => 128, "connections_requested" => 1342, ...)
+```
+
+### Get samples
+
+```ruby
+# Get the most recent samples for a single metric
+CopperEgg::MetricSample.samples(metric_group.name, "connections_accepts")
+
+# Get the most recent samples for multiple metrics
+CopperEgg::MetricSample.samples(metric_group.name, ["connections_accepts", "connections_handled", "reading", "writing"])
+
+# Specify a start time and duration
+CopperEgg::MetricSample.samples(metric_group.name, ["connections_accepts", "connections_handled", "reading", "writing"], :starttime => 4.hours.ago, :duration => 15.minutes)
+```
+
+The raw JSON response is returned as specified in the [API docs][sample_docs].
+
+### Create a dashboard from a metric group
+
+By default, the dashboard created will be named "_MetricGroupLabel_ Dashboard" and will have one timeline widget per metric matching all sources.
+
+```ruby
+# Creates a dashboard named "My Metric Group Dashboard"
+CopperEgg::CustomDashboard.create(metric_group)
+```
 
+You can pass an option to specify the name of the dashboard.
+
+```ruby
+ CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers")
+```
+
+If a single identifier is specified, the dashboard will be created having one value widget per metric matching the single identifier.
+
+```ruby
+ CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => "custom_identifier1")
+```
+
+If an array of identifiers is specified, the dashboard will be created having one timeline widget per metric matching each identifier.
+
+```ruby
+ CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => ["custom_identifier1", "custom_identifier2"])
+```
+
+You can limit the widgets created by metic.
+
+```ruby
+ CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => ["custom_identifier1", "custom_identifier2"], :metrics => ["reading", "writing", "waiting"])
+```
+
+### Get a dashboard
+
+```ruby
+ CopperEgg::CustomDashboard.find_by_name("My Metric Group Dashboard")
+```
+
+## Questions / Problems?
 
-There are more detailed examples in the included [examples][examples]
-directory.
+There are more detailed examples in the [test classes][test_classes].
 
 Full [API docs][docs] are available.
 
-[examples]:https://github.com/copperegg/copperegg-ruby/blob/master/examples
+[sample_docs]:http://dev.copperegg.com/revealmetrics/samples.html
+[test_classes]:https://github.com/copperegg/copperegg-ruby/tree/feature/ares/test
 [docs]:http://dev.copperegg.com
 
 ## Copyright
-Copyright 2012 CopperEgg - See LICENSE for details.
+Copyright 2013 CopperEgg.

data/copperegg.gemspec

@@ -1,26 +1,23 @@
 require './lib/copperegg/ver'
 
 Gem::Specification.new do |s|
-  s.name = 'copperegg'
+  s.name    = 'copperegg'
   s.version = CopperEgg::GEM_VERSION
-  s.author = 'Eric Anderson'
-  s.email = 'anderson@copperegg.com'
+  s.author  = 'Eric Anderson'
+  s.email   = 'anderson@copperegg.com'
 
   s.description = 'Library for using the CopperEgg REST API'
-  s.summary = 'Library for using the CopperEgg REST API'
-  s.homepage = 'http://github.com/copperegg/copperegg-ruby'
-  s.license = '???'
+  s.summary   = 'Library for using the CopperEgg REST API'
+  s.homepage  = 'http://github.com/copperegg/copperegg-ruby'
+  s.license   = '???'
 
   s.platform = Gem::Platform::RUBY
   s.require_paths = %w[lib]
   s.files         = Dir["#{File.dirname(__FILE__)}/**/*"]
   s.test_files    = Dir.glob("{test,spec,features}/*")
-  s.executables = Dir.glob("bin/*")
-  s.add_dependency('multi_json', '>= 1.3.0')
-  #...
+  s.executables   = Dir.glob("bin/*")
 
-  #s.add_development_dependency 'rake',    '~> 0.9.0'
+  s.add_dependency('json_pure', '~> 1.7.6')
 
-  #s.extra_rdoc_files = ['README.md', 'LICENSE']
   s.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'copperegg-ruby', '--main', 'README.md']
 end

data/lib/copperegg.rb

@@ -1,17 +1,12 @@
-require 'copperegg/metrics'
-require 'copperegg/util'
-require 'net/http'
-require 'net/https'
-require 'uri'
-
-  API_VERSION = 'v2'
-  DEFAULTS = {
-      :apihost => 'https://api.copperegg.com',
-      :ssl_verify_peer => false,
-      #:ssl_ca_file => File.dirname(__FILE__) + '/../../../conf/cacert.pem',
-      :timeout => 10
-    }
+require "net/http"
+require "net/https"
+require "uri"
+require "json/pure"
+require File.dirname(__FILE__) + "/copperegg/mixins/persistence"
+require File.dirname(__FILE__) + "/copperegg/metric_group"
+require File.dirname(__FILE__) + "/copperegg/custom_dashboard"
+require File.dirname(__FILE__) + "/copperegg/metric_sample"
+require File.dirname(__FILE__) + "/copperegg/api"
 
 module CopperEgg
-
 end

data/lib/copperegg/api.rb

@@ -0,0 +1,26 @@
+module CopperEgg
+	class Api
+		class << self
+			attr_accessor :apikey
+			attr_reader :ssl_verify_peer, :timeout
+
+			@uri = "https://api.copperegg.com/v2/revealmetrics/"
+
+			def host=(host)
+				@uri = "#{host}/v2/revealmetrics/"
+			end
+
+			def uri
+				@uri
+			end
+
+			def ssl_verify_peer=(boolean)
+				@ssl_verify_peer = boolean ? true : false
+			end
+
+			def timeout=(seconds)
+				@timeout = seconds.to_i
+			end
+		end
+	end
+end

data/lib/copperegg/custom_dashboard.rb

@@ -0,0 +1,140 @@
+module CopperEgg
+	class CustomDashboard
+		include CopperEgg::Mixins::Persistence
+
+		WIDGET_TYPES 		= %w(metric metric_list timeline)
+		WIDGET_STYLES 	= %w(value timeline both list values)
+		WIDGET_MATCHES	= %w(select multi tag all)
+	
+		resource "dashboards"
+
+		attr_accessor :name, :label, :data
+
+		def initialize(attributes={})
+			load_attributes(attributes)
+		end
+
+		def load_attributes(attributes)
+			@data = {"widgets" => {}, "order" => []}
+			attributes.each do |name, value|
+				if name.to_s == "id"
+					@id = value
+				elsif name.to_s == "data"
+					attributes[name].each do |data_name, data_value|
+						if data_name.to_s == "order"
+							data["order"] = data_value
+						else
+							data["widgets"] = data_value
+						end
+					end
+				elsif !respond_to?("#{name}=")
+					next
+				else
+					send "#{name}=", value
+				end
+			end
+		end
+
+		def valid?
+			@error = nil
+			if self.name.nil? || self.name.to_s.strip.empty?
+				@error = "Name can't be blank."
+			else
+				self.data["widgets"].values.each do |widget|
+					widget.each do |key, value|
+						if key.to_s == "type" && !WIDGET_TYPES.include?(value)
+							@error = "Invalid widget type #{value}."
+						elsif key.to_s == "style" && !WIDGET_STYLES.include?(value)
+							@error = "Invalid widget style #{value}."
+						elsif key.to_s == "match" && !WIDGET_MATCHES.include?(value)
+							@error = "Invalid widget match #{value}."
+						elsif key.to_s == "metric" && (!value.is_a?(Hash) || value.keys.size == 0)
+							@error = "Invalid widget metric. #{value}"
+						elsif key.to_s == "match_param" && (widget["match"] || widget[:match]) != "all" && (value.nil? || value.to_s.strip.empty?)
+							@error = "Missing match parameter."
+						else
+							(widget["metric"] || widget[:metric]).each do |metric_group_name, metric_group_value|
+								if !metric_group_value.is_a?(Array)
+									@error = "Invalid widget metric. #{metric_group_value}"
+								elsif metric_group_value.length == 0
+									@error = "Invalid widget metric. #{metric_group_value}"
+								else
+									metric_group_value.each do |metric_data|
+										if !metric_data.is_a?(Array)
+											@error = "Invalid widget metric. #{metric_group_value}"
+										elsif metric_data.length < 2
+											@error = "Invalid widget metric. #{metric_group_value}"
+										elsif (/^\d+$/ =~ metric_data.first.to_s).nil?
+											@error = "Invalid widget metric. #{metric_group_value}"
+										end
+									end
+								end
+							end
+						end
+					end
+					break if !@error.nil?
+				end
+			end
+			@error.nil?
+		end
+
+		def to_hash
+			set_data_order
+			self.instance_variables.reduce({}) do |memo, variable|
+				unless variable.to_s == "@error"
+					value = instance_variable_get(variable)
+					memo[variable.to_s.sub("@","")] = value
+				end
+				memo
+			end
+		end
+
+		class <<self
+			def create(*args)
+				options = args.last.class == Hash ? args.pop : {}
+
+				return super(args.first) if args.first.is_a?(Hash)
+
+				metric_group = args.first
+				raise ArgumentError.new("CopperEgg::MetricGroup object expected") if !metric_group.is_a?(MetricGroup)
+				raise ArgumentError.new("Invalid metric group") if !metric_group.valid?
+
+				metrics 			= filter_metrics(metric_group, options[:metrics]).map { |name| metric_group.metrics.find {|metric| metric.name == name} }
+				identifiers 	= options[:identifiers].is_a?(Array) ? (options[:identifiers].empty? ? nil : options[:identifiers]) : (options[:identifier] ? [options[:identifiers]] : nil)
+				widget_match 	= identifiers.nil? ? "all" : (identifiers.size == 1 ? "select" : "multi")
+				widget_type 	= widget_match == "select" ? "metric" : "timeline"
+				widget_style 	= widget_type == "metric" ? "both" : "values"
+				name 					= options[:name] || "#{metric_group.label} Dashboard"
+
+				dashboard = new(:name => name)
+				metrics.each.with_index do |metric, i|
+					metric_data = [metric.position, metric.name]
+					metric_data.push("rate") if metric.type == "ce_counter" || metric.type == "ce_counter_f"
+					widget = {:type => widget_type, :style => widget_style, :match => widget_match, :metric => {metric_group.name => [metric_data]}}
+					widget[:match_param] = identifiers if identifiers
+					dashboard.data["widgets"][i.to_s] = widget
+				end
+				dashboard.save
+				dashboard
+			end
+
+			def find_by_name(name)
+				find.detect {|dashboard| dashboard.name == name}
+			end
+
+			private
+
+			def filter_metrics(metric_group, specified_metrics)
+				metrics = metric_group.metrics.map(&:name)
+				specified_metrics = specified_metrics.is_a?(Array) ? specified_metrics & metrics : (specified_metrics ? [specified_metrics] & metrics : [])
+				specified_metrics.empty? ? metrics : specified_metrics
+			end
+		end
+
+		private
+
+		def set_data_order
+  		@data["order"] = @data["widgets"].keys if @data["order"].empty?
+  	end
+	end
+end

data/lib/copperegg/metric_group.rb

@@ -0,0 +1,108 @@
+module CopperEgg
+	class MetricGroup
+		include CopperEgg::Mixins::Persistence
+		
+		resource "metric_groups"
+
+		attr_accessor :name, :label, :frequency, :metrics
+
+		def initialize(attributes={})
+			load_attributes(attributes)
+		end
+
+		def load_attributes(attributes)
+			@metrics = []
+			attributes.each do |name, value|
+				if name.to_s == "id"
+					@id = value
+				elsif !respond_to?("#{name}=")
+					next
+				elsif value.to_s == "metrics"
+					@metrics = value.map {|v| Metric.new(v)}
+				else
+					send "#{name}=", value
+				end
+			end
+		end
+
+		def to_hash
+			self.instance_variables.reduce({}) do |memo, variable|
+				value = instance_variable_get(variable)
+				if variable.to_s == "@metrics"
+					memo[variable.to_s.sub("@","")] = value.map(&:to_hash)
+				elsif variable.to_s != "@error"
+					memo[variable.to_s.sub("@","")] = value
+				end
+				memo
+			end
+		end
+
+	  def valid?
+	  	@error = nil
+	  	if self.name.nil? || self.name.to_s.strip.empty?
+	  		@error = "Name can't be blank."
+	  	elsif self.metrics.nil? || self.metrics.empty?
+	  		@error = "You must define at least one metric."
+	  	else
+	  		self.metrics = self.metrics.map {|metric| metric.is_a?(Hash) ? Metric.new(metric) : metric}
+		  	self.metrics.each do |metric|
+		  		if !metric.is_a?(Metric)
+		  			@error = "Metric expected."
+		  			break
+		  		elsif !metric.valid?
+		  			@error = metric.error
+		  			break
+		  		else
+		  			metric.send(:remove_instance_variable, :@position) if (metric.instance_variables.include?(:@position) || metric.instance_variables.include?("@position")) && !self.persisted?
+		  		end
+		  	end
+		  end
+		  @error.nil?
+	  end
+
+	  class Metric
+	  	TYPES = %w(ce_gauge ce_gauge_f ce_counter ce_counter_f)
+
+			attr_accessor :name, :label, :type, :unit
+			attr_reader :error, :position
+
+			def initialize(attributes={})
+				attributes.each do |name, value|
+					if name.to_s == "position"
+						@position = value
+					elsif !respond_to?("#{name}=")
+						next
+					else
+						send "#{name}=", value
+					end
+				end
+			end
+
+			def to_hash
+				self.instance_variables.reduce({}) do |memo, variable|
+					if variable.to_s != "@error"
+						value = instance_variable_get(variable)
+						memo[variable.to_s.sub("@","")] = value
+					end
+					memo
+				end
+			end
+
+			def valid?
+				valid = false
+				@error = nil
+				if self.name.nil? || self.name.to_s.strip.empty?
+					@error = "Metric name cannot be blank."
+				elsif self.type.nil? || self.type.to_s.strip.empty?
+					@error = "Metric type must be defined."
+				elsif !TYPES.include?(self.type)
+					return "Invalid metric type #{self.type}."
+				else
+					valid = true
+					remove_instance_variable(:@error)
+				end
+				valid
+			end
+	  end
+	end
+end

data/lib/copperegg/metric_sample.rb

@@ -0,0 +1,22 @@
+module CopperEgg
+  class MetricSample
+    include CopperEgg::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

data/lib/copperegg/mixins/persistence.rb

@@ -0,0 +1,106 @@
+module CopperEgg
+	class ValidationError < 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 && response.is_a?(Array)
+								response.map {|resp| new(resp)}
+							elsif response
+								new(response)
+							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" 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"
+
+				      connect_try_count = 0
+				      response = nil
+				      begin
+				        response = http.request(request)
+				      rescue Exception => e
+				        connect_try_count += 1
+				        if connect_try_count > 1
+				          log "#{e.inspect}"
+				          raise e
+				        end
+				        sleep 0.5
+				        retry
+				      end
+
+				      return nil if response.nil? || response.code != "200" || response.body.nil? || response.body.strip.empty?
+
+				      JSON.parse(response.body)
+						end
+
+						private
+
+						def resource(value)
+							@resource_name = value
+						end
+					end
+				end
+			end
+
+			attr_reader :id
+
+			def save
+				if valid?
+					attributes = persisted? ? update : create
+					load_attributes(attributes)
+				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

data/lib/copperegg/ver.rb

@@ -1,3 +1,3 @@
 module CopperEgg
-  GEM_VERSION = '0.5.3'
+  GEM_VERSION = '0.6.0.pre'
 end

data/test/custom_dashboard_test.rb

@@ -0,0 +1,139 @@
+require "test/unit"
+require "copperegg"
+
+class CustomDashboardTest < Test::Unit::TestCase
+
+	def test_name_accessor_and_setter
+		dashboard = CopperEgg::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
+
+		error = assert_raise(CopperEgg::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"], 
+																	:metric => {"my_metric_group" => [[0, "metric1"]]}}
+
+		error = assert_raise(CopperEgg::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"], 
+																	:metric => {"my_metric_group" => [[0, "metric1"]]}}
+
+		error = assert_raise(CopperEgg::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.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 }
+		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.data.widgets["0"] = {:type => "metric", :style => "value", :match => "select", :metric => {"my_metric_group" => [[0, "metric1"]]}}
+
+		error = assert_raise(CopperEgg::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.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 }
+		assert_equal "Invalid widget metric.", error.message
+	end
+
+	def test_save_should_fail_if_metric_does_not_contain_an_array
+		dashboard = CopperEgg::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 }
+		assert_equal "Invalid widget metric.", error.message
+	end
+
+	def test_save_should_fail_if_metric_contains_an_empty_array
+		dashboard = CopperEgg::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 }
+		assert_equal "Invalid widget metric.", error.message
+	end
+
+	def test_save_should_fail_if_metric_contains_an_array_with_invalid_values
+		dashboard = CopperEgg::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 }
+		assert_equal "Invalid widget metric.", 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.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 }
+		assert_equal "Invalid widget metric.", 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.data.widgets["0"] = {:type => "metric", :style => "value", :match => "tag", :match_param => ["test"], :metric => {"my_metric_group" => [[0]]}}
+
+		error = assert_raise(CopperEgg::ValidationError) { dashboard.save }
+		assert_equal "Invalid widget metric.", error.message
+	end
+
+	# def test_save_should_save_a_valid_dashboard
+	# 	CopperEgg::Api.apikey = "testapikey"
+
+	# 	request_headers = {
+	# 	  'Authorization' => "Basic #{Base64.encode64("testapikey:").gsub("\n",'')}",
+	# 	  'Content-Type'  => 'application/json'
+	# 	}
+
+	# 	response_body = {:id => 1, :name => "My Dashboard", :data => {:widgets => [{:type => "metric", :style => "value", :match => "tag", :match_param => ["test"]}]},
+	# 																																:order => ["0"]}
+	  
+	#   ActiveResource::HttpMock.respond_to do |mock|
+	#     mock.post "/v2/revealmetrics/dashboards.json", request_headers, {}, 200
+	#   end
+
+	# 	dashboard = CopperEgg::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.save
+	# end
+
+	def test_to_hash
+		dashboard = CopperEgg::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
+
+		assert_equal "My Dashboard", hash["name"]
+		assert_equal "metric", hash["data"]["widgets"]["0"]["type"]
+		assert_equal "value", hash["data"]["widgets"]["0"]["style"]
+		assert_equal "tag", hash["data"]["widgets"]["0"]["match"]
+		assert_equal ["test"], hash["data"]["widgets"]["0"]["match_param"]
+		assert_equal [[1, "metric1"]], hash["data"]["widgets"]["0"]["metric"]["my_metric_group"]
+	end
+
+end

data/test/metric_group_test.rb

@@ -0,0 +1,82 @@
+require "test/unit"
+require "copperegg"
+
+class MetricGroupTest < Test::Unit::TestCase
+
+	def test_name_accessor_and_setter
+		metric_group = CopperEgg::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
+
+		error = assert_raise(CopperEgg::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")
+
+		error = assert_raise(CopperEgg::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"])
+
+		error = assert_raise(CopperEgg::ValidationError) { metric_group.save }
+		assert_equal "Metric expected.", error.message
+	end
+
+	def test_save_should_fail_for_invalid_metrics
+		metric_group = CopperEgg::MetricGroup.new(:name => "my_metric_group", :metrics => [{:name => "test", :type => "invalid"}])
+
+		error = assert_raise(CopperEgg::ValidationError) { metric_group.save }
+		assert_equal "Invalid metric type invalid.", error.message
+	end
+
+	# def test_save_should_retrieve_versioned_name_of_metric_group
+	# 	CopperEgg::Api.apikey = "testapikey"
+
+	# 	request_headers = {
+	# 	  'Authorization' => "Basic #{Base64.encode64("testapikey:").gsub("\n",'')}",
+	# 	  'Content-Type'  => 'application/json'
+	# 	}
+	# 	response_body = {:id => "test_v2", :name => "test_v2", :label => "Test", :frequency => 5, :metrics => [{:name => "test", :type => "ce_counter", :position => 0}]}
+	  
+	#   ActiveResource::HttpMock.respond_to do |mock|
+	#     mock.post "/v2/revealmetrics/metric_groups.json", request_headers, response_body.to_json, 200
+	#   end
+
+	# 	metric_group = CopperEgg::MetricGroup.new(:name => "test", :frequency => 5, :metrics => [{:name => "test", :type => "ce_counter"}])
+
+	# 	metric_group.save
+
+	# 	assert_equal "test_v2", metric_group.id
+	# 	assert_equal "test_v2", metric_group.name
+	# end
+
+	def test_to_hash
+		metric_group = CopperEgg::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"}
+
+		assert metric_group.valid?
+		hash = metric_group.to_hash
+
+		assert_nil hash["id"]
+		assert_equal "test", hash["name"]
+		assert_equal "Test Metric", hash["label"]
+		assert_equal 5, hash["frequency"]
+		assert_equal "ce_counter", hash["metrics"].first["type"]
+		assert_equal "metric1", hash["metrics"].first["name"]
+		assert_equal "Metric 1", hash["metrics"].first["label"]
+		assert_equal "ticks", hash["metrics"].first["unit"]
+		assert_equal "ce_counter_f", hash["metrics"].last["type"]
+		assert_equal "metric2", hash["metrics"].last["name"]
+		assert_equal "Metric 2", hash["metrics"].last["label"]
+	end
+
+end

data/test/metric_sample_test.rb

@@ -0,0 +1,36 @@
+require "test/unit"
+require "copperegg"
+
+class MetricSampleTest < Test::Unit::TestCase
+
+	# def test_save_should_post_a_sample
+	# 	CopperEgg::Api.apikey = "testapikey"
+	# 	request_headers = {
+	# 	  'Authorization' => "Basic #{Base64.encode64("testapikey:").gsub("\n",'')}",
+	# 	  'Content-Type'  => 'application/json'
+	# 	}
+	  
+	#   ActiveResource::HttpMock.respond_to do |mock|
+	#     mock.post "/v2/revealmetrics/samples//test.json", request_headers, {}, 200
+	#   end
+
+	# 	CopperEgg::MetricSample.save("test", "custom_object", Time.now.to_i, :key1 => "value1", :key2 => "value2")
+	# end
+
+	# def test_samples_should_return_the_json_response_body_upon_success
+	# 	CopperEgg::Api.apikey = "testapikey"
+	# 	request_headers = {
+	# 	  'Authorization' => "Basic #{Base64.encode64("testapikey:").gsub("\n",'')}",
+	# 	  'Accept'  => 'application/json'
+	# 	}
+
+	# 	ActiveResource::HttpMock.respond_to do |mock|
+	# 		queries = {"queries" => {"metric_group" => [{"metrics" => ["metric1"]}]}}.to_param
+			
+	#     mock.get "/v2/revealmetrics/samples.json?#{queries}", request_headers, {"_ts" => Time.now.to_i, "object_count" => 0, "values" => {"metric_group" => []}}.to_json, 200
+	#   end
+
+	#   CopperEgg::MetricSample.samples("metric_group", "metric1")
+	# end
+	
+end

metadata

@@ -1,83 +1,108 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: copperegg
-version: !ruby/object:Gem::Version
-  version: 0.5.3
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  hash: -764821022
+  prerelease: 6
+  segments: 
+  - 0
+  - 6
+  - 0
+  - pre
+  version: 0.6.0.pre
 platform: ruby
-authors:
+authors: 
 - Eric Anderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-11 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-  type: :runtime
+
+date: 2013-01-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json_pure
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.3.0
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 7
+        - 6
+        version: 1.7.6
+  type: :runtime
+  version_requirements: *id001
 description: Library for using the CopperEgg REST API
 email: anderson@copperegg.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
+- ./copperegg.gemspec
 - ./Gemfile
 - ./Gemfile.lock
-- ./LICENSE
-- ./README.md
-- ./Rakefile
-- ./copperegg-0.5.2.1.gem
-- ./copperegg-0.5.2.gem
-- ./copperegg-0.5.3.pre.gem
-- ./copperegg-0.5.3.pre2.gem
-- ./copperegg.gemspec
-- ./examples/example.rb
-- ./lib/copperegg/metrics.rb
-- ./lib/copperegg/util.rb
+- ./lib/copperegg/api.rb
+- ./lib/copperegg/custom_dashboard.rb
+- ./lib/copperegg/metric_group.rb
+- ./lib/copperegg/metric_sample.rb
+- ./lib/copperegg/mixins/persistence.rb
 - ./lib/copperegg/ver.rb
 - ./lib/copperegg.rb
-- ./lib/test/test_copperegg.rb
+- ./LICENSE
+- ./Rakefile
+- ./README.md
+- ./test/custom_dashboard_test.rb
+- ./test/metric_group_test.rb
+- ./test/metric_sample_test.rb
+- test/custom_dashboard_test.rb
+- test/metric_group_test.rb
+- test/metric_sample_test.rb
 homepage: http://github.com/copperegg/copperegg-ruby
-licenses:
+licenses: 
 - ???
 post_install_message: 
-rdoc_options:
+rdoc_options: 
 - --line-numbers
 - --inline-source
 - --title
 - copperegg-ruby
 - --main
 - README.md
-require_paths:
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Library for using the CopperEgg REST API
-test_files: []
+test_files: 
+- test/custom_dashboard_test.rb
+- test/metric_group_test.rb
+- test/metric_sample_test.rb

data/examples/example.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'copperegg'
-require 'redis'
-require 'getoptlong'
-
-apikey = "asdadasdasd"
-
-rm = CopperEgg::Metrics.new(apikey)
-
-puts rm.apikey
-
-metrics = {}
-time = Time.now.to_i
-
-rm.store(metrics, time, "my_group_name")
-
-data = rm.samples(time-300, time, "my_group_name", "metric_foo")
-

data/lib/copperegg/metrics.rb

@@ -1,99 +0,0 @@
-module CopperEgg
-  class Metrics
-
-    attr_accessor :apikey
-
-    def initialize(apikey, apihost=nil)
-      @apikey = apikey
-      @util = CopperEgg::Util.new(@apikey, "revealmetrics", apihost)
-    end
-
-    def store_sample(group_name, identifier, timestamp, metric_data)
-      return if identifier.nil?
-      return if group_name.nil?
-      return if timestamp.nil? || timestamp == 0
-      return if metric_data.nil?
-
-      payload = {}
-      payload["timestamp"] = timestamp
-      payload["identifier"] = identifier
-      payload["values"] = metric_data
-
-      response = @util.make_api_post_request("/samples/#{group_name}.json", @apikey, payload)
-      return
-    end
-
-    def samples(group_name, metricname, starttime=nil, duration=nil, sample_size=nil)
-      return if group_name.nil?
-      return if metricname.nil?
-
-      metric_name = []
-      metrics = {}
-      metric_gid = []
-      query = {}
-      params = {}
-
-      metric_name = [metricname]
-      metrics["metrics"] = metric_name
-      metric_gid = [metrics]
-      query[group_name] = metric_gid
-      params["queries"] = query
-      params["starttime"] = starttime if !starttime.nil?
-      params["duration"] = duration if !duration.nil?
-      params["sample_size"] = sample_size if !sample_size.nil?
-
-      samples = @util.make_api_get_request("/samples.json", @apikey, params)
-      return samples
-    end
-
-    def metric_groups
-      # return an array of metric groups
-      mgroup = @util.make_api_get_request("/metric_groups.json", @apikey, nil)
-      return mgroup
-    end
-
-    def metric_group(group_name)
-      mgroup = @util.make_api_get_request("/metric_groups/#{group_name}.json", @apikey, nil)
-      return mgroup
-    end
-
-    def metric_names(group_name)
-      # return an array of metric names in a metric group
-      mgroup = self.metric_group(group_name)
-      if !mgroup.nil?
-        # go through each and add to array
-
-
-      end
-      puts "NOT YET IMPLEMENTED"
-    end
-
-    def create_metric_group(group_name, group_definition)
-      response = @util.make_api_post_request("/metric_groups.json", @apikey, group_definition)
-    end
-
-    def dashboard(dashboard_name)
-      dashes = @util.make_api_get_request("/dashboards.json", @apikey, nil)
-      return nil if dashes.nil?
-
-#      dashboards = JSON.parse(dashes.body)
-# modified 12-10-2012 ... get returns the body
-      dashboards = JSON.parse(dashes)
-      dashboards.each do |dash|
-        if dash["name"] == dashboard_name
-          return dash
-        end
-      end
-
-      return nil
-    end
-
-    def create_dashboard(dashcfg)
-      response = @util.make_api_post_request("/dashboards.json", @apikey, dashcfg)
-    end
-
-    private
-
-
-  end
-end

data/lib/copperegg/util.rb

@@ -1,80 +0,0 @@
-require 'multi_json'
-
-module CopperEgg
-  class Util
-
-    attr_accessor :apikey
-
-    def initialize(apikey, product, apihost=nil)
-      @apikey = apikey
-      @product = product
-      if apihost
-        @apihost = apihost
-      else
-        @apihost = DEFAULTS[:apihost]
-      end
-    end
-
-    def make_api_get_request(api_cmd, apikey, params)
-      response = make_api_request("get", api_cmd, apikey, params)
-      return response
-    end
-
-    def make_api_post_request(api_cmd, apikey, body)
-      response = make_api_request("post", api_cmd, apikey, body)
-      return response
-    end
-
-    private
-
-    def make_uri(api_cmd)
-      return URI.parse("#{@apihost}/#{API_VERSION}/#{@product}#{api_cmd}")
-    end
-
-    def make_api_request(type, api_cmd, apikey, params)
-      request = nil
-      uri = make_uri(api_cmd)
-      http = Net::HTTP.new(uri.host, uri.port)
-
-      http.use_ssl = uri.scheme == 'https'
-      if !DEFAULTS[:ssl_verify_peer]
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-
-      if type == "get"
-        request = Net::HTTP::Get.new(uri.request_uri)
-        request.body = MultiJson.dump(params)
-      else
-        request = Net::HTTP::Post.new(uri.request_uri)
-        request.body = MultiJson.dump(params)
-      end
-
-      request.basic_auth(apikey, "U")
-      request["Content-Type"] = "application/json"
-
-      connect_try_count = 0
-      response = nil
-      begin
-        response = http.request(request)
-      rescue Exception => e
-        connect_try_count += 1
-        if connect_try_count > 1
-          log "#{e.inspect}"
-          raise e
-        end
-        sleep 0.5
-        retry
-      end
-
-      if response == nil || response.code != "200"
-        return nil
-      end
-      if type == "get"
-        return response.body
-      else
-        return response
-      end
-    end
-
-  end
-end