slate 0.0.1 → 0.0.2

data/README.md

@@ -1,5 +1,6 @@
 # Slate
 [![Build Status](https://secure.travis-ci.org/trobrock/slate.png)](http://travis-ci.org/trobrock/slate)
+[![Dependency Status](https://gemnasium.com/trobrock/slate.png)](https://gemnasium.com/trobrock/slate)
 
 Simple wrapper to the Graphite render api
 

data/lib/slate.rb

@@ -1,6 +1,7 @@
 require "slate/version"
 require "slate/configuration"
-require "slate/render"
+require "slate/target"
+require "slate/graph"
 require "slate/calculation"
 
 require "slate/calculation/mean"

data/lib/slate/graph.rb

@@ -0,0 +1,43 @@
+require 'cgi'
+require 'rest_client'
+
+module Slate
+  class Graph
+    def initialize(options={})
+      @from    = options[:from]
+      @until   = options[:until]
+    end
+
+    def <<(target)
+      @target = target
+    end
+
+    def url(format=:png)
+      options = url_options.push(["format", format.to_s])
+      "#{Configuration.instance.endpoint}/render?#{params(options)}"
+    end
+
+    def download(format=:png)
+      RestClient.get url(format)
+    end
+
+    private
+
+    def url_options
+      options = []
+      options << ["target", @target.to_s]
+      options << ["from", @from]   if @from
+      options << ["until", @until] if @until
+
+      options
+    end
+
+    def params(options={})
+      options.map do |param|
+        key   = param.first
+        value = param.last
+        "#{CGI.escape(key)}=#{CGI.escape(value)}"
+      end.join("&")
+    end
+  end
+end

data/lib/slate/target.rb

@@ -0,0 +1,56 @@
+# TODO: Tests
+module Slate
+  class Target
+    def self.build(metric, &block)
+      target = new(metric)
+      yield target if block_given?
+      target
+    end
+
+    def initialize(metric)
+      @metric    = metric
+      @functions = []
+    end
+
+    def to_s
+      target = @metric
+      @functions.each do |function|
+        if function.is_a? Symbol
+          target = %Q{#{function}(#{target})}
+        else
+          args = arguments(function.last).join(",")
+          target = %Q{#{function.first}(#{target},#{args})}
+        end
+      end
+
+      target
+    end
+
+    def add_function(*function)
+      if function.size > 1
+        arguments = function[1..-1]
+        @functions << [function.first.to_sym, arguments]
+      else
+        @functions << function.first.to_sym
+      end
+
+      to_s
+    end
+
+    private
+
+    def arguments(args=[])
+      args.map do |arg|
+        if arg.is_a?(Numeric)
+          arg.to_s
+        elsif arg.is_a?(Slate::Graph)
+          arg.send(:target)
+        elsif arg.is_a? Slate::Target
+          arg.to_s
+        else
+          %Q{"#{arg}"}
+        end
+      end
+    end
+  end
+end

data/lib/slate/version.rb

@@ -1,3 +1,3 @@
 module Slate
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/slate/calculation/mean_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
 describe Slate::Calculation::Mean do
   before do
-    @graph = Slate::Render.new(:target => "some.stat")
+    @graph = Slate::Graph.new(:target => "some.stat")
     data = [
       {
         "target" => "some.stat",

data/spec/slate/{render_spec.rb → graph_spec.rb}

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
-describe Slate::Render do
+describe Slate::Graph do
   before(:each) do
     Slate.configure { |c| c.endpoint = "http://graphite" }
 
@@ -18,54 +18,77 @@ describe Slate::Render do
   end
 
   it "should be able to get a single target" do
-    graph = Slate::Render.new(:target => "app.server01.load")
+    target = Slate::Target.build("app.server01.load")
+    graph = Slate::Graph.new
+    graph << target
     query(graph.url).should include("target" => "app.server01.load", "format" => "png")
   end
 
   it "should be able to apply functions" do
-    graph = Slate::Render.new(:target => "app.server01.load")
-    graph.add_function :cumulative
+    target = Slate::Target.build("app.server01.load") do |t|
+      t.add_function :cumulative
+    end
+    graph = Slate::Graph.new
+    graph << target
     graph.url.should include(CGI.escape("cumulative(app.server01.load)"))
 
-    graph = Slate::Render.new(:target => "app.server01.load")
-    graph.add_function :cumulative
-    graph.add_function :alias, "load"
+    target = Slate::Target.build("app.server01.load") do |t|
+      t.add_function :cumulative
+      t.add_function :alias, "load"
+    end
+    graph = Slate::Graph.new
+    graph << target
     graph.url.should include(CGI.escape("alias(cumulative(app.server01.load),\"load\""))
 
-    graph = Slate::Render.new(:target => "app.server01.load")
-    graph.add_function :summarize, "1s", "sum"
+    target = Slate::Target.build("app.server01.load") do |t|
+      t.add_function :summarize, "1s", "sum"
+    end
+    graph = Slate::Graph.new
+    graph << target
     graph.url.should include(CGI.escape("summarize(app.server01.load,\"1s\",\"sum\")"))
 
-    graph = Slate::Render.new(:target => "app.server01.load")
-    graph.add_function :movingAverage, 10
+    target = Slate::Target.build("app.server01.load") do |t|
+      t.add_function :movingAverage, 10
+    end
+    graph = Slate::Graph.new
+    graph << target
     graph.url.should include(CGI.escape("movingAverage(app.server01.load,10)"))
   end
 
   it "should be able to accept other graphs as options to a function" do
-    graph = Slate::Render.new(:target => "app.server01.load")
+    first_target  = Slate::Target.build("app.server*.load") do |t|
+      t.add_function :sum
+    end
+    second_target = Slate::Target.build("app.server01.load") do |t|
+      t.add_function :asPercent, first_target
+    end
 
-    other_graph = Slate::Render.new(:target => "app.server*.load")
-    other_graph.add_function :sum
-
-    graph.add_function :asPercent, other_graph
+    graph = Slate::Graph.new
+    graph << second_target
 
     graph.url.should include(CGI.escape("asPercent(app.server01.load,sum(app.server*.load))"))
   end
 
   it "should be able to specify start and end times" do
-    graph = Slate::Render.new(:target => "app.server01.load", :from => "-1d")
+    target = Slate::Target.build("app.server01.load")
+    graph = Slate::Graph.new(:from => "-1d")
+    graph << target
     graph.url.should match(/from=-1d/)
 
-    graph = Slate::Render.new(:target => "app.server01.load", :until => "-1d")
+    graph = Slate::Graph.new(:until => "-1d")
+    graph << target
     graph.url.should match(/until=-1d/)
 
-    graph = Slate::Render.new(:target => "app.server01.load", :from => "-1d", :until => "-6h")
+    graph = Slate::Graph.new(:from => "-1d", :until => "-6h")
+    graph << target
     graph.url.should match(/from=-1d/)
     graph.url.should match(/until=-6h/)
   end
 
   it "should provide methods for retrieving formats" do
-    graph = Slate::Render.new(:target => "app.server01.load")
+    target = Slate::Target.build("app.server01.load")
+    graph = Slate::Graph.new
+    graph << target
     graph.url(:png).should  match(/format=png/)
     graph.url(:raw).should  match(/format=raw/)
     graph.url(:csv).should  match(/format=csv/)
@@ -74,7 +97,9 @@ describe Slate::Render do
   end
 
   it "should retrieve the graph" do
-    graph = Slate::Render.new(:target => "app.server01.load")
+    target = Slate::Target.build("app.server01.load")
+    graph = Slate::Graph.new
+    graph << target
     graph.download(:png).should  eq(@png_stub)
     graph.download(:raw).should  eq(@raw_stub)
     graph.download(:csv).should  eq(@csv_stub)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slate
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-07 00:00:00.000000000 Z
+date: 2012-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -124,12 +124,12 @@ files:
 - lib/slate/calculation.rb
 - lib/slate/calculation/mean.rb
 - lib/slate/configuration.rb
-- lib/slate/render.rb
+- lib/slate/graph.rb
+- lib/slate/target.rb
 - lib/slate/version.rb
-- script.rb
 - slate.gemspec
 - spec/slate/calculation/mean_spec.rb
-- spec/slate/render_spec.rb
+- spec/slate/graph_spec.rb
 - spec/slate_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/trobrock/slate
@@ -146,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1369003764169049016
+      hash: -3823959702397249819
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -155,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1369003764169049016
+      hash: -3823959702397249819
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -164,6 +164,6 @@ specification_version: 3
 summary: Simple wrapper on top of the graphite render api
 test_files:
 - spec/slate/calculation/mean_spec.rb
-- spec/slate/render_spec.rb
+- spec/slate/graph_spec.rb
 - spec/slate_spec.rb
 - spec/spec_helper.rb

data/lib/slate/render.rb

@@ -1,77 +0,0 @@
-require 'cgi'
-require 'rest_client'
-
-module Slate
-  class Render
-    def initialize(options={})
-      @target = options[:target]
-      @from   = options[:from]
-      @until  = options[:until]
-      @functions = []
-    end
-
-    def url(format=:png)
-      options = url_options.merge("format" => format.to_s)
-      "#{Configuration.instance.endpoint}/render?#{params(options)}"
-    end
-
-    def download(format=:png)
-      RestClient.get url(format)
-    end
-
-    def add_function(*function)
-      if function.size > 1
-        arguments = function[1..-1]
-        @functions << [function.first.to_sym, arguments]
-      else
-        @functions << function.first.to_sym
-      end
-
-      target
-    end
-
-    def target
-      target = @target
-      @functions.each do |function|
-        if function.is_a? Symbol
-          target = %Q{#{function}(#{target})}
-        else
-          args = arguments(function.last).join(",")
-          target = %Q{#{function.first}(#{target},#{args})}
-        end
-      end
-
-      target
-    end
-
-    private
-
-    def arguments(args=[])
-      args.map do |arg|
-        if arg.is_a?(Numeric)
-          arg.to_s
-        elsif arg.is_a?(Slate::Render)
-          arg.send(:target)
-        else
-          %Q{"#{arg}"}
-        end
-      end
-    end
-
-    def url_options
-      options = {
-        "target" => target
-      }
-      options["from"]  = @from if @from
-      options["until"] = @until if @until
-
-      options
-    end
-
-    def params(options={})
-      options.map do |key,value|
-        "#{CGI.escape(key)}=#{CGI.escape(value)}"
-      end.join("&")
-    end
-  end
-end

data/script.rb

@@ -1,61 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'bundler/setup'
-require 'slate'
-
-WINDOW = ARGV[0] || "-1w"
-
-def log(title, value)
-  format = "[%17s] %01.2f\n"
-  printf format, title, value
-end
-
-Slate.configure do |c|
-  c.endpoint = "http://statsd.outright.com"
-end
-
-graph = Slate::Render.new(target: "stats.timers.rack.*.response_time.upper_90", from: WINDOW)
-graph.add_function :avg
-graph.add_function :summarize, "1h", "avg"
-
-app_response_time = Slate::Calculation::Mean.new(graph).result
-
-graph = Slate::Render.new(target: "stats.rack.*.status_code.success", from: WINDOW)
-graph.add_function :sum
-
-total_graph = Slate::Render.new(target: "stats.rack.*.status_code.*", from: WINDOW)
-total_graph.add_function :exclude, "missing"
-total_graph.add_function :sum
-
-graph.add_function :asPercent, total_graph
-
-app_success_rate = Slate::Calculation::Mean.new(graph).result
-
-
-
-graph = Slate::Render.new(target: "stats.timers.agg.thrift.*.response_time.upper_90", from: WINDOW)
-graph.add_function :avg
-graph.add_function :summarize, "1h", "avg"
-
-agg_response_time = Slate::Calculation::Mean.new(graph).result
-
-
-graph = Slate::Render.new(target: "stats.agg.thrift.*.status_code.success", from: WINDOW)
-graph.add_function :sum
-
-total_graph = Slate::Render.new(target: "stats.agg.thrift.*.status_code.*", from: WINDOW)
-total_graph.add_function :exclude, "missing"
-total_graph.add_function :sum
-
-graph.add_function :asPercent, total_graph
-
-agg_success_rate = Slate::Calculation::Mean.new(graph).result
-
-log "App Response Time", app_response_time
-log "App Success Rate" , app_success_rate
-log "App Uptime"       , 0
-print "\n"
-log "Agg Response Time", agg_response_time
-log "Agg Success Rate" , agg_success_rate
-log "Agg Uptime"       , 0