dogapi-demo 0.1.0

data/lib/dogapi-demo.rb

@@ -0,0 +1,5 @@
+require 'dogapi-demo/common'
+require 'dogapi-demo/facade'
+require 'dogapi-demo/event'
+require 'dogapi-demo/metric'
+require 'dogapi-demo/version'

data/lib/dogapi-demo/common.rb

@@ -0,0 +1,168 @@
+require 'cgi'
+require 'net/https'
+require 'pp'
+require 'socket'
+require 'uri'
+
+require 'rubygems'
+require 'multi_json'
+
+module DogapiDemo
+
+  # Metadata class to hold the scope of an API call
+  class Scope
+    attr_reader :host, :device
+    def initialize(host=nil, device=nil)
+      @host = host
+      @device = device
+    end
+  end
+
+  # <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=DogapiDemo.find_datadog_host)
+      @api_key = api_key
+      @host = api_host
+    end
+
+    # <b>DEPRECATED:</b> Going forward, use the newer APIService.
+    def connect
+      warn "[DEPRECATION] DogapiDemo::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
+        session.use_ssl = true
+      end
+      session.start do |conn|
+        yield(conn)
+      end
+    end
+
+    # <b>DEPRECATED:</b> Going forward, use the newer APIService.
+    def request(method, url, params)
+      warn "[DEPRECATION] DogapiDemo::Service has been deprecated in favor of the newer V1 services"
+      if !params.has_key? :api_key
+        params[:api_key] = @api_key
+      end
+
+      resp_obj = nil
+      connect do |conn|
+        req = method.new(url)
+        req.set_form_data params
+        resp = conn.request(req)
+        begin
+          resp_obj = MultiJson.load(resp.body)
+        rescue
+          raise 'Invalid JSON Response: ' + resp.body
+        end
+
+        if resp_obj.has_key? 'error'
+          request_string = params.pretty_inspect
+          error_string = resp_obj['error']
+          raise "Failed request\n#{request_string}#{error_string}"
+        end
+      end
+      resp_obj
+    end
+  end
+
+  # Superclass that deals with the details of communicating with the DataDog API
+  class APIService
+    def initialize(api_key, application_key, silent=true, timeout=nil)
+      @api_key = api_key
+      @application_key = application_key
+      @api_host = DogapiDemo.find_datadog_host()
+      @silent = silent
+      @timeout = timeout || 5
+    end
+
+    # Manages the HTTP connection
+    def connect
+      connection = Net::HTTP
+
+      # After ruby 2.0 Net::HTTP looks for the env variable but not ruby 1.9
+      if RUBY_VERSION < "2.0.0"
+        proxy = ENV["HTTPS_PROXY"] || ENV["https_proxy"] || ENV["HTTP_PROXY"] || ENV["http_proxy"]
+        if proxy
+          proxy_uri = URI.parse(proxy)
+          connection = Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+        end
+      end
+
+      uri = URI.parse(@api_host)
+      session = connection.new(uri.host, uri.port)
+      session.open_timeout = @timeout
+      session.use_ssl = uri.scheme == 'https'
+      session.start do |conn|
+        conn.read_timeout = @timeout
+        yield(conn)
+      end
+    end
+
+    def suppress_error_if_silent(e)
+      if @silent
+        warn e
+        return -1, {}
+      else
+        raise e
+      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 = MultiJson.dump(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 = MultiJson.load(resp.body)
+          rescue
+            raise 'Invalid JSON Response: ' + resp.body
+          end
+        else
+          resp_obj = {}
+        end
+      end
+      return resp.code, resp_obj
+    end
+  end
+
+  def DogapiDemo.find_datadog_host
+    # allow env-based overriding, useful for tests
+    "https://app.datadoghq.com"
+  end
+
+  # Memoize the hostname as a module variable
+  @@hostname = nil
+
+  def DogapiDemo.find_localhost
+    begin
+      # prefer hostname -f over Socket.gethostname
+      @@hostname ||= %x[hostname -f].strip
+    rescue
+      raise "Cannot determine local hostname via hostname -f"
+    end
+  end
+
+end

data/lib/dogapi-demo/event.rb

@@ -0,0 +1,129 @@
+require 'net/http'
+
+require 'rubygems'
+require 'multi_json'
+
+module DogapiDemo
+
+  # Metadata class for storing the details of an event
+  class Event
+    attr_reader :date_happened,
+      :msg_title,
+      :msg_text,
+      :priority,
+      :parent,
+      :tags,
+      :aggregation_key
+
+  # Optional arguments:
+  #  :date_happened => time in seconds since the epoch (defaults to now)
+  #  :msg_title     => String
+  #  :priority      => String
+  #  :parent        => event ID (integer)
+  #  :tags          => array of Strings
+  #  :event_object  => String
+  #  :alert_type    => 'success', 'error'
+  #  :event_type    => String
+  #  :source_type_name => String
+  #  :aggregation_key => String
+    def initialize(msg_text, options = {})
+      defaults = {
+        :date_happened => Time.now.to_i,
+        :msg_title => '',
+        :priority => "normal",
+        :parent => nil,
+        :tags => [],
+        :aggregation_key => nil
+      }
+      options = defaults.merge(options)
+
+      @msg_text = msg_text
+      @date_happened = options[:date_happened]
+      @msg_title = options[:msg_title]
+      @priority = options[:priority]
+      @parent = options[:parent]
+      @tags = options[:tags]
+      @aggregation_key = options[:event_object] || options[:aggregation_key]
+      @alert_type = options[:alert_type]
+      @event_type = options[:event_type]
+      @source_type_name = options[:source_type_name]
+    end
+
+    # Copy and pasted from the internets
+    # http://stackoverflow.com/a/5031637/25276
+    def to_hash
+      hash = {}
+      instance_variables.each { |var| hash[var.to_s[1..-1].to_sym] = instance_variable_get(var) }
+      hash
+    end
+  end
+
+  # <b>DEPRECATED:</b> Going forward, use the V1 services. This legacy service will be
+  # removed in an upcoming release.
+  class EventService < DogapiDemo::Service
+
+    API_VERSION = "1.0.0"
+    MAX_BODY_LENGTH = 4000
+    MAX_TITLE_LENGTH = 100
+
+    # <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] DogapiDemo::EventService.submit() has been deprecated in favor of the newer V1 services"
+      scope = scope || DogapiDemo::Scope.new()
+      params = {
+        :api_key => api_key,
+        :api_version  =>  API_VERSION,
+
+        :host =>    scope.host,
+        :device =>  scope.device,
+
+        :metric =>  event.metric,
+        :date_detected => event.date_detected,
+        :date_happened => event.date_happened,
+        :alert_type => event.alert_type,
+        :event_type => event.event_type,
+        :event_object => event.event_object,
+        :msg_title => event.msg_title[0..MAX_TITLE_LENGTH - 1],
+        :msg_text => event.msg_text[0..MAX_BODY_LENGTH - 1],
+        :json_payload => event.json_payload,
+      }
+
+      if source_type
+        params[:source_type] = source_type
+      end
+
+      request Net::HTTP::Post, '/event/submit', params
+    end
+
+    # <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] DogapiDemo::EventService.start() has been deprecated in favor of the newer V1 services"
+      response = submit api_key, event, scope, source_type
+      success = nil
+
+      begin
+        yield response
+      rescue
+        success = false
+        raise
+      else
+        success = true
+      ensure
+        return finish api_key, response['id'], success
+      end
+    end
+
+    private
+
+    def finish(api_key, event_id, successful=nil)
+      params = {
+        :api_key => api_key,
+        :event_id => event_id
+      }
+
+      request Net::HTTP::Post, '/event/ended', params
+    end
+  end
+end

data/lib/dogapi-demo/facade.rb

@@ -0,0 +1,475 @@
+require 'time'
+require 'dogapi-demo/v1'
+
+module DogapiDemo
+
+  # A simple DogAPI client
+  #
+  # See DogapiDemo::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-demo/wiki].
+  class Client
+
+    # Create a new Client optionally specifying a default host and device
+    def initialize(api_key, application_key=nil, host=nil, device=nil, silent=true, timeout=nil)
+
+      if api_key
+        @api_key = api_key
+      else
+        raise 'Please provide an API key to submit your data'
+      end
+
+      @application_key = application_key
+
+      @datadog_host = DogapiDemo.find_datadog_host()
+
+      @host = host ||= DogapiDemo.find_localhost()
+
+      @device = device
+
+      # FIXME: refactor to avoid all this code duplication
+      @metric_svc = DogapiDemo::V1::MetricService.new(@api_key, @application_key, silent, timeout)
+      @event_svc = DogapiDemo::V1::EventService.new(@api_key, @application_key, silent, timeout)
+      @tag_svc = DogapiDemo::V1::TagService.new(@api_key, @application_key, silent, timeout)
+      @comment_svc = DogapiDemo::V1::CommentService.new(@api_key, @application_key, silent, timeout)
+      @search_svc = DogapiDemo::V1::SearchService.new(@api_key, @application_key, silent, timeout)
+      @dash_service = DogapiDemo::V1::DashService.new(@api_key, @application_key, silent, timeout)
+      @alert_svc = DogapiDemo::V1::AlertService.new(@api_key, @application_key, silent, timeout)
+      @user_svc = DogapiDemo::V1::UserService.new(@api_key, @application_key, silent, timeout)
+      @snapshot_svc = DogapiDemo::V1::SnapshotService.new(@api_key, @application_key, silent, timeout)
+      @embed_svc = DogapiDemo::V1::EmbedService.new(@api_key, @application_key, silent, timeout)
+      @screenboard_svc = DogapiDemo::V1::ScreenboardService.new(@api_key, @application_key, silent, timeout)
+      @monitor_svc = DogapiDemo::V1::MonitorService.new(@api_key, @application_key, silent, timeout)
+      @service_check_svc = DogapiDemo::V1::ServiceCheckService.new(@api_key, @application_key, silent, timeout)
+      @legacy_event_svc = DogapiDemo::EventService.new(@datadog_host)
+    end
+
+    #
+    # METRICS
+
+    # Record a single point of metric data
+    #
+    # Optional arguments:
+    #  :timestamp => Ruby stdlib Time
+    #  :host      => String
+    #  :device    => String
+    #  :options   => Map
+    #
+    # options[:type] = "counter" to specify a counter metric
+    # options[:tags] = ["tag1", "tag2"] to tag the point
+    def emit_point(metric, value, options = {})
+      defaults = { :timestamp => Time.now }
+      options = defaults.merge(options)
+
+      self.emit_points(
+        metric,
+        [[options[:timestamp], value]],
+        options
+      )
+    end
+
+    # Record a set of points of metric data
+    #
+    # +points+ is an array of <tt>[Time, value]</tt> doubles
+    #
+    # Optional arguments:
+    #  :host   => String
+    #  :device => String
+    #  :options   => Map
+    #
+    # options[:type] = "counter" to specify a counter metric
+    # options[:tags] = ["tag1", "tag2"] to tag the point
+    def emit_points(metric, points, options = {})
+      scope = override_scope options
+
+      points.each do |p|
+        p[0].kind_of? Time or raise "Not a Time"
+        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(metric, points, scope, options)
+    end
+
+    # Get a set of points by query between from and to
+    #
+    # +from+ The seconds since the unix epoch <tt>[Time, Integer]</tt>
+    # +to+ The seconds since the unix epoch <tt>[Time, Integer]</tt>
+    # +query+ The query string <tt>[String]</tt>
+    #
+    def get_points(query, from, to)
+      @metric_svc.get(query, from, to)
+    end
+
+    def batch_metrics()
+      @metric_svc.switch_to_batched
+      begin
+        yield
+        @metric_svc.flush_buffer # flush_buffer should returns the response from last API call
+      ensure
+        @metric_svc.switch_to_single
+      end
+    end
+
+    #
+    # EVENTS
+
+    # Record an event
+    #
+    # Optional arguments:
+    #  :host        => String
+    #  :device      => String
+    def emit_event(event, options = {})
+      scope = override_scope options
+
+      @event_svc.post(event, scope)
+    end
+
+    # Get the details of an event
+    #
+    # +id+ of the event to get
+    def get_event(id)
+      @event_svc.get(id)
+    end
+
+    # Get an optionally filtered event stream
+    #
+    # +start+ is a Time object for when to start the stream
+    #
+    # +stop+ is a Time object for when to end the stream
+    #
+    # Optional arguments:
+    #   :priority   => "normal" or "low"
+    #   :sources    => String, see https://github.com/DataDog/dogapi-demo/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] DogapiDemo::Client.start_event() is deprecated. Use `emit_event` instead."
+      defaults = { :source_type => nil }
+      options = defaults.merge(options)
+
+      scope = override_scope options
+
+      @legacy_event_svc.start(@api_key, event, scope, options[:source_type]) do
+        yield
+      end
+    end
+
+    #
+    # COMMENTS
+    #
+
+    # Post a comment
+    def comment(message, options = {})
+      @comment_svc.comment(message, options)
+    end
+
+    # Post a comment
+    def update_comment(comment_id, options = {})
+      @comment_svc.update_comment(comment_id, options)
+    end
+
+    def delete_comment(comment_id)
+      @comment_svc.delete_comment(comment_id)
+    end
+
+    #
+    # SEARCH
+    #
+
+    # Run the given search query.
+    def search(query)
+      @search_svc.search query
+    end
+
+
+    #
+    # TAGS
+    #
+
+    # Get all tags and their associated hosts at your org
+    def all_tags(source = nil)
+      @tag_svc.get_all(source)
+    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, source = nil, by_source = false)
+      @tag_svc.get(host_id, source, by_source)
+    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, source = nil)
+      @tag_svc.add(host_id, tags, source)
+    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, source = nil)
+      @tag_svc.update(host_id, tags, source)
+    end
+
+    # <b>DEPRECATED:</b> Spelling mistake temporarily preserved as an alias.
+    def detatch_tags(host_id)
+      warn "[DEPRECATION] DogapiDemo::Client.detatch() is deprecated. Use `detach` instead."
+      detach_tags(host_id)
+    end
+
+    # Remove all tags from the given host
+    #
+    # +host_id+ can be the host's numeric id or string name
+    def detach_tags(host_id, source = nil)
+      @tag_svc.detach(host_id, source)
+    end
+
+    #
+    # DASHES
+    #
+
+    # Create a dashboard.
+    def create_dashboard(title, description, graphs, template_variables = nil)
+      @dash_service.create_dashboard(title, description, graphs, template_variables)
+    end
+
+    # Update a dashboard.
+    def update_dashboard(dash_id, title, description, graphs, template_variables = nil)
+      @dash_service.update_dashboard(dash_id, title, description, graphs, template_variables)
+    end
+
+    # Fetch the given dashboard.
+    def get_dashboard(dash_id)
+      @dash_service.get_dashboard(dash_id)
+    end
+
+    # Fetch all of the dashboards.
+    def get_dashboards
+      @dash_service.get_dashboards
+    end
+
+    # Delete the given dashboard.
+    def delete_dashboard(dash_id)
+      @dash_service.delete_dashboard(dash_id)
+    end
+
+    #
+    # ALERTS
+    #
+
+    def alert(query, options = {})
+      @alert_svc.alert(query, options)
+    end
+
+    def update_alert(alert_id, query, options = {})
+      @alert_svc.update_alert(alert_id, query, options)
+    end
+
+    def get_alert(alert_id)
+      @alert_svc.get_alert(alert_id)
+    end
+
+    def delete_alert(alert_id)
+      @alert_svc.delete_alert(alert_id)
+    end
+
+    def get_all_alerts()
+      @alert_svc.get_all_alerts()
+    end
+
+    def mute_alerts()
+      @alert_svc.mute_alerts()
+    end
+
+    def unmute_alerts()
+      @alert_svc.unmute_alerts()
+    end
+
+    # User invite
+    def invite(emails, options = {})
+      @user_svc.invite(emails, options)
+    end
+
+    def create_user(description = {})
+      @user_svc.create_user(description)
+    end
+
+    def get_all_users()
+      @user_svc.get_all_users()
+    end
+
+    def get_user(handle)
+      @user_svc.get_user(handle)
+    end
+
+    def update_user(handle, description = {})
+      @user_svc.update_user(handle, description)
+    end
+
+    def disable_user(handle)
+      @user_svc.disable_user(handle)
+    end
+
+    # Graph snapshot
+    def graph_snapshot(metric_query, start_ts, end_ts, event_query = nil)
+      @snapshot_svc.snapshot(metric_query, start_ts, end_ts, event_query)
+    end
+
+    #
+    # EMBEDS
+    #
+    def get_all_embeds()
+      @embed_svc.get_all_embeds()
+    end
+
+    def get_embed(embed_id, description= {})
+      @embed_svc.get_embed(embed_id, description)
+    end
+
+    def create_embed(graph_json, description= {})
+      @embed_svc.create_embed(graph_json, description)
+    end
+
+    def enable_embed(embed_id)
+      @embed_svc.enable_embed(embed_id)
+    end
+
+    def revoke_embed(embed_id)
+      @embed_svc.revoke_embed(embed_id)
+    end
+
+    #
+    # SCREENBOARD
+    #
+    def create_screenboard(description)
+      @screenboard_svc.create_screenboard(description)
+    end
+
+    def update_screenboard(board_id, description)
+      @screenboard_svc.update_screenboard(board_id, description)
+    end
+
+    def get_screenboard(board_id)
+      @screenboard_svc.get_screenboard(board_id)
+    end
+
+    def get_all_screenboards()
+      @screenboard_svc.get_all_screenboards()
+    end
+
+    def delete_screenboard(board_id)
+      @screenboard_svc.delete_screenboard(board_id)
+    end
+
+    def share_screenboard(board_id)
+      @screenboard_svc.share_screenboard(board_id)
+    end
+
+    def revoke_screenboard(board_id)
+      @screenboard_svc.revoke_screenboard(board_id)
+    end
+
+    #
+    # MONITORS
+    #
+
+    def monitor(type, query, options = {})
+      @monitor_svc.monitor(type, query, options)
+    end
+
+    def update_monitor(monitor_id, query, options = {})
+      @monitor_svc.update_monitor(monitor_id, query, options)
+    end
+
+    def get_monitor(monitor_id, options = {})
+      @monitor_svc.get_monitor(monitor_id, options)
+    end
+
+    def delete_monitor(monitor_id)
+      @monitor_svc.delete_monitor(monitor_id)
+    end
+
+    def get_all_monitors(options = {})
+      @monitor_svc.get_all_monitors(options)
+    end
+
+    def mute_monitors()
+      @monitor_svc.mute_monitors()
+    end
+
+    def unmute_monitors()
+      @monitor_svc.unmute_monitors()
+    end
+
+    def mute_monitor(monitor_id, options = {})
+      @monitor_svc.mute_monitor(monitor_id, options)
+    end
+
+    def unmute_monitor(monitor_id, options = {})
+      @monitor_svc.unmute_monitor(monitor_id, options)
+    end
+
+    #
+    # MONITOR DOWNTIME
+    #
+
+    def schedule_downtime(scope, options = {})
+      @monitor_svc.schedule_downtime(scope, options)
+    end
+
+    def update_downtime(downtime_id, options = {})
+      @monitor_svc.update_downtime(downtime_id, options)
+    end
+
+    def get_downtime(downtime_id)
+      @monitor_svc.get_downtime(downtime_id)
+    end
+
+    def cancel_downtime(downtime_id)
+      @monitor_svc.cancel_downtime(downtime_id)
+    end
+
+    def get_all_downtimes(options = {})
+      @monitor_svc.get_all_downtimes(options)
+    end
+
+    #
+    # HOST MUTING
+    #
+
+    def mute_host(hostname, options = {})
+      @monitor_svc.mute_host(hostname, options)
+    end
+
+    def unmute_host(hostname)
+      @monitor_svc.unmute_host(hostname)
+    end
+
+    #
+    # SERVICE CHECKS
+    #
+
+    def service_check(check, host, status, options = {})
+      @service_check_svc.service_check(check, host, status, options)
+    end
+
+    private
+
+    def override_scope(options= {})
+      defaults = { :host => @host, :device => @device }
+      options = defaults.merge(options)
+      Scope.new(options[:host], options[:device])
+    end
+  end
+end