dogapi-demo 0.1.0

data/tests/test_alerts.rb

@@ -0,0 +1,38 @@
+require 'dogapi'
+require 'time'
+require 'test_base.rb'
+
+class TestAlerts < Minitest::Test
+  include TestBase
+
+  def test_alerts
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    query = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100'
+
+    alert_id = dog.alert(query)[1]['id']
+    status, alert = dog.get_alert(alert_id)
+    assert_equal alert['query'], query, alert['query']
+    assert_equal alert['silenced'], false, alert['silenced']
+
+    dog.update_alert(alert_id, query, :silenced => true)
+    status, alert = dog.get_alert(alert_id)
+    assert_equal alert['query'], query, alert['query']
+    assert_equal alert['silenced'], true, alert['silenced']
+
+    dog.delete_alert(alert_id)
+
+    query1 = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100'
+    query2 = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200'
+
+    alert_id1 = dog.alert(query1)[1]['id']
+    alert_id2 = dog.alert(query2)[1]['id']
+    status, alerts = dog.get_all_alerts()
+    alerts = alerts['alerts']
+    alert1 = alerts.select {|a| a['id'] == alert_id1}
+    alert2 = alerts.select {|a| a['id'] == alert_id2}
+    assert_equal alert1[0]['query'], query1, alert1
+    assert_equal alert2[0]['query'], query2, alert2
+
+  end
+end

data/tests/test_base.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'dogapi'
+require 'time'
+
+module TestBase
+
+  def config_client_test_env
+    @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()
+  end
+
+  def random
+    Kernel.rand 100000
+  end
+
+  def job_number
+    # Get the Travis ENV and use that to 'seed' the dashboard titles, in attempt
+    # to prevent parallel testing conflicts
+    job_number = ENV['TRAVIS_JOB_NUMBER'] || '1'
+  end
+
+end

data/tests/test_client.rb

@@ -0,0 +1,23 @@
+require 'dogapi'
+require 'time'
+require 'test_base.rb'
+
+class TestClient < Minitest::Test
+  include TestBase
+
+  def test_find_localhost
+    val = Dogapi.find_localhost
+    assert !val.nil?
+  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')
+
+    dog_r.emit_points('test.metric.metric', [[Time.now-60, 20], [Time.now-30, 10], [Time.now, 5]], :tags => ["test:tag.1", "test:tag2"])
+  end
+end

data/tests/test_comments.rb

@@ -0,0 +1,39 @@
+require 'dogapi'
+require 'time'
+require 'test_base.rb'
+
+class TestComments < Minitest::Test
+  include TestBase
+
+
+  def test_comments
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    # Create a comment
+    dog.comment('test comment')
+
+    # Create a comment as a user.
+    handle = "carlo+14.1@datadoghq.com"
+    status, comment_response = dog.comment('test comment with handle', :handle => handle)
+    comment = comment_response["comment"]
+    assert_equal "200", status, "Comment did not succeed, response: #{comment_response}"
+
+    sleep 1
+
+    # Reply to a comment.
+    status, reply_response = dog.comment('replying!', :related_event_id => comment["id"])
+    reply = reply_response["comment"]
+    assert_equal "200", status, "Reply did not work, response: #{reply_response}"
+    # HACK: issue #900 on dogweb. id types should be the same.
+    assert_equal comment["id"].to_s, reply["related_event_id"]
+
+    # Update a comment.
+    dog.update_comment(reply["related_event_id"], :message => "Updating the comment")
+
+    # Delete a comment.
+    status, to_delete_response = dog.comment("im dead")
+    to_delete = to_delete_response["comment"]
+    dog.delete_comment(to_delete["id"])
+
+  end
+end

data/tests/test_dashes.rb

@@ -0,0 +1,85 @@
+require 'dogapi'
+require 'time'
+require 'test_base.rb'
+
+class TestDashes < Minitest::Test
+  include TestBase
+
+  def test_dashes
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    now = Time.now.to_i.to_s
+
+    # Create a dashboard.
+    title = "foobar-#{job_number}-#{now}"
+    description = 'desc'
+    graphs =  [{
+      "definition" => {
+        "events" => [],
+        "requests" => [
+          {"q" => "avg:system.mem.free{*}"}
+        ],
+        "viz" => "timeseries"
+      },
+      "title" => "Average Memory Free"
+    }]
+
+    status, dash_response = dog.create_dashboard(title, description, graphs)
+    assert_equal "200", status, "Creation failed, response: #{dash_response}"
+
+    dash_id = dash_response["dash"]["id"]
+
+    # Fetch the dashboard and assert all is well.
+    status, dash_response = dog.get_dashboard(dash_id)
+    assert_equal "200", status, "Fetch failed, response: #{dash_response}"
+    dash = dash_response["dash"]
+    assert_equal title, dash["title"]
+    assert_equal description, dash["description"]
+    assert_equal graphs, dash["graphs"]
+
+    # Update the dashboard.
+    title = "blahfoobar-#{job_number}-#{now}"
+    description = 'asdfdesc'
+    graphs =  [{
+      "definition" => {
+        "events" => [],
+        "requests" => [
+          {"q" => "sum:system.mem.free{*}"}
+        ],
+        "viz" => "timeseries"
+      },
+      "title" => "Sum Memory Free"
+    }]
+    tpl_vars = [{"default" => nil, "prefix" => nil, "name" => "foo"},
+                {"default" => nil, "prefix" => nil, "name" => "bar"}]
+
+    status, dash_response = dog.update_dashboard(dash_id, title, description, graphs, tpl_vars)
+    assert_equal "200", status, "Updated failed, response: #{dash_response}"
+
+    # Fetch the dashboard and assert all is well.
+    status, dash_response = dog.get_dashboard(dash_id)
+    assert_equal "200", status, "Fetch failed, response: #{dash_response}"
+    dash = dash_response["dash"]
+    assert_equal title, dash["title"]
+    assert_equal description, dash["description"]
+    assert_equal graphs, dash["graphs"]
+    assert_equal tpl_vars, dash["template_variables"]
+
+    # Fetch all the dashboards, assert our created one is in the list of all
+    status, dash_response = dog.get_dashboards()
+    assert_equal "200", status, "fetch failed, response: #{dash_response}"
+    dashes = dash_response["dashes"]
+    assert dashes.any? { |d| title == d["title"] }
+    dash = dashes.find { |d| title == d["title"] }
+    assert_equal title, dash["title"]
+    assert_equal dash_id.to_s, dash["id"]
+
+    # Delete the dashboard.
+    status, dash_response = dog.delete_dashboard(dash_id)
+    assert_equal "204", status, "Deleted failed, response: #{dash_response}"
+
+    # Fetch the dashboard and assert all it's gone.
+    status, dash_response = dog.get_dashboard(dash_id)
+    assert_equal "404", status, "Still there failed, response: #{dash_response}"
+
+  end
+end

data/tests/test_embed.rb

@@ -0,0 +1,194 @@
+require 'dogapi'
+require 'time'
+require 'test_base.rb'
+
+class TestEmbed < Minitest::Test
+  include TestBase
+
+  def test_get_all_embeds
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    # Attempt API Call
+    status, result = dog.get_all_embeds()
+    # Sanity check results
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    assert result.has_key?("embedded_graphs")
+  end
+
+  def test_create_embed
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    # create an embed using the embed id and verify that it is valid
+    graph_json = '{
+      "viz": "toplist",
+      "requests": [{
+        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
+        "style": {
+          "palette": "dog_classic"
+        },
+        "conditional_formats": [{
+          "palette": "red",
+          "comparator": ">",
+          "value": 50000000000
+        }, {
+          "palette": "green",
+          "comparator": ">",
+          "value": 30000000000
+        }]
+      }]
+    }'
+    timeframe = "1_hour"
+    size = "medium"
+    legend = "no"
+    title = "Sick Title!"
+    description = {
+      :timeframe => timeframe,
+      :size => size,
+      :legend => legend,
+      :title => title
+    }
+    status, result = dog.create_embed(graph_json, description)
+    # Sanity check results
+    assert result["graph_title"] == title
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    assert result["html"].include? "legend=false"
+    assert result["html"].include? "height=300"
+    assert result["html"].include? "width=600"
+  end
+
+  def test_get_embed
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    # Create an Embed to get a valid embed_id
+    graph_json = '{
+      "viz": "toplist",
+      "requests": [{
+        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
+        "style": {
+          "palette": "dog_classic"
+        },
+        "conditional_formats": [{
+          "palette": "red",
+          "comparator": ">",
+          "value": 50000000000
+        }, {
+          "palette": "green",
+          "comparator": ">",
+          "value": 30000000000
+        }]
+      }]
+    }'
+    timeframe = "1_hour"
+    size = "medium"
+    legend = "no"
+    title = "Sick Title!"
+    description = {
+      :timeframe => timeframe,
+      :size => size,
+      :legend => legend,
+      :title => title
+    }
+    status, create_result = dog.create_embed(graph_json, description)
+    # Sanity check results
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    assert create_result["html"].include? "legend=false"
+    assert create_result["html"].include? "height=300"
+    assert create_result["html"].include? "width=600"
+    embed_id = create_result["embed_id"]
+    # Get the embed using that embed id
+    status, embed_without_var = dog.get_embed(embed_id)
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    get_embed_description = {
+      :size => size,
+      :legend => legend,
+      :var => "val"
+    }
+    status, embed_with_var = dog.get_embed(embed_id, get_embed_description)
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    # Verify that the get requests are good
+    assert embed_without_var["html"] == create_result["html"]
+    assert embed_with_var["html"] != embed_without_var["html"]
+    assert embed_with_var["html"].include? "legend=false"
+    assert embed_with_var["html"].include? "height=300"
+    assert embed_with_var["html"].include? "width=600"
+    assert embed_with_var["html"].include? "var=val"
+  end
+
+  def test_enable_embed
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    # Create an Embed to get a valid embed_id
+    graph_json = '{
+      "viz": "toplist",
+      "requests": [{
+        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
+        "style": {
+          "palette": "dog_classic"
+        },
+        "conditional_formats": [{
+          "palette": "red",
+          "comparator": ">",
+          "value": 50000000000
+        }, {
+          "palette": "green",
+          "comparator": ">",
+          "value": 30000000000
+        }]
+      }]
+    }'
+    timeframe = "1_hour"
+    size = "medium"
+    legend = "no"
+    title = "Sick Title!"
+    description = {
+      :timeframe => timeframe,
+      :size => size,
+      :legend => legend,
+      :title => title
+    }
+    status, create_result = dog.create_embed(graph_json, description)
+    # Sanity check results
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    embed_id = create_result["embed_id"]
+    status, result = dog.enable_embed(embed_id)
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    assert result.has_key?("success")
+  end
+
+  def test_revoke_embed
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    # Create an Embed to get a valid embed_id
+    graph_json = '{
+      "viz": "toplist",
+      "requests": [{
+        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
+        "style": {
+          "palette": "dog_classic"
+        },
+        "conditional_formats": [{
+          "palette": "red",
+          "comparator": ">",
+          "value": 50000000000
+        }, {
+          "palette": "green",
+          "comparator": ">",
+          "value": 30000000000
+        }]
+      }]
+    }'
+    timeframe = "1_hour"
+    size = "medium"
+    legend = "no"
+    title = "Sick Title!"
+    description = {
+      :timeframe => timeframe,
+      :size => size,
+      :legend => legend,
+      :title => title
+    }
+    status, create_result = dog.create_embed(graph_json, description)
+    # Sanity check results
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    embed_id = create_result["embed_id"]
+    status, result = dog.revoke_embed(embed_id)
+    assert_equal status, "200", "invalid HTTP response => #{status}"
+    assert result.has_key?("success")
+  end
+end

data/tests/test_monitors.rb

@@ -0,0 +1,192 @@
+require 'dogapi'
+require 'time'
+require 'test_base.rb'
+
+class TestAlerts < Minitest::Test
+  include TestBase
+
+  def test_metric_alerts
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    query = 'sum(last_1d):sum:system.net.bytes_rcvd{host:host0} > 100'
+    options = {
+        'silenced' => {'*' => nil},
+        'notify_no_data' => false
+    }
+
+    monitor_id = dog.monitor('metric alert', query, :options=>options)[1]['id']
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['query'], query, monitor['query']
+    assert_equal monitor['options']['silenced'], options['silenced'], monitor['options']
+
+    query2 = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200'
+    updated_monitor_id = dog.update_monitor(monitor_id, query2,
+                                :options => options)[1]['id']
+    status, monitor = dog.get_monitor(updated_monitor_id)
+    assert_equal monitor['query'], query2, monitor['query']
+
+    name = 'test_monitors'
+    monitor_id = dog.update_monitor(monitor_id, query2, :name => name,
+        :options=>{'notify_no_data' => true})[1]['id']
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['name'], name, monitor['name']
+    assert_equal monitor['options']['notify_no_data'], true, monitor['options']
+
+    dog.delete_monitor(monitor_id)
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal status.to_i, 404, status.to_i
+
+    query1 = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100"
+    query2 = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200"
+    query3 = "avg(last_1h):sum:system.net.bytes_rcvd{host:host1} > 200"
+
+    monitor_id1 = dog.monitor('metric alert', query1)[1]['id']
+    monitor_id2 = dog.monitor('metric alert', query2)[1]['id']
+    monitor_id3 = dog.monitor('metric alert', query3)[1]['id']
+    status, monitors = dog.get_all_monitors(:group_states => ['alert', 'warn'])
+    monitor1 = monitors.map{|m| m if m['id'] == monitor_id1}.compact[0]
+    monitor2 = monitors.map{|m| m if m['id'] == monitor_id2}.compact[0]
+    assert_equal monitor1['query'], query1, monitor1['query']
+    assert_equal monitor2['query'], query2, monitor2['query']
+
+    status, monitors = dog.get_all_monitors(:tags => ['host:host1'])
+    monitor3 = monitors.map{|m| m if m['id'] == monitor_id3}.compact[0]
+    assert_equal monitor3['query'], query3, monitor3['query']
+    assert_equal nil, monitors.map{|m| m if m['id'] == monitor_id1}.compact[0]
+    assert_equal nil, monitors.map{|m| m if m['id'] == monitor_id2}.compact[0]
+
+    dog.delete_monitor(monitor_id1)
+    dog.delete_monitor(monitor_id2)
+    dog.delete_monitor(monitor_id3)
+  end
+
+  def test_checks
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    query = '"ntp.in_sync".over("role:herc").last(3).count_by_status()'
+    options = {
+        'notify_no_data' => false,
+        'thresholds' => {
+            'ok' => 3,
+            'warning' => 2,
+            'critical' => 1,
+            'no data' => 3
+        }
+    }
+    monitor_id = dog.monitor('service check', query, :options => options)[1]['id']
+    status, monitor = dog.get_monitor(monitor_id, :group_states => ['all'])
+
+    assert_equal monitor['query'], query, monitor['query']
+    assert_equal monitor['options']['notify_no_data'], options['notify_no_data'], monitor['options']
+    assert_equal monitor['options']['thresholds'], options['thresholds'], monitor['options']
+
+    query2 = '"ntp.in_sync".over("role:sobotka").last(3).count_by_status()'
+    monitor_id = dog.update_monitor(monitor_id, query2)[1]['id']
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['query'], query2, monitor['query']
+
+    dog.delete_monitor(monitor_id)
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal status.to_i, 404, status.to_i
+  end
+
+  def test_monitor_muting
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    query = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100'
+    monitor_id = dog.monitor('metric alert', query)[1]['id']
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['query'], query, monitor['query']
+
+    status, dt = dog.mute_monitors()
+    assert_equal dt['active'], true, dt['active']
+    assert_equal dt['scope'], ['*'], dt['scope']
+
+    status, dt = dog.unmute_monitors()
+    assert_equal status.to_i, 204, status.to_i
+
+    # We shouldn't be able to mute a simple alert on a scope.
+    status, _ = dog.mute_monitor(monitor_id, :scope => 'env:staging')
+    assert_equal status.to_i, 400, status.to_i
+
+    query2 = 'avg(last_1h):sum:system.net.bytes_rcvd{*} by {host} > 100'
+    monitor_id = dog.monitor('metric alert', query2)[1]['id']
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['query'], query2, monitor['query']
+
+    dog.mute_monitor(monitor_id, :scope => 'host:foo')
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['options']['silenced'], {'host:foo' => nil}, monitor['options']
+
+    dog.unmute_monitor(monitor_id, :scope => 'host:foo')
+    status, monitor = dog.get_monitor(monitor_id)
+    assert_equal monitor['options']['silenced'], {}, monitor['options']
+
+    dog.delete_monitor(monitor_id)
+  end
+
+  def test_downtime
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    start_ts = Time.now.to_i
+    end_ts = start_ts + 1000
+    downtime_id = dog.schedule_downtime('env:staging', :start => start_ts,
+                                        :end => end_ts, :message=>'Message!')[1]['id']
+    status, dt = dog.get_downtime(downtime_id)
+    assert_equal dt['start'], start_ts, dt['start']
+    assert_equal dt['end'], end_ts, dt['end']
+    assert_equal dt['scope'], ['env:staging'], dt['scope']
+    assert_equal dt['message'], 'Message!', dt['messsage']
+
+    dog.update_downtime(downtime_id, :start => start_ts + 1, :end => end_ts + 1,
+                        :scope => 'env:prod', :message => 'New Message!')
+    status, dt = dog.get_downtime(downtime_id)
+    assert_equal dt['start'], start_ts + 1, dt['start']
+    assert_equal dt['end'], end_ts + 1, dt['end']
+    assert_equal dt['scope'], ['env:prod'], dt['scope']
+    assert_equal dt['message'], 'New Message!', dt['messsage']
+
+    dog.cancel_downtime(downtime_id)
+  end
+
+  def test_host_muting
+    dog = Dogapi::Client.new(@api_key, @app_key)
+
+    hostname = 'test.host%d' % rand(10000)
+
+    # Reset test
+    dog.unmute_host(hostname)
+
+    message = "Muting this host for a test."
+    end_ts = Time.now.to_i + 60 * 60
+
+    res_code, res = dog.mute_host(hostname, :end => end_ts, :message => message)
+    assert_equal res_code, "200", res_code
+    assert_equal res["action"], "Muted", res["action"]
+    assert_equal res["hostname"], hostname, res["hostname"]
+    assert_equal res["message"], message, res["message"]
+    assert_equal res["end"], end_ts, res["end"]
+
+    # muting the same host multiple times should fail unless override is true
+    end_ts2 = end_ts + 60 * 15
+    res_code, res = dog.mute_host(hostname, :end => end_ts2)
+    assert_equal res_code, "400", res_code
+
+    res_code, res = dog.mute_host(hostname, :end => end_ts2, :override => true)
+    assert_equal res_code, "200", res_code
+    assert_equal res["action"], "Muted", res["action"]
+    assert_equal res["hostname"], hostname, res["hostname"]
+    assert_equal res["end"], end_ts2, res["end"]
+
+    res_code, res = dog.unmute_host(hostname)
+    assert_equal res_code, "200", res_code
+    assert_equal res["action"], "Unmuted", res["action"]
+    assert_equal res["hostname"], hostname, res["hostname"]
+  end
+
+  def test_service_checks
+    dog = Dogapi::Client.new(@api_key, @app_key)
+    status, response = dog.service_check('app.ok', 'app1', 1)
+    assert_equal status.to_i, 202
+  end
+
+end