dogapi-demo 0.1.0

data/Rakefile

@@ -0,0 +1,50 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+
+default_tests = [:spec, :test]
+
+case RbConfig::CONFIG['ruby_version']
+when -> (version) { version.start_with?("2.3") }
+  # Not compatible with Ruby 2.3.x
+else
+  require 'tailor/rake_task'
+  default_tests.unshift(:tailor)
+
+  Tailor::RakeTask.new do |task|
+    task.file_set 'lib/**/*.rb', :code do |style|
+      style.max_line_length 160, :level => :warn
+      style.max_code_lines_in_method 40, :level => :warn
+    end
+    task.file_set 'spec/**/*.rb', :tests do |style|
+      style.max_line_length 160, :level => :warn
+      style.max_code_lines_in_method 40, :level => :warn
+    end
+  end
+
+end
+
+task :default => default_tests
+
+Rake::TestTask.new(:test) do |test|
+  test.libs.push 'lib'
+  test.libs.push 'tests'
+  test.test_files = FileList['tests/test_*.rb']
+end
+
+# Doc stuff
+RDoc::Task.new do |rd|
+  rd.main = 'README.rdoc'
+  rd.rdoc_files.include('README.rdoc', 'lib/**/*.rb', 'CHANGELOG.md')
+  rd.options << '--line-numbers' << '--inline-source'
+  rd.rdoc_dir = 'doc'
+  rd.title = 'DogAPI -- DataDog Client'
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Find notes in code"
+task :notes do
+  puts `grep --exclude=Rakefile -r 'OPTIMIZE:\\|FIXME:\\|TODO:' .`
+end

data/dogapi-demo.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dogapi-demo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dogapi-demo'
+  spec.version       = DogapiDemo::VERSION
+  spec.authors       = ['Datadog, Inc.']
+  spec.email         = ['packages@datadoghq.com']
+  spec.description   = 'Ruby bindings for Datadog\'s API'
+  spec.summary       = spec.description
+  spec.homepage      = 'http://datadoghq.com/'
+  spec.license       = 'BSD'
+
+  spec.files         = `git ls-files`.split($\)
+  spec.executables   = spec.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = ['README.rdoc']
+  spec.rdoc_options << '--title' << 'DogAPI -- Datadog Client' <<
+                    '--main' << 'README.rdoc' <<
+                    '--line-numbers' << '--inline-source'
+
+  spec.add_dependency 'multi_json'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake', '~> 10'
+  spec.add_development_dependency 'rdoc'
+end

data/examples/Capfile

@@ -0,0 +1,19 @@
+require 'capistrano/setup'
+require 'capistrano/datadog'
+
+set :datadog_api_key, 'my_api_key'
+set :stage, :test
+# set :format, :pretty
+# set :log_level, :info
+# set :pty, true
+
+server "host0", roles: ["thing"]
+server "host1", roles: ["other_thing"]
+
+desc "Hello world"
+task :hello do
+  on roles(:all) do |host|
+    info capture('echo "$(date): Hello from $(whoami)@$(hostname) !"')
+  end
+end
+

data/examples/custom_event.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'dogapi'
+
+# Create a simple client
+# The host is optional here, it's a shortcut to tie event and metrics to a given host
+#
+# You typically want to do:
+#   Dogapi::Client.new(your_actual_api_key_as_a_string, ...)
+# We are using ENV to let you experiment via an environment variable.
+dog = Dogapi::Client.new(ENV['DATADOG_KEY'])
+
+# Let's use tags and aggregation
+# We will send 2 related events, one error and one success.
+
+dog.emit_event(Dogapi::Event.new("Uh-oh, something bad happened",
+                                 :msg_title       => "Alert! Alert!",
+                                 :aggregation_key => "job-123",
+                                 :alert_type      => "error",
+                                 :tags            => ["ruby", "dogapi"]
+                                 ))
+
+dog.emit_event(Dogapi::Event.new("Now that's better",
+                                 :msg_title       => "All systems green",
+                                 :aggregation_key => "job-123",
+                                 :alert_type      => "success",
+                                 :tags            => ["ruby", "dogapi"]
+                                 ))
+
+# You should see something like this in your stream:
+# screenshot: https://img.skitch.com/20120705-3s4icgxfc689x1jtrx1yr1m5k.png
+
+# And if you graph a metric and want to overlay these events on the graphs
+# You can use the following query: "tags:dogapi tags:ruby" in the graph editor
+# screenshot: https://img.skitch.com/20120705-m4h6f4377cbm2d3rctnd6biej9.png
+
+# Then you can see the events neatly overlaid on your graph
+# screenshot: https://img.skitch.com/20120705-xybhimti31u4s4m42ac854568h.png

data/examples/custom_metric.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'dogapi'
+
+# Create a simple client
+# The host is optional here, it's a shortcut to tie event and metrics to a given host
+#
+# You typically want to do:
+#   Dogapi::Client.new(your_actual_api_key_as_a_string, ...)
+# We are using ENV to let you experiment via an environment variable.
+dog = Dogapi::Client.new(ENV['DATADOG_KEY'])
+
+# Emit points one by one, timestamp is omitted and is the time this call is made.
+dog.emit_point('test.api.test_metric', 4.0)
+
+sleep 1
+
+dog.emit_point('test.api.test_metric', 5.0)
+
+# Emit a list of points in one go as a list of (timestamp, value)
+# here we pretend to send a point a minute for the past hour
+now = Time.now
+points = (0...60).map do |i|
+  i = 60 - i
+  t = now - (i*60)
+  [t, Math.cos(i) + 1.0]
+end
+
+# And emit the data in one call
+dog.emit_points('test.api.test_metric', points)
+
+# Emit differents metrics in a single request to be more efficient
+dog.batch_metrics do
+  dog.emit_point('test.api.test_metric',10)
+  dog.emit_point('test.api.this_other_metric', 1, :type => 'counter')
+end

data/lib/capistrano/README.md

@@ -0,0 +1,13 @@
+# capistrano/datadog
+
+Instrument your [Capistrano](https://github.com/capistrano/capistrano) deploys, generating events in Datadog which you can correlate with metrics in order to figure out what caused production issues.
+
+To set up your Capfile:
+
+    require "capistrano/datadog"
+    set :datadog_api_key, "my_api_key"
+
+You can find your Datadog API key [here](https://app.datadoghq.com/account/settings#api). If you don't have a Datadog account, you can sign up for one [here](http://www.datadoghq.com/).
+
+`capistrano/datadog` will capture each Capistrano task that that Capfile runs, including the roles that the task applies to and any logging output that it emits and submits them as events to Datadog at the end of the execution of all the tasks. If sending to Datadog fails for any reason, your scripts will still succeed.
+

data/lib/capistrano/datadog.rb

@@ -0,0 +1,125 @@
+require "etc"
+require "digest/md5"
+require "timeout"
+
+require "dogapi"
+
+module Capistrano
+  module Datadog
+    # Singleton method for Reporter
+    def self.reporter()
+      @reporter || @reporter = Reporter.new
+    end
+
+    def self.cap_version()
+      if @cap_version.nil? then
+        if Configuration.respond_to? :instance then
+          @cap_version = :v2
+        else
+          @cap_version = :v3
+        end
+      end
+      @cap_version
+    end
+
+    def self.submit(api_key)
+      begin
+        if api_key
+          dog = Dogapi::Client.new(api_key)
+          reporter.report.each do |event|
+            dog.emit_event event
+          end
+        else
+          puts "No api key set, not submitting to Datadog"
+        end
+      rescue Timeout::Error => e
+        puts "Could not submit to Datadog, request timed out."
+      rescue => e
+        puts "Could not submit to Datadog: #{e.inspect}\n#{e.backtrace.join("\n")}"
+      end
+    end
+
+    # Collects info about the tasks that ran in order to submit to Datadog
+    class Reporter
+      attr_accessor :current_task
+
+      def initialize()
+        @tasks = []
+        @current_task = nil
+        @logging_output = {}
+      end
+
+      def record_task(task_name, timing, roles, stage=nil, application_name=nil)
+        @tasks << {
+          :name   => task_name,
+          :timing => timing,
+          :roles  => roles,
+          :stage  => stage,
+          :application => application_name
+        }
+      end
+
+      def record_log(message)
+        if not @logging_output[@current_task]
+          @logging_output[@current_task] = []
+        end
+        @logging_output[@current_task] << message
+      end
+
+      def report()
+        hostname = %x[hostname -f].strip
+        user = Etc.getlogin
+
+        # Lazy randomness
+        aggregation_key = Digest::MD5.hexdigest "#{Time.new}|#{rand}"
+
+        # Convert the tasks into Datadog events
+        @tasks.map do |task|
+          name  = task[:name]
+          roles = Array(task[:roles]).map(&:to_s).sort
+          tags  = ["#capistrano"] + (roles.map { |t| '#role:' + t })
+          if !task[:stage].nil? and !task[:stage].empty? then
+            tags << "#stage:#{task[:stage]}"
+          end
+          application = ''
+          if !task[:application].nil? and !task[:application].empty? then
+            application = ' for ' + task[:application]
+          end
+          title = "%s@%s ran %s%s on %s with capistrano in %.2f secs" % [user, hostname, name, application, roles.join(', '), task[:timing]]
+          type  = "deploy"
+          alert_type = "success"
+          source_type = "capistrano"
+          message_content = (@logging_output[name] || []).join('')
+          message = if !message_content.empty? then
+            # Strip out color control characters
+            message_content = sanitize_encoding(message_content).gsub(/\e\[(\d+)m/, '')
+            "@@@\n#{message_content}@@@" else "" end
+
+          Dogapi::Event.new(message,
+            :msg_title        => title,
+            :event_type       => type,
+            :event_object     => aggregation_key,
+            :alert_type       => alert_type,
+            :source_type_name => source_type,
+            :tags             => tags
+          )
+        end
+      end
+
+      def sanitize_encoding(string)
+        return string unless defined?(::Encoding) && string.encoding == Encoding::BINARY
+        string.encode(Encoding::UTF_8, Encoding::BINARY, invalid: :replace, undef: :replace, replace: '')
+      end
+    end
+
+  end
+end
+
+case Capistrano::Datadog::cap_version
+when :v2
+  require 'capistrano/datadog/v2'
+when :v3
+  require 'capistrano/datadog/v3'
+else
+  puts "Unknown version: #{Capistrano::Datadog::cap_version.inspect}"
+end

data/lib/capistrano/datadog/v2.rb

@@ -0,0 +1,74 @@
+require "benchmark"
+require "delegate"
+
+# Capistrano v2
+
+# Monkeypatch capistrano to collect data about the tasks that it's running
+module Capistrano
+  class Configuration
+    module Execution
+      # Attempts to locate the task at the given fully-qualified path, and
+      # execute it. If no such task exists, a Capistrano::NoSuchTaskError
+      # will be raised.
+      # Also, capture the time the task took to execute, and the logs it
+      # outputted for submission to Datadog
+      def find_and_execute_task(path, hooks = {})
+        task = find_task(path) or raise NoSuchTaskError, "the task `#{path}' does not exist"
+        result = nil
+        reporter = Capistrano::Datadog.reporter
+        task_name = task.fully_qualified_name
+        timing = Benchmark.measure(task_name) do
+          # Set the current task so that the logger knows which task to
+          # associate the logs with
+          reporter.current_task = task_name
+          trigger(hooks[:before], task) if hooks[:before]
+          result = execute_task(task)
+          trigger(hooks[:after], task) if hooks[:after]
+          reporter.current_task = nil
+        end
+
+        # Record the task name, its timing and roles
+        roles = task.options[:roles]
+        if roles.is_a? Proc
+          roles = roles.call
+        end
+        reporter.record_task(task_name, timing.real, roles, task.namespace.variables[:stage], fetch(:application))
+
+        # Return the original result
+        result
+      end
+    end
+  end
+
+  class Logger
+    # Make the device attribute writeable so we can swap it out
+    # with something that captures logging out by task
+    attr_accessor   :device
+  end
+end
+
+
+module Capistrano
+  module Datadog
+    class LogCapture < SimpleDelegator
+      def puts(message)
+        Capistrano::Datadog::reporter.record_log message
+        __getobj__.puts message
+      end
+    end
+
+    Configuration.instance(:must_exist).load do
+      # Wrap the existing logging target with the Datadog capture class
+      logger.device = Datadog::LogCapture.new logger.device
+
+      # Trigger the Datadog submission once all the tasks have run
+      on :exit, "datadog:submit"
+      namespace :datadog do
+        desc "Submit the tasks that have run to Datadog as events"
+        task :submit do |ns|
+          Capistrano::Datadog.submit variables[:datadog_api_key]
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/datadog/v3.rb

@@ -0,0 +1,64 @@
+require "benchmark"
+require "sshkit/formatters/pretty"
+require "sshkit/formatters/simple_text"
+
+# Capistrano v3 uses Rake's DSL instead of its own
+
+module Rake
+  class Task
+    alias old_invoke invoke
+    def invoke(*args)
+      result = nil
+      reporter = Capistrano::Datadog.reporter
+      task_name = name
+      reporter.current_task = task_name
+      timing = Benchmark.measure(task_name) do
+        result = old_invoke(*args)
+      end
+      reporter.record_task(task_name, timing.real, roles,
+        Capistrano::Configuration.env.fetch(:stage), Capistrano::Configuration.env.fetch(:application))
+      result
+    end
+  end
+end
+
+module Capistrano
+  module Datadog
+    class CaptureIO
+      def initialize(wrapped)
+        @wrapped = wrapped
+      end
+
+      def write(*args)
+        @wrapped.write(*args)
+        args.each { |arg| Capistrano::Datadog.reporter.record_log(arg) }
+      end
+      alias :<< :write
+
+      def close
+        @wrapped.close
+      end
+    end
+  end
+end
+
+module SSHKit
+  module Formatter
+    class Pretty
+      def initialize(oio)
+        super(Capistrano::Datadog::CaptureIO.new(oio))
+      end
+    end
+
+    class SimpleText
+      def initialize(oio)
+        super(Capistrano::Datadog::CaptureIO.new(oio))
+      end
+    end
+  end
+end
+
+at_exit do
+  api_key = Capistrano::Configuration.env.fetch :datadog_api_key
+  Capistrano::Datadog.submit api_key
+end