copperegg-revealmetrics 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6fd0a9c916d336895ea615212e8fdff1c4e62e38
-  data.tar.gz: 64fc8b11e3f72888a3e8f3afbd1e2ac3040d4a06
+  metadata.gz: 9ab876f0e7a6bdf9ea7c22ebbca19da8e231a581
+  data.tar.gz: a726222785b11573ec23ac80f701b1535ad604d1
 SHA512:
-  metadata.gz: 85749a44833212b1ffc7259ac035e5fd200b0c49784ac0f4b3aff7be8320c391dcf6e1294bcae4efc838098d65f618511776757de3d08f463b42ccb2250e6b63
-  data.tar.gz: fd3527fe79c80d13ba37e012d405840561e439c7e64fde985911966d10e887af7e173f243c987ac12b0ba29093cef5106d3ee6682b498ad5ce8bcc99975a727c
+  metadata.gz: 4f941a07e07e7f61b64ae58e177c597f935143e9cd121818d54d5736f9e6dd0c7f3467f77b496ed4e300d3e76eb58012880dfdf200b6e43e7734a9812fc997ea
+  data.tar.gz: 44b0d4aa25f277f5f343529f54743ccb123a1cbc2bd0cf1056c4a3dc9a59dae648e73f2ed878cb12de8b481055ffb725069e2f1415e270e5121ae4c5d9656a74

data/README.md

@@ -13,8 +13,8 @@ gem install copperegg-revealmetrics
 
 Set up your API key:
 ``` ruby
-require 'copperegg'
-CopperEgg::Api.apikey = "sdf87xxxxxxxxxxxxxxxxxxxxx" # from the web UI
+require 'copperegg/revealmetrics'
+Copperegg::Revealmetrics::Api.apikey = "sdf87xxxxxxxxxxxxxxxxxxxxx" # from the web UI
 ```
 
 ## Metric Groups
@@ -22,19 +22,19 @@ CopperEgg::Api.apikey = "sdf87xxxxxxxxxxxxxxxxxxxxx" # from the web UI
 #### Get a metric group:
 
 ``` ruby
-metric_group = CopperEgg::MetricGroup.find("my_metric_group")
+metric_group = Copperegg::Revealmetrics::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">]
+# => [#<Copperegg::Revealmetrics::MetricGroup::Metric:0x007fb43aab2570 @position=0, @type="ce_gauge", @name="metric1", @label="Metric 1", @unit="b">]
 ```
 
 #### Create a metric group:
 
 ``` ruby
-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 = Copperegg::Revealmetrics::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"}
@@ -48,7 +48,7 @@ metric_group.save
 If a metric group by the same name already exists, that one will rather than creating a new one. In addition, if the metric group was previously removed it will be restored.
 
 ```ruby
-metric_group2 = CopperEgg::MetricGroup.new(:name => "my_new_metric_group", :label => "New Group Version 2", :frequency => 60)
+metric_group2 = Copperegg::Revealmetrics::MetricGroup.new(:name => "my_new_metric_group", :label => "New Group Version 2", :frequency => 60)
 metric_group2.metrics << {"type"=>"ce_counter", "name"=>"active_connections", "unit"=>"Connections"}
 metric_group2.save # this will perform an update to change the type of the metric 'active_connections' from 'ce_gauge' to 'ce_counter'
 
@@ -86,20 +86,20 @@ metric_group.delete
 #### 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, ...)
+Copperegg::Revealmetrics::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")
+Copperegg::Revealmetrics::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"])
+Copperegg::Revealmetrics::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)
+Copperegg::Revealmetrics::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].
@@ -112,37 +112,37 @@ By default, the dashboard created will be named "_MetricGroupLabel_ Dashboard" a
 
 ```ruby
 # Creates a dashboard named "My Metric Group Dashboard"
-dashboard = CopperEgg::CustomDashboard.create(metric_group)
+dashboard = Copperegg::Revealmetrics::CustomDashboard.create(metric_group)
 ```
 
 You can pass an option to specify the name of the dashboard.
 
 ```ruby
-dashboard = CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers")
+dashboard = Copperegg::Revealmetrics::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
-dashboard = CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => "custom_identifier1")
+dashboard = Copperegg::Revealmetrics::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
-dashboard = CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => ["custom_identifier1", "custom_identifier2"])
+dashboard = Copperegg::Revealmetrics::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => ["custom_identifier1", "custom_identifier2"])
 ```
 
 You can limit the widgets created by metric.
 
 ```ruby
-dashboard = CopperEgg::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => ["custom_identifier1", "custom_identifier2"], :metrics => ["reading", "writing", "waiting"])
+dashboard = Copperegg::Revealmetrics::CustomDashboard.create(metric_group, :name => "Cloud Servers", :identifiers => ["custom_identifier1", "custom_identifier2"], :metrics => ["reading", "writing", "waiting"])
 ```
 
 #### Get a dashboard
 
 ```ruby
-dashboard = CopperEgg::CustomDashboard.find_by_name("My Metric Group Dashboard")
+dashboard = Copperegg::Revealmetrics::CustomDashboard.find_by_name("My Metric Group Dashboard")
 ```
 
 #### Delete a dashboard
@@ -158,14 +158,14 @@ dashboard.delete
 #### Get all or specific tags
 
 ```ruby
-tags_list = CopperEgg::Tag.find
-tag = CopperEgg::Tag.find_by_name("my-tag")
+tags_list = Copperegg::Revealmetrics::Tag.find
+tag = Copperegg::Revealmetrics::Tag.find_by_name("my-tag")
 ```
 
 #### Create a tag
 
 ```ruby
-tag = CopperEgg::Tag.new({:name => "my-tag"})
+tag = Copperegg::Revealmetrics::Tag.new({:name => "my-tag"})
 tag.objects = ["object-identifier-1", "object-identifier-2"]
 tag.save
 ```

data/lib/copperegg/revealmetrics.rb

@@ -0,0 +1,17 @@
+require "net/http"
+require "net/https"
+require "uri"
+require "json/pure"
+
+require "copperegg/revealmetrics/mixins/persistence"
+require "copperegg/revealmetrics/metric_group"
+require "copperegg/revealmetrics/custom_dashboard"
+require "copperegg/revealmetrics/metric_sample"
+require "copperegg/revealmetrics/tag"
+require "copperegg/revealmetrics/api"
+
+module Copperegg
+  module Revealmetrics
+
+  end
+end

data/lib/copperegg/revealmetrics/api.rb

@@ -0,0 +1,28 @@
+module Copperegg
+  module Revealmetrics
+
+    class Api
+      class << self
+        attr_accessor :apikey
+        attr_reader :ssl_verify_peer, :timeout
+
+        def host=(host)
+          @uri = URI.join(host, "/v2/revealmetrics/").to_s
+        end
+
+        def uri
+          @uri || "https://api.copperegg.com/v2/revealmetrics/"
+        end
+
+        def ssl_verify_peer=(boolean)
+          @ssl_verify_peer = boolean ? true : false
+        end
+
+        def timeout=(seconds)
+          @timeout = seconds.to_i
+        end
+      end
+    end
+
+  end
+end

data/lib/copperegg/revealmetrics/custom_dashboard.rb

@@ -0,0 +1,142 @@
+module Copperegg
+  module Revealmetrics
+
+    class CustomDashboard
+      include Copperegg::Revealmetrics::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 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}"
+              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
+            match_param = widget["match_param"] || widget[:match_param]
+            if (widget["match"] || widget[:match]) != "all" && (match_param.nil? || match_param.to_s.strip.empty?)
+              @error = "Missing match parameter."
+            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::Revealmetrics::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
+end

data/lib/copperegg/revealmetrics/metric_group.rb

@@ -0,0 +1,127 @@
+module Copperegg
+  module Revealmetrics
+
+    class MetricGroup
+      include Copperegg::Revealmetrics::Mixins::Persistence
+
+      resource "metric_groups"
+
+      attr_accessor :name, :label, :frequency, :metrics
+
+      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
+
+      private
+
+      def create
+        response = self.class.request(:request_type => "get", :id => self.name, :show_hidden => true)
+        if response.code == "200"
+          json = JSON.parse(response.body)
+          metric_group = self.class.new(json)
+          @id = self.name
+          # needs_update = self.label != metric_group.label || self.frequency != metric_group.frequency || self.metrics.length != metric_group.metrics.length || self.metrics.map(&:name).sort != metric_group.metrics.map {|m| m["name"]}.sort
+          if true #needs_update
+            self.class.request(self.to_hash.merge(:id => @id, :is_hidden => 0, :request_type => "put", :show_hidden => true))
+          else
+            response
+          end
+        else
+          self.class.request(self.to_hash.merge(:request_type => "post"))
+        end
+      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)
+            @error = "Invalid metric type #{self.type}."
+          else
+            valid = true
+            remove_instance_variable(:@error)
+          end
+          valid
+        end
+      end
+    end
+
+  end
+end