dogapi 1.1.0 → 1.2.1

data/README.rdoc

@@ -1,7 +1,20 @@
-= Ruby client for Datadog API v1.1.0
+= Ruby client for Datadog API v1.2.1
 
 The Ruby client is a library suitable for inclusion in existing Ruby projects or for development of standalone scripts. It provides an abstraction on top of Datadog's raw HTTP interface for reporting events and metrics.
 
+= What's new?
+
+== v1.2.x
+
+* You can now manage host tags
+* You can now get event details and query the stream in addition to posting events
+* Functionality relating to events with a duration has been deprecated
+* The underlying clients have been updated to use Datadog's new public HTTP API[https://github.com/DataDog/dogapi/wiki]
+
+== v1.1.x
+
+* You do not need to use environment variables anymore to use the client.
+
 = Installation
 
 == From Source
@@ -20,7 +33,7 @@ Gem page: https://rubygems.org/gems/dogapi
 
 = Usage
 
-== How to find your API Key
+== How to find your API and application keys
 
 Go to your setup page[https://app.datadoghq.com/account/settings].
 
@@ -34,62 +47,66 @@ on a host, simply specify the device when calling emit functions.
 
 == Submit an event to Datadog
 
-=== If the event has no duration
 
     require 'rubygems'
     require 'dogapi'
 
     api_key = "abcdef123456"
 
+    # submitting events doesn't require an application_key, so we don't bother setting it
     dog = Dogapi::Client.new(api_key)
 
-    dog.emit_event(Dogapi::Event.new('Testing done, FTW'), host => "my_host")
+    dog.emit_event(Dogapi::Event.new('Testing done, FTW'), :host => "my_host")
+
+
+== Tag a host in Datadog
 
-=== If the event has a duration
 
     require 'rubygems'
     require 'dogapi'
 
     api_key = "abcdef123456"
+    application_key = "fedcba654321"
 
-    dog = Dogapi::Client.new(api_key)
+    dog = Dogapi::Client.new(api_key, application_key)
+
+    dog.add_tags("my_host", ["tagA", "tagB"])
 
-    dog.start_event(Dogapi::Event.new('My event with a duration'), host => "my_host") do
-    # do your work here...
-    # e.g. sleep 1
-    end
-    # stop_event will be sent automatically
 
 == Submit a metric to Datadog
 
-You want to track a new metric called +some.metric.name+ and have just sampled it from +my_device+ on +my_host+.
+You want to track a new metric called +some+.+metric+.+name+ and have just sampled it from +my_device+ on +my_host+.
 Its value is 50. Here is how you submit the value to Datadog.
 
+
     require 'rubygems'
     require 'dogapi'
 
     api_key = "abcdef123456"
 
+    # submitting metrics doesn't require an application_key, so we don't bother setting it
     dog = Dogapi::Client.new(api_key)
 
-    dog.emit_point 'some.metric.name', 50.0, host => "my_host", device => "my_device"
+    dog.emit_point('some.metric.name', 50.0, :host => "my_host", :device => "my_device")
+
 
 Let us now assume that you have sampled the metric multiple times and you would like to submit the results.
 You can use the +emit_points+ method (instead of +emit_point+). Since you are submitting more than one
 data point you will need to pass a list of +Time+, +float+ pairs, instead of a simple +float+ value.
 
+
     require 'rubygems'
     require 'dogapi'
 
-    = Actual sampling takes place
+    # Actual sampling takes place
     t1 = Time.now
     val1 = 50.0
 
-    = some time elapses
+    # some time elapses
     t2 = Time.now
     val2 = 51.0
 
-    = some more time elapses
+    # some more time elapses
     t3 = Time.now
     val3 = -60.0
 
@@ -97,4 +114,4 @@ data point you will need to pass a list of +Time+, +float+ pairs, instead of a s
 
     dog = Dogapi::Client.new(api_key)
 
-    dog.emit_points 'some.metric.name', [[t1, val1], [t2, val2], [t3, val3]], host => "my_host", device => "my_device"
+    dog.emit_points('some.metric.name', [[t1, val1], [t2, val2], [t3, val3]], :host => "my_host", :device => "my_device")

data/lib/dogapi/common.rb

@@ -18,15 +18,17 @@ module Dogapi
     end
   end
 
-  # Superclass that deals with the details of communicating with the DataDog API
+  # <b>DEPRECATED:</b> Going forward, use the newer APIService.
   class Service
+    # <b>DEPRECATED:</b> Going forward, use the newer APIService.
     def initialize(api_key, api_host=Dogapi.find_datadog_host)
       @api_key = api_key
       @host = api_host
     end
 
-    # Manages the HTTP connection
+    # <b>DEPRECATED:</b> Going forward, use the newer APIService.
     def connect
+      warn "[DEPRECATION] Dogapi::Service has been deprecated in favor of the newer V1 services"
       uri = URI.parse(@host)
       session = Net::HTTP.new(uri.host, uri.port)
       if 'https' == uri.scheme
@@ -41,12 +43,9 @@ module Dogapi
       end
     end
 
-    # Prepares the request and handles the response
-    #
-    # +method+ is an implementation of Net::HTTP::Request (e.g. Net::HTTP::Post)
-    #
-    # +params+ is a Hash that will be converted to request parameters
+    # <b>DEPRECATED:</b> Going forward, use the newer APIService.
     def request(method, url, params)
+      warn "[DEPRECATION] Dogapi::Service has been deprecated in favor of the newer V1 services"
       if !params.has_key? :api_key
         params[:api_key] = @api_key
       end
@@ -72,6 +71,69 @@ module Dogapi
     end
   end
 
+  # Superclass that deals with the details of communicating with the DataDog API
+  class APIService
+    def initialize(api_key, application_key)
+      @api_key = api_key
+      @application_key = application_key
+      @api_host = Dogapi.find_datadog_host()
+    end
+
+    # Manages the HTTP connection
+    def connect
+      uri = URI.parse(@api_host)
+      session = Net::HTTP.new(uri.host, uri.port)
+      if 'https' == uri.scheme
+        session.use_ssl = true
+        # FIXME - turn off SSL verification for now until we can spend
+        # some time figuring out how to find certs across platforms.
+        # - matt 10/06/2011
+        session.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      session.start do |conn|
+        yield(conn)
+      end
+    end
+
+    # Prepares the request and handles the response
+    #
+    # +method+ is an implementation of Net::HTTP::Request (e.g. Net::HTTP::Post)
+    #
+    # +params+ is a Hash that will be converted to request parameters
+    def request(method, url, params, body, send_json)
+      resp_obj = nil
+      resp = nil
+      connect do |conn|
+        if params and params.size > 0
+          qs_params = params.map { |k,v| k.to_s + "=" + v.to_s }
+          qs = "?" + qs_params.join("&")
+          url = url + qs
+        end
+
+        req = method.new(url)
+
+        if send_json
+          req.content_type = 'application/json'
+          req.body = JSON.generate(body)
+        end
+
+        resp = conn.request(req)
+        resp_str = resp.body
+
+        if resp.code != 204 and resp.body != '' and resp.body != 'null' and resp.body != nil
+          begin
+            resp_obj = JSON.parse(resp.body)
+          rescue
+            raise 'Invalid JSON Response: ' + resp.body
+          end
+        else
+          resp_obj = {}
+        end
+      end
+      return resp.code, resp_obj
+    end
+  end
+
   def Dogapi.find_datadog_host
     # allow env-based overriding, useful for tests
     ENV["DATADOG_HOST"] || "https://app.datadoghq.com"

data/lib/dogapi/event.rb

@@ -15,6 +15,9 @@ module Dogapi
       :event_object,
       :msg_title,
       :msg_text,
+      :priority,
+      :parent,
+      :tags,
       :json_payload
 
   # Optional arguments:
@@ -25,6 +28,9 @@ module Dogapi
   #  :event_type    => String
   #  :event_object  => String
   #  :msg_title     => String
+  #  :priority      => String
+  #  :parent        => event ID (integer)
+  #  :tags          => array of Strings
   #  :json_payload  => String
     def initialize(msg_text, options={})
       defaults = {
@@ -35,6 +41,9 @@ module Dogapi
         :event_type => '',
         :event_object => '',
         :msg_title => '',
+        :priority => "normal",
+        :parent => nil,
+        :tags => [],
         :json_payload => ''
       }
       options = defaults.merge(options)
@@ -47,17 +56,23 @@ module Dogapi
       @event_type = options[:event_type]
       @event_object = options[:event_object]
       @msg_title = options[:msg_title]
+      @priority = options[:priority]
+      @parent = options[:parent]
+      @tags = options[:tags]
       @json_payload = options[:json_payload]
     end
   end
 
-  # Event-specific client affording more granular control than the simple Dogapi::Client
+  # <b>DEPRECATED:</b> Going forward, use the V1 services. This legacy service will be
+  # removed in an upcoming release.
   class EventService < Dogapi::Service
 
     API_VERSION = "1.0.0"
 
-    # Records an Event with no duration
+    # <b>DEPRECATED:</b> Going forward, use the V1 services. This legacy service will be
+    # removed in an upcoming release.
     def submit(api_key, event, scope=nil, source_type=nil)
+      warn "[DEPRECATION] Dogapi::EventService.submit() has been deprecated in favor of the newer V1 services"
       scope = scope || Dogapi::Scope.new()
       params = {
         :api_key => api_key,
@@ -84,12 +99,10 @@ module Dogapi
       request Net::HTTP::Post, '/event/submit', params
     end
 
-    # Manages recording an event with a duration
-    #
-    # 0. The start time is recorded immediately
-    # 0. The given block is executed with access to the response of the start request
-    # 0. The end time is recorded once the block completes execution
+    # <b>DEPRECATED:</b> Going forward, use the V1 services. This legacy service will be
+    # removed in an upcoming release.
     def start(api_key, event, scope, source_type=nil)
+      warn "[DEPRECATION] Dogapi::EventService.start() has been deprecated in favor of the newer V1 services"
       response = submit api_key, event, scope, source_type
       success = nil
 

data/lib/dogapi/facade.rb

@@ -1,15 +1,17 @@
 require 'time'
-require 'dogapi/metric'
+require 'dogapi/v1'
 
 module Dogapi
 
   # A simple DogAPI client
   #
-  # See Dogapi::EventService and Dogapi::MetricService for the thick underlying clients
+  # See Dogapi::V1  for the thick underlying clients
+  #
+  # Class methods return a tuple of (+response_code+, +response_body+). Unless otherwise noted, the response body is deserialized JSON. Up-to-date information about the JSON object structure is available in the HTTP API documentation, here[https://github.com/DataDog/dogapi/wiki].
   class Client
 
     # Create a new Client optionally specifying a default host and device
-    def initialize(api_key, host=nil, device=nil)
+    def initialize(api_key, application_key=nil, host=nil, device=nil)
 
       if api_key
         @api_key = api_key
@@ -17,15 +19,23 @@ module Dogapi
         raise 'Please provide an API key to submit your data'
       end
 
+      @application_key = application_key
+
       @datadog_host = Dogapi.find_datadog_host()
 
       @host = host
       @device = device
 
-      @metric_svc = Dogapi::MetricService.new(@datadog_host)
-      @event_svc = Dogapi::EventService.new(@datadog_host)
+      @metric_svc = Dogapi::V1::MetricService.new(@api_key, @application_key)
+      @event_svc = Dogapi::V1::EventService.new(@api_key, @application_key)
+      @tag_svc = Dogapi::V1::TagService.new(@api_key, @application_key)
+
+      @legacy_event_svc = Dogapi::EventService.new(@datadog_host)
     end
 
+    #
+    # METRICS
+
     # Record a single point of metric data
     #
     # Optional arguments:
@@ -36,10 +46,10 @@ module Dogapi
       defaults = {:timestamp => Time.now, :host => nil, :device => nil}
       options = defaults.merge(options)
 
-      self.emit_points metric,
+      self.emit_points(metric,
                        [[options[:timestamp], value]],
                        :host => options[:host],
-                       :device => options[:device]
+                       :device => options[:device])
     end
 
     # Record a set of points of metric data
@@ -57,52 +67,105 @@ module Dogapi
 
       points.each do |p|
         p[0].kind_of? Time or raise "Not a Time"
-        p[1].to_f # TODO: stupid to_f will never raise and exception
+        p[0] = p[0].to_i
+        p[1] = p[1].to_f # TODO: stupid to_f will never raise an exception
       end
 
-      @metric_svc.submit @api_key, scope, metric, points
+      @metric_svc.submit(metric, points, scope)
     end
 
-    # Record an event with no duration
     #
-    # If <tt>:source_type</tt> is unset, a generic "system" event will be reported
+    # EVENTS
+
+    # Record an event
     #
     # Optional arguments:
     #  :host        => String
     #  :device      => String
-    #  :source_type => String
     def emit_event(event, options={})
-      defaults = {:host => nil, :device => nil, :source_type => nil}
+      defaults = {:host => nil, :device => nil}
       options = defaults.merge(options)
 
-      scope = override_scope options[:host], options[:device]
+      scope = override_scope(options[:host], options[:device])
+
+      @event_svc.post(event, scope)
+    end
 
-      @event_svc.submit(@api_key, event, scope, options[:source_type])
+    # Get the details of an event
+    #
+    # +id+ of the event to get
+    def get_event(id)
+      @event_svc.get(id)
     end
 
-    # Record an event with a duration
+    # Get an optionally filtered event stream
     #
-    # 0. The start time is recorded immediately
-    # 0. The given block is executed
-    # 0. The end time is recorded once the block completes execution
+    # +start+ is a Time object for when to start the stream
     #
-    # If <tt>:source_type</tt> is unset, a generic "system" event will be reported
+    # +stop+ is a Time object for when to end the stream
     #
     # Optional arguments:
-    #  :host        => String
-    #  :device      => String
-    #  :source_type => String
+    #   :priority   => "normal" or "low"
+    #   :sources    => String, see https://github.com/DataDog/dogapi/wiki/Event for a current list of sources
+    #   :tags       => Array of Strings
+    def stream(start, stop, options={})
+      @event_svc.stream(start, stop, options)
+    end
+
+    # <b>DEPRECATED:</b> Recording events with a duration has been deprecated.
+    # The functionality will be removed in a later release.
     def start_event(event, options={})
+      warn "[DEPRECATION] Dogapi::Client.start_event() is deprecated. Use `emit_event` instead."
       defaults = {:host => nil, :device => nil, :source_type => nil}
       options = defaults.merge(options)
 
       scope = override_scope options[:host], options[:device]
 
-      @event_svc.start(@api_key, event, scope, options[:source_type]) do
+      @legacy_event_svc.start(@api_key, event, scope, options[:source_type]) do
         yield
       end
     end
 
+    #
+    # TAGS
+   
+    # Get all tags and their associated hosts at your org
+    def all_tags()
+      @tag_svc.get_all()
+    end
+   
+    # Get all tags for the given host
+    #
+    # +host_id+ can be the host's numeric id or string name
+    def host_tags(host_id)
+      @tag_svc.get(host_id)
+    end
+    
+    # Add the tags to the given host
+    #
+    # +host_id+ can be the host's numeric id or string name
+    #
+    # +tags+ is and Array of Strings
+    def add_tags(host_id, tags)
+      @tag_svc.add(host_id, tags)
+    end
+   
+    # Replace the tags on the given host
+    #
+    # +host_id+ can be the host's numeric id or string name
+    #
+    # +tags+ is and Array of Strings
+    def update_tags(host_id, tags)
+      @tag_svc.update(host_id, tags)
+    end
+    
+    # Remove all tags from the given host
+    #
+    # +host_id+ can be the host's numeric id or string name
+    def detatch_tags(host_id)
+      @tag_svc.detatch(host_id)
+    end
+
     private
 
     def override_scope(host, device)

data/lib/dogapi/metric.rb

@@ -5,12 +5,16 @@ require 'json'
 
 module Dogapi
 
+  # <b>DEPRECATED:</b> Going forward, use the V1 services. This legacy service will be
+  # removed in an upcoming release.
   class MetricService < Dogapi::Service
 
     API_VERSION = "1.0.0"
 
-    # Records some number of points for a given metric
+    # <b>DEPRECATED:</b> Going forward, use the V1 services. This legacy service will be
+    # removed in an upcoming release.
     def submit(api_key, scope, metric, points)
+      warn "[DEPRECATION] Dogapi::MetricService.submit() has been deprecated in favor of the newer V1 services"
       series = [{
         :host    =>  scope.host,
         :device  =>  scope.device,

data/lib/dogapi/v1.rb

@@ -0,0 +1,3 @@
+require 'dogapi/v1/event'
+require 'dogapi/v1/metric'
+require 'dogapi/v1/tag'

data/lib/dogapi/v1/event.rb

@@ -0,0 +1,71 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # Event-specific client affording more granular control than the simple Dogapi::Client
+    class EventService < Dogapi::APIService
+
+      API_VERSION = "v1"
+
+      # Records an Event with no duration
+      def post(event, scope=nil)
+        scope = scope || Dogapi::Scope.new()
+        params = {
+          :api_key => @api_key
+        }
+
+        body = {
+          :title => event.msg_title,
+          :text => event.msg_text,
+          :date_happened => event.date_happened.to_i,
+          :priority => event.priority,
+          :parent => event.parent,
+          :tags => event.tags,
+        }
+
+        request(Net::HTTP::Post, '/api/v1/events', params, body, true)
+      end
+
+      def get(id)
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key
+        }
+
+        request(Net::HTTP::Get, '/api/' + API_VERSION + '/events/' + id.to_s, params, nil, false)
+      end
+
+      def stream(start, stop, options={})
+        defaults = {
+          :priority => nil,
+          :sources => nil,
+          :tags => nil
+        }
+        options = defaults.merge(options)
+
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key,
+
+          :start => start.to_i,
+          :end => stop.to_i
+        }
+
+        if options[:priority]:
+          params[:priority] = options[:priority]
+        end
+        if options[:sources]:
+          params[:sources] = options[:sources]
+        end
+        if options[:tags]:
+          params[:tags] = options[:tags]
+        end
+
+        request(Net::HTTP::Get, '/api/' + API_VERSION + '/events', params, nil, false)
+      end
+
+    end
+
+  end
+end

data/lib/dogapi/v1/metric.rb

@@ -0,0 +1,33 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # Event-specific client affording more granular control than the simple Dogapi::Client
+    class MetricService < Dogapi::APIService
+
+      API_VERSION = "v1"
+
+      # Records an Event with no duration
+      def submit(metric, points, scope)
+        params = {
+          :api_key => @api_key
+        }
+
+        body = { :series => [
+            {
+              :metric => metric,
+              :points => points,
+              :type => "gauge",
+              :host => scope.host,
+              :device => scope.device
+            }
+          ]
+        }
+
+        request(Net::HTTP::Post, '/api/' + API_VERSION + '/series', params, body, true)
+      end
+    end
+
+  end
+end

data/lib/dogapi/v1/tag.rb

@@ -0,0 +1,72 @@
+require 'dogapi'
+
+module Dogapi
+  class V1 # for namespacing
+
+    # 
+    class TagService < Dogapi::APIService
+
+      API_VERSION = "v1"
+
+      # Gets all tags in your org and the hosts tagged with them
+      def get_all()
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key
+        }
+
+        request(Net::HTTP::Get, '/api/' + API_VERSION + '/tags/hosts', params, nil, false)
+      end
+
+      # Gets all tags for a given host
+      def get(host_id)
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key
+        }
+
+        request(Net::HTTP::Get, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, nil, false)
+      end
+
+      # Adds a list of tags to a host
+      def add(host_id, tags)
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key
+        }
+
+        body = {
+          :tags => tags
+        }
+
+        request(Net::HTTP::Post, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, body, true)
+      end
+
+      # Remove all tags from a host and replace them with a new list
+      def update(host_id, tags)
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key
+        }
+
+        body = {
+          :tags => tags
+        }
+
+        request(Net::HTTP::Put, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, body, true)
+      end
+
+      # Remove all tags from a host
+      def detatch(host_id)
+        params = {
+          :api_key => @api_key,
+          :application_key => @application_key
+        }
+
+        request(Net::HTTP::Delete, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, nil, false)
+      end
+
+    end
+
+  end
+end

data/tests/tc_client.rb

@@ -1,37 +1,103 @@
 require 'test/unit'
 require 'dogapi'
+require 'time'
 
 class TestClient < Test::Unit::TestCase
 
   def config_client_test_env
-    @api_key = ENV['DATADOG_KEY']
+    @api_key = ENV['DATADOG_API_KEY']
+    @app_key = ENV['DATADOG_APP_KEY']
+    if not @api_key or not @app_key
+      puts "\n"
+      abort "To run tests in your environment, set 'DATADOG_API_KEY' and 'DATADOG_APP_KEY' to appropriate values for your account. Be aware that the tests will submit data, some of which won't be removed at the end.\n\n"
+    end
   end
 
   def setup
-    config_client_test_env
+    config_client_test_env()
   end
 
-  def test_simple_client
-    dog = Dogapi::Client.new(@api_key)
+  def test_tags
+    hostname = 'test.tag.host'
+    dog = Dogapi::Client.new(@api_key, @app_key)
 
-    dog.emit_point 'test.dogclient.emit_point',
-                   999,
-                   :host => 'test.dogclient.fake',
-                   :device => 'eth0'
+    # post a metric to make sure the test host context exists
+    dog.emit_point('test.tag.metric', 1, :host => hostname)
 
-    dog.emit_points 'test.dogclient.emit_points',
-                    [[Time.now - 60, 10], [Time.now - 30, 20], [Time.now, 30]],
-                    :host => 'test.dogclient.fake',
-                    :device => 'eth0'
+    dog.all_tags()
 
-    my_event = Dogapi::Event.new('Testing Event API')
-    dog.emit_event my_event,
-      :host => 'test.dogclient.fake',
-      :device => 'eth0'
+    dog.detatch_tags(hostname)
+    code, resp = dog.host_tags(hostname)
+    assert resp["tags"].size == 0
 
-    my_event = Dogapi::Event.new('Testing Event API with a duration')
-    dog.start_event(my_event, :host =>'test.dogclient.fake', :device => 'eth0') do
-      sleep 1
-    end
+    dog.add_tags(hostname, ['test.tag.1', 'test.tag.2'])
+    code, resp = dog.host_tags(hostname)
+    new_tags = resp["tags"]
+    assert new_tags.size == 2
+    assert new_tags.include?('test.tag.1')
+    assert new_tags.include?('test.tag.2')
+
+    dog.add_tags(hostname, ['test.tag.3'])
+    code, resp = dog.host_tags(hostname)
+    new_tags = resp["tags"]
+    assert new_tags.size == 3
+    assert new_tags.include?('test.tag.1')
+    assert new_tags.include?('test.tag.2')
+    assert new_tags.include?('test.tag.3')
+
+    dog.update_tags(hostname, ['test.tag.4'])
+    code, resp = dog.host_tags(hostname)
+    new_tags = resp["tags"]
+    assert new_tags.size == 1
+    assert new_tags.include?('test.tag.4')
+
+    dog.detatch_tags(hostname)
+    code, resp = dog.host_tags(hostname)
+    assert resp["tags"].size == 0
   end
+
+  def test_events
+    now = Time.now()
+
+    now_ts = now
+    now_title = 'end test title ' + now_ts.to_i.to_s
+    now_message = 'test message ' + now_ts.to_i.to_s
+
+    before_ts = (now - 5*60)
+    before_title = 'start test title ' + before_ts.to_i.to_s
+    before_message = 'test message ' + before_ts.to_i.to_s
+
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    dog_r = Dogapi::Client.new(@api_key)
+
+    code, resp = dog_r.emit_event(Dogapi::Event.new(now_message, :msg_title =>now_title, :date_happened => now_ts))
+    now_event_id = resp["event"]["id"]
+    sleep 1
+    code, resp = dog_r.emit_event(Dogapi::Event.new(before_message, :msg_title =>before_title, :date_happened => before_ts))
+    before_event_id = resp["event"]["id"]
+
+    code, resp = dog.stream(before_ts, now_ts + 1)
+    stream = resp["events"]
+
+    assert stream.last['title'] == before_title
+    assert stream.first['title'] == now_title
+
+    code, resp = dog.get_event(now_event_id)
+    now_event = resp['event']
+    code, resp = dog.get_event(before_event_id)
+    before_event = resp['event']
+
+    assert now_event['text'] == now_message
+    assert before_event['text'] == before_message
+  end
+
+  def test_metrics
+    # FIXME: actually verify this once there's a way to look at metrics through the api
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    dog_r = Dogapi::Client.new(@api_key)
+
+    dog_r.emit_point('test.metric.metric', 10, :host => 'test.metric.host')
+    dog_r.emit_points('test.metric.metric', [[Time.now-5*60, 0]], :host => 'test.metric.host')
+  end
+
 end

data/tests/ts_dogapi.rb

@@ -1,6 +1,3 @@
 require 'test/unit'
 
-require 'tc_env'
 require 'tc_client'
-require 'tc_event'
-require 'tc_metric'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dogapi
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 29
   prerelease: 
   segments: 
   - 1
+  - 2
   - 1
-  - 0
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors: 
 - Datadog, Inc.
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-06 00:00:00 Z
+date: 2011-10-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -46,11 +46,12 @@ files:
 - lib/dogapi/event.rb
 - lib/dogapi/facade.rb
 - lib/dogapi/metric.rb
+- lib/dogapi/v1/event.rb
+- lib/dogapi/v1/metric.rb
+- lib/dogapi/v1/tag.rb
+- lib/dogapi/v1.rb
 - lib/dogapi.rb
 - tests/tc_client.rb
-- tests/tc_env.rb
-- tests/tc_event.rb
-- tests/tc_metric.rb
 - tests/ts_dogapi.rb
 - README.rdoc
 homepage: http://datadoghq.com/
@@ -87,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Ruby bindings for Datadog's API

data/tests/tc_env.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-require 'dogapi'
-
-class TestEnvironment < Test::Unit::TestCase
-
-  def setup
-    @host = ENV['DATADOG_HOST']
-  end
-
-  def teardown
-    ENV['DATADOG_HOST'] = @host
-  end
-
-  def test_unset
-    ENV['DATADOG_HOST'] = nil
-    assert_equal "https://app.datadoghq.com", Dogapi.find_datadog_host
-  end
-
-  def test_set
-    ENV['DATADOG_HOST'] = 'test.host'
-    assert_equal 'test.host', Dogapi.find_datadog_host
-  end
-end

data/tests/tc_event.rb

@@ -1,35 +0,0 @@
-require 'test/unit'
-require 'dogapi'
-
-class TestEventClient < Test::Unit::TestCase
-
-  def config_client_test_env
-    @api_key = ENV['DATADOG_KEY']
-  end
-
-  def setup
-    config_client_test_env
-  end
-
-  def submit_event(scope=nil, source_type=nil)
-    event_service = Dogapi::EventService.new(@host)
-    tok = '#' + (rand(10000)+1).to_s
-    test_message = 'event_test_' + tok
-    event = Dogapi::Event.new(test_message, :event_type => 'test-event-type')
-    res = event_service.submit(@api_key, event, scope, source_type)
-    assert_not_equal(res['id'], nil)
-  end
-
-  def test_submit_event
-    submit_event
-  end
-
-  def test_submit_scoped_event
-    submit_event(Dogapi::Scope.new('scoped-testhost', 'testdevice'))
-  end
-
-  def test_submit_typed_event
-    submit_event(Dogapi::Scope.new('typed-testhost', 'testdevice'), 'GitHub')
-  end
-
-end

data/tests/tc_metric.rb

@@ -1,29 +0,0 @@
-require 'test/unit'
-require 'time'
-require 'dogapi'
-
-class TestMetricClient < Test::Unit::TestCase
-
-  def config_client_test_env
-    @api_key = ENV['DATADOG_KEY']
-  end
-
-  def setup
-    config_client_test_env
-  end
-
-  def test_submit_metric
-    metric_service = Dogapi::MetricService.new(@host)
-    scope = Dogapi::Scope.new('test.dogclient.fake', 'eth0')
-    metric = 'test.dogclient.metric.submit_metric'
-    points = [
-      [Time.now-90, 1.0],
-      [Time.now-60, 2.0],
-      [Time.now-30, 4.0],
-      [Time.now,    8.0]
-    ]
-    res = metric_service.submit(@api_key, scope, metric, points)
-    assert_equal(res['status'], 'ok')
-  end
-
-end