dogapi-demo 0.1.0

data/lib/dogapi-demo/v1/search.rb

@@ -0,0 +1,27 @@
+require 'dogapi-demo'
+
+module DogapiDemo
+  class V1 # for namespacing
+
+    class SearchService < DogapiDemo::APIService
+
+      API_VERSION = "v1"
+
+      def search(query)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key,
+            :q => query
+          }
+
+          request(Net::HTTP::Get, "/api/#{API_VERSION}/search", params, nil, false)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dogapi-demo/v1/service_check.rb

@@ -0,0 +1,32 @@
+require 'dogapi-demo'
+
+module DogapiDemo
+  class V1
+
+    class ServiceCheckService < DogapiDemo::APIService
+
+      API_VERSION = 'v1'
+
+      def service_check(check, host, status, options = {})
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          body = {
+            'check' => check,
+            'host_name' => host,
+            'status' => status
+          }.merge options
+
+          request(Net::HTTP::Post, "/api/#{API_VERSION}/check_run", params, body, true)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dogapi-demo/v1/snapshot.rb

@@ -0,0 +1,30 @@
+require 'dogapi-demo'
+
+module DogapiDemo
+  class V1 # for namespacing
+
+    class SnapshotService < DogapiDemo::APIService
+
+      API_VERSION = "v1"
+
+      def snapshot(metric_query, start_ts, end_ts, event_query=nil)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key,
+            :metric_query => metric_query,
+            :start => start_ts,
+            :end => end_ts,
+            :event_query => event_query
+          }
+
+          request(Net::HTTP::Get, "/api/#{API_VERSION}/graph/snapshot", params, nil, false)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dogapi-demo/v1/tag.rb

@@ -0,0 +1,141 @@
+require 'dogapi-demo'
+
+module DogapiDemo
+  class V1 # for namespacing
+
+    # 
+    class TagService < DogapiDemo::APIService
+
+      API_VERSION = "v1"
+
+      # Gets all tags in your org and the hosts tagged with them
+      def get_all(source=nil)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+          if source
+            params['source'] = source
+          end
+
+          request(Net::HTTP::Get, '/api/' + API_VERSION + '/tags/hosts', params, nil, false)
+        rescue Exception => e
+          if @silent
+            warn e
+            return -1, {}
+          else
+            raise e
+          end
+        end
+      end
+
+      # Gets all tags for a given host
+      def get(host_id, source=nil, by_source=false)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+          if source
+            params['source'] = source
+          end
+          if by_source
+            params['by_source'] = 'true'
+          end
+
+          request(Net::HTTP::Get, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, nil, false)
+        rescue Exception => e
+          if @silent
+            warn e
+            return -1, {}
+          else
+            raise e
+          end
+        end
+      end
+
+      # Adds a list of tags to a host
+      def add(host_id, tags, source=nil)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+          if source
+            params['source'] = source
+          end
+
+          body = {
+            :tags => tags
+          }
+
+          request(Net::HTTP::Post, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, body, true)
+        rescue Exception => e
+          if @silent
+            warn e
+            return -1, {}
+          else
+            raise e
+          end
+        end
+      end
+
+      # Remove all tags from a host and replace them with a new list
+      def update(host_id, tags, source=nil)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+          if source
+            params['source'] = source
+          end
+
+          body = {
+            :tags => tags
+          }
+
+          request(Net::HTTP::Put, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, body, true)
+        rescue Exception => e
+          if @silent
+            warn e
+            return -1, {}
+          else
+            raise e
+          end
+        end
+      end
+
+      # <b>DEPRECATED:</b> Spelling mistake temporarily preserved as an alias.
+      def detatch(host_id)
+        warn "[DEPRECATION] DogapiDemo::V1::TagService.detatch() is deprecated. Use `detach` instead."
+        detach(host_id)
+      end
+
+      # Remove all tags from a host
+      def detach(host_id, source=nil)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+          if source
+            params['source'] = source
+          end
+
+          request(Net::HTTP::Delete, '/api/' + API_VERSION + '/tags/hosts/' + host_id.to_s, params, nil, false)
+        rescue Exception => e
+          if @silent
+            warn e
+            return -1, {}
+          else
+            raise e
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dogapi-demo/v1/user.rb

@@ -0,0 +1,113 @@
+require 'dogapi-demo'
+
+module DogapiDemo
+  class V1 # for namespacing
+
+    class UserService < DogapiDemo::APIService
+
+      API_VERSION = "v1"
+
+      # <b>DEPRECATED:</b> Going forward, we're using a new and more restful API,
+      # the new methods are get_user, create_user, update_user, disable_user
+      def invite(emails, options = {})
+        warn "[DEPRECATION] DogapiDemo::V1::UserService::invite has been deprecated in favor of DogapiDemo::V1::UserService::create_user"
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          body = {
+            'emails' => emails,
+          }.merge options
+
+          request(Net::HTTP::Post, "/api/#{API_VERSION}/invite_users", params, body, true)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+      # Create a user
+      #
+      # :description => Hash: user description containing 'handle' and 'name' properties
+      def create_user(description = {})
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          request(Net::HTTP::Post, "/api/#{API_VERSION}/user", params, description, true)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+      # Retrieve user information
+      #
+      # :handle => String: user handle
+      def get_user(handle)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          request(Net::HTTP::Get, "/api/#{API_VERSION}/user/#{handle}", params, nil, false)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+      # Retrieve all users
+      def get_all_users()
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          request(Net::HTTP::Get, "/api/#{API_VERSION}/user", params, nil, false)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+      # Update a user
+      #
+      # :handle => String: user handle
+      # :description => Hash: user description optionally containing 'name', 'email',
+      # 'is_admin', 'disabled' properties
+      def update_user(handle, description = {})
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          request(Net::HTTP::Put, "/api/#{API_VERSION}/user/#{handle}", params, description, true)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+      # Disable a user
+      #
+      # :handle => String: user handle
+      def disable_user(handle)
+        begin
+          params = {
+            :api_key => @api_key,
+            :application_key => @application_key
+          }
+
+          request(Net::HTTP::Delete, "/api/#{API_VERSION}/user/#{handle}", params, nil, false)
+        rescue Exception => e
+          suppress_error_if_silent e
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dogapi-demo/version.rb

@@ -0,0 +1,3 @@
+module DogapiDemo
+  VERSION = "0.1.0"
+end

data/spec/alerts_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "Alerts", :vcr => true do
+
+  before(:all) do
+    @api_key = ENV["DATADOG_API_KEY"]
+    @app_key = ENV["DATADOG_APP_KEY"]
+    @dog = Dogapi::Client.new(@api_key, @app_key)
+    @query = 'avg(last_10m):avg:test.metric.metric{host:test.metric.host} > 5'
+  end
+
+  context "create" do
+    before(:each) do
+      @new_alert = @dog.alert(@query)
+    end
+    after(:each) do
+      @dog.delete_alert(@new_alert[1]['id'])
+    end
+
+    it "returns HTTP code 200" do
+      expect(@new_alert[0]).to eq '200'
+    end
+
+    it "returns a valid event ID" do
+      expect(@new_alert[1]['id']).to be_a(Fixnum)
+    end
+
+    it "returns the same query as sent" do
+      expect(@new_alert[1]['query']).to eq @query
+    end
+  end
+
+end

data/spec/common_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe "Common" do
+
+  context "Scope" do
+
+    it "validates the Scope class" do
+      obj = Dogapi::Scope.new("somehost", "somedevice")
+
+      expect(obj.host).to eq "somehost"
+      expect(obj.device).to eq "somedevice"
+    end
+
+  end # end Scope
+
+  context "HttpConnection" do
+
+    it "respects the proxy configuration" do
+      service = Dogapi::APIService.new("api_key", "app_key")
+
+      service.connect do |conn|
+        expect(conn.proxy_address).to be(nil)
+        expect(conn.proxy_port).to be(nil)
+      end
+
+      ENV["http_proxy"] = "https://www.proxy.com:443"
+
+      service.connect do |conn|
+        expect(conn.proxy_address).to eq "www.proxy.com"
+        expect(conn.proxy_port).to eq 443
+      end
+
+      ENV["http_proxy"] = nil
+    end
+  end
+
+end # end Common

data/spec/facade_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe "Facade", :vcr => true do
+
+  before(:all) do
+    @api_key = ENV["DATADOG_API_KEY"]
+    @app_key = ENV["DATADOG_APP_KEY"]
+    @job_number = ENV['TRAVIS_JOB_NUMBER'] || '1'
+    @dog = Dogapi::Client.new(@api_key, @app_key)
+  end
+
+  context "Client" do
+
+    before(:each) do
+      @dogmock = Dogapi::Client.new(@api_key, @app_key)
+      @service = @dogmock.instance_variable_get(:@metric_svc)
+      @service.instance_variable_set(:@uploaded, Array.new)
+      def @service.upload payload
+        @uploaded << payload
+        return 200, {}
+      end
+    end
+
+    it "emit_point passes data" do
+      @dogmock.emit_point("metric.name", 0, :host => "myhost")
+
+      uploaded =  @service.instance_variable_get(:@uploaded)
+      expect(uploaded.length).to eq 1
+      series = uploaded.first
+      expect(series.class).to eq Array
+      expect(series[0][:metric]).to eq "metric.name"
+      expect(series[0][:points][0][1]).to eq 0
+      expect(series[0][:host]).to eq "myhost"
+    end
+
+    it "emit_point uses localhost default" do
+      @dogmock.emit_point("metric.name", 0)
+
+      uploaded =  @service.instance_variable_get(:@uploaded)
+      series = uploaded.first
+      expect(series[0][:host]).to eq Dogapi.find_localhost
+    end
+
+    it "emit_point can pass nil host" do
+      @dogmock.emit_point("metric.name", 0, :host => nil)
+
+      uploaded =  @service.instance_variable_get(:@uploaded)
+      series = uploaded.first
+      expect(series[0][:host]).to be_nil
+    end
+
+    it "emit_points can be batched" do
+      code, resp = @dogmock.batch_metrics do
+        @dogmock.emit_point("metric.name", 1, :type => 'counter')
+        @dogmock.emit_point("othermetric.name", 2, :type => 'counter')
+      end
+      expect(code).to eq 200
+      # Verify that we uploaded what we expected
+      uploaded =  @service.instance_variable_get(:@uploaded)
+      expect(uploaded.length).to eq 1
+      series = uploaded.first
+      expect(series.class).to eq Array
+      expect(series[0][:metric]).to eq 'metric.name'
+      expect(series[0][:points][0][1]).to eq 1
+      expect(series[0][:type]).to eq 'counter'
+      expect(series[1][:metric]).to eq 'othermetric.name'
+      expect(series[1][:points][0][1]).to eq 2
+      expect(series[1][:type]).to eq 'counter'
+
+      # Verify that the buffer was correclty emptied
+      buffer = @service.instance_variable_get(:@buffer)
+      expect(buffer).to be nil
+    end
+
+    it "flushes the buffer even if an exception is raised" do
+      begin
+        @dogmock.batch_metrics do
+          @dogmock.emit_point("metric.name", 1, :type => 'counter')
+          raise "Oh no, something went wrong"
+        end
+      rescue
+      end
+      buffer = @service.instance_variable_get(:@buffer)
+      expect(buffer).to be nil
+    end
+
+  end
+
+  context "Events" do
+
+    it "emits events and retrieves them" do
+      now = Time.now()
+
+      # Tag the events with the build number, because Travis parallel testing
+      # can cause problems with the event stream
+      tags = ["test-run:#{@job_number}"]
+
+      now_ts = now
+      now_title = 'dogapi-rb end test title ' + now_ts.to_i.to_s
+      now_message = 'test message'
+
+
+      event = Dogapi::Event.new(now_message, :msg_title => now_title,
+        :date_happened => now_ts, :tags => tags)
+
+      code, resp = @dog.emit_event(event)
+      now_event_id = resp["event"]["id"]
+      sleep 8
+      code, resp = @dog.get_event(now_event_id)
+      expect(resp['event']).not_to be_nil
+      expect(resp['event']['text']).to eq(now_message)
+    end
+
+    it "emits events with specified priority" do
+      event = Dogapi::Event.new('test message', :msg_title => 'title', :date_happened => Time.now(), :priority => "low")
+      code, resp = @dog.emit_event(event)
+      low_event_id = resp["event"]["id"]
+      sleep 8
+      code, resp = @dog.get_event(low_event_id)
+      expect(resp['event']).not_to be_nil
+      low_event = resp['event']
+      expect(low_event['priority']).to eq("low")
+    end
+
+    it "emits aggregate events" do
+      now = Time.now()
+      code, resp = @dog.emit_event(Dogapi::Event.new("Testing Aggregation (first)", :aggregation_key => now.to_i))
+      first = resp["event"]["id"]
+      code, resp = @dog.emit_event(Dogapi::Event.new("Testing Aggregation (second)", :aggregation_key => now.to_i))
+      second = resp["event"]["id"]
+      sleep 8
+      code, resp = @dog.get_event(first)
+      expect(resp["event"]).not_to be_nil
+      code, resp = @dog.get_event(second)
+      expect(resp["event"]).not_to be_nil
+    end
+
+  end
+
+  context "Tags" do
+    it "adds, updates and detaches tags" do
+      hostname = "test.tag.host"
+
+      @dog.emit_point('test.tag.metric', 1, :host => hostname)
+      sleep 5
+      @dog.detach_tags(hostname)
+      code, resp = @dog.host_tags(hostname)
+      expect(resp["tags"]).to be_empty
+
+      @dog.add_tags(hostname, ['test.tag.1', 'test.tag.2'])
+      code, resp = @dog.host_tags(hostname)
+      new_tags = resp["tags"]
+      expect(new_tags).to match_array(['test.tag.1', 'test.tag.2'])
+
+      @dog.add_tags(hostname, ['test.tag.3'])
+      code, resp = @dog.host_tags(hostname)
+      new_tags = resp["tags"]
+      expect(new_tags).to match_array(['test.tag.1', 'test.tag.2', 'test.tag.3'])
+
+      @dog.detach_tags(hostname)
+      code, resp = @dog.host_tags(hostname)
+      expect(resp["tags"]).to be_empty
+    end
+  end
+
+end