snitcher 0.3.2 → 0.4.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27871ec34b5ab2bb24c584562a646931855745d4
-  data.tar.gz: 82156be355ece58115b1880651c98aa14ec47d60
+  metadata.gz: 31fd69148d1e700f8fb0530699877e3efc5fad4b
+  data.tar.gz: cd47d65eb4574061cab9352d6de6818cdbc591dc
 SHA512:
-  metadata.gz: 3bf4288bea7ae411853643790614e4fa7850f0ba57f9586e8e57170852198e8e67d64900832e1b16f8e0c4cf0c1dea495872c792aa690c4d73f40ced3fe86c65
-  data.tar.gz: 9b1dbe9bde047d543996ad4bb14025a4058559cf8ecad36f46aaf183a83cbc052007ce8a93b97cb907ec15737ca8b0657cd4f01e7b6b1b8f404fa1991c2eced4
+  metadata.gz: 934c98e32c1880697ecd3e13d50c4296b843de6fd85c7625ed150117c07cbbb2391fc7efc3c221efad17abe20a31caabd5bc1c14a7abe40941697ab585da6bfd
+  data.tar.gz: d6c37d3f7ff629ba62c2a6cf79254998a6a528ce85d63ab8104c3abcd129d509eaeae7a21f5d6182d9edb91746de7dba9ba26c01758d6d050b3e4eb8fdb53975

data/.travis.yml

@@ -5,9 +5,18 @@ language: ruby
 matrix:
   allow_failures:
     - rvm: ruby-head
+
+before_install:
+  - gem install bundler
+
+# Disable support for sudo to get faster builds with Docker
+sudo: false
+
 rvm:
   - 1.9.3
   - 2.0.0
   - 2.1
   - 2.2
+  - 2.3.0
+  - jruby
   - ruby-head

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## 0.3.1 / TBD
+## 0.4.0 / TBD
+* [FEATURE] Add Snitcher::API for integrating with the DMS API ([[@danabrit](https://github.com/danabrit))
+
+## 0.3.2 / 2015-08-13
+* [BUG] Fixed passing messaging during a check-in ([@ryoung](https://github.com/ryoung))
+
+## 0.3.1 / 2015-06-23
 * [ENHANCEMENT] Add a custom User-Agent
 
 ## 0.3.0 / 2014-10-14

data/Gemfile

@@ -2,8 +2,12 @@ source "https://rubygems.org"
 
 gemspec
 
+group :development do
+  gem "pry"
+end
+
 group :test do
-  gem "coveralls", "~> 0.7", require: false
-  gem "rspec", "~> 2.14"
-  gem "webmock", "~> 1.17"
+  gem "coveralls", require: false
+  gem "rspec"
+  gem "webmock"
 end

data/README.md

@@ -23,27 +23,163 @@ You also may provide a message with the check in:
 Snitcher.snitch("c2354d53d2", message: "Finished in 23.8 seconds.")
 ```
 
-The default timeout of 2 seconds can be overridden:
+The default timeout of 5 seconds can be overridden:
 
 ```ruby
 Snitcher.snitch("c2354d53d2", timeout: 10)
 ```
 
-## Command Line Tool
+## API Access
 
-You can also check in from the command line:
+### Retrieving Your API Key At Command Line
 
-```bash
-$ snitch c2354d53d2
+```ruby
+require "snitcher/api"
+
+key = Snitcher::API.get_key("jane@example.com", "password")
 ```
 
-If you want to include a message, use the `-m` or `--message` flag.
+Returns an authentication key to access the api.
+
+### Setup
+
+Initialize the API client directly with your api key:
+
+```ruby
+require "snitcher/api"
 
-```bash
-$ snitch c2354d53d2 -m "Finished in 23.8 seconds."
-$ snitch c2354d53d2 --message "Finished in 23.8 seconds."
+client = Snitcher::API::Client.new("my_awesome_key")
 ```
 
+#### Heroku
+
+Dead Man's Snitch exposes the `DEADMANSSNITCH_API_KEY` environment variable for
+accessing the API.
+
+```ruby
+require "snitcher/api"
+
+client = Snitcher::API::Client.new(ENV["DEADMANSSNITCH_API_KEY"])
+```
+
+### Listing Snitches
+
+```ruby
+client.snitches
+```
+
+Returns an array of snitches.
+
+### Retrieve a Single Snitch
+
+```ruby
+token = "c2354d53d2"
+client.snitch(token)
+```
+
+Returns a snitch.
+
+### Retrieve Snitches That Match a Set of Tags
+
+```ruby
+tags = ["critical", "sales"]
+client.tagged_snitches(tags)
+```
+
+Returns an array of snitches.
+
+### Create a Snitch
+
+Required attributes are name and interval. Optional attributes are notes and tags.
+
+```ruby
+attributes = { "name": "Nightly User Data Backups",
+  "interval": "daily",
+  "notes": "User login and usage data",
+  "tags": ["users", "critical"]
+}
+client.create_snitch(attributes)
+```
+
+Returns the newly-created snitch.
+
+### Edit a Snitch
+
+You only need to pass the edit_snitch function the attributes you want to change. The rest of a snitch's attributes will remain the same.
+
+```ruby
+token = "c2354d53d2"
+new_attributes = { "name": "Important Nightly User Data Backups" }
+client.edit_snitch(token, new_attributes)
+```
+
+Returns the edited snitch.
+
+### Adding Tags to a Snitch
+
+This function adds tags to a snitch, retaining whatever tags it already has.
+
+```ruby
+token = "c2354d53d2"
+tags = ["spring_campaign", "support"]
+client.add_tags(token, tags)
+```
+
+Returns an array of all of the snitch's tags.
+
+### Deleting a Tag From a Snitch
+
+This function is for deleting a single tag from a snitch.
+
+```ruby
+token = "c2354d53d2"
+tag = "support"
+client.remove_tag(token, tag)
+```
+
+Returns an array of all of the snitch's remaining tags.
+
+### Replace Tags on a Snitch
+
+Replaces all of a snitch's tags with an array of new tags.
+
+```ruby
+token = "c2354d53d2"
+tags = ["csv", "server_a"]
+client.replace_tags(token, tags)
+```
+
+Returns the updated snitch.
+
+### Remove Tags From a Snitch
+
+Removes all of a snitch's tags.
+
+```ruby
+token = "c2354d53d2"
+client.clear_tags(token)
+```
+
+Returns the updated snitch.
+
+### Pause a Snitch
+
+```ruby
+token = "c2354d53d2"
+client.pause_snitch(token)
+```
+
+Returns a hash with a `message` key, whose value is "Response complete".
+
+### Delete a Snitch
+
+```ruby
+token = "c2354d53d2"
+client.delete_snitch(token)
+```
+
+Returns a hash with a `message` key, whose value is "Response complete".
+
 ## Contributing
 
 Snitcher is open source and contributions from the community are encouraged! No

data/bin/snitch

@@ -24,7 +24,7 @@ if token
   print "Snitching #{token} ... "
 
   opts = {
-    :message => params[:message]
+    message: params[:message]
   }
 
   if Snitcher.snitch(token, opts)

data/lib/snitcher.rb

@@ -1,16 +1,18 @@
 require "uri"
 require "timeout"
 require "net/http"
+require "snitcher/version"
 
 module Snitcher
   extend self
 
   # Public: Check-in to Deadman's Snitch
   #
-  # token - The Snitch token given by Deadman's Snitch (see the install page).
-  # opts  - The hash of optional parameters that can be given during check-in:
-  #         :message - Text message limited to ~250 characters.
-  #         :timeout - Number of seconds to set as connect and read timeout.
+  # token:  The Snitch token given by Deadman's Snitch (see the install page).
+  # opts:   The hash of optional parameters that can be given during check-in:
+  #           :message - Text message limited to ~250 characters.
+  #           :timeout - Number of seconds to set as connect and read timeout.
+  #           :uri - URL to use for snitch checkins.
   #
   # Examples
   #
@@ -19,16 +21,10 @@ module Snitcher
   #
   # Returns true if the check-in succeeded or false if it failed
   def snitch(token, opts = {})
-    uri       = URI.parse("https://nosnch.in/#{token}")
-    uri.query = URI.encode_www_form(:m => opts[:message]) if opts[:message]
-    timeout   = opts.fetch(:timeout, 2)
-
-    opts = {
-      :open_timeout => timeout,
-      :read_timeout => timeout,
-      :ssl_timeout  => timeout,
-      :use_ssl      => uri.port == 443
-    }
+    uri       = URI.parse(checkin_url(opts, token))
+    uri.query = URI.encode_www_form(m: opts[:message]) if opts[:message]
+
+    opts = initialize_opts(opts, uri)
 
     Net::HTTP.start(uri.host, uri.port, opts) do |http|
       request = Net::HTTP::Get.new(uri.request_uri)
@@ -43,11 +39,34 @@ module Snitcher
 
   private
 
+  def initialize_opts(options, uri)
+    timeout = options.fetch(:timeout, 5)
+
+    {
+      open_timeout: timeout,
+      read_timeout: timeout,
+      ssl_timeout:  timeout,
+      use_ssl:      use_ssl?(uri)
+    }
+  end
+
+  def checkin_url(opts, token)
+    if opts[:uri].nil?
+      "https://nosnch.in/#{token}"
+    else
+      "#{opts[:uri]}/#{token}"
+    end
+  end
+
+  def use_ssl?(uri)
+    uri.scheme == "https"
+  end
+
   def user_agent
     # RUBY_ENGINE was not added until 1.9.3
     engine = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "Ruby"
 
-    "Snitcher; #{engine}/#{RUBY_VERSION}; #{RUBY_PLATFORM}; v#{VERSION}"
+    "Snitcher; #{engine}/#{RUBY_VERSION}; #{RUBY_PLATFORM}; v#{::Snitcher::VERSION}"
   end
 end
 

data/lib/snitcher/api.rb

@@ -0,0 +1,72 @@
+require "snitcher"
+require "net/https"
+require "json"
+
+require "timeout"
+require "snitcher/version"
+
+module Snitcher
+  module API
+    extend self
+
+    # Snitcher::API::Error and subclasses
+    require "snitcher/api/error"
+
+    # Public: Retrieve API Key
+    #
+    # username: The username associated with a Deadman's Snitch account
+    # password: The password associated with a Deadman's Snitch account
+    #
+    # options:
+    #   uri     - String URL of the DMS API to connect to.
+    #   timeout - Number of seconds to wait for open, read, and ssl handshake.
+    #
+    # Example
+    #
+    #   Snitcher::API.get_key("alice@example.com", "password")
+    #   # => "_caeEiZXnEyEzXXYVh2NhQ"
+    #
+    # Returns the string api_key
+    # Raises Snitcher::API::Error based on the type from the server.
+    # Raises Timeout::Error if the request timed out.
+    def get_key(username, password, options={})
+      api = options.fetch(:uri, "https://deadmanssnitch.com")
+      uri = URI.parse("#{api}/v1/api_key")
+
+      timeout = options.fetch(:timeout, 5)
+      http_options = {
+        open_timeout: timeout,
+        read_timeout: timeout,
+        ssl_timeout:  timeout,
+        use_ssl:      uri.scheme == "https",
+      }
+
+      Net::HTTP.start(uri.host, uri.port, http_options) do |http|
+        request = Net::HTTP::Get.new(uri.path)
+        request["User-Agent"] = user_agent
+        request.basic_auth(username, password)
+
+        response = http.request(request)
+
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)["api_key"]
+        else
+          error = JSON.parse(response.body)
+
+          raise ::Snitcher::API::Error.new(error)
+        end
+      end
+    end
+
+    private
+
+    def user_agent
+      # RUBY_ENGINE was not added until 1.9.3
+      engine = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "Ruby"
+
+      "Snitcher; #{engine}/#{RUBY_VERSION}; #{RUBY_PLATFORM}; v#{::Snitcher::VERSION}"
+    end
+  end
+end
+
+require "snitcher/api/client"

data/lib/snitcher/api/client.rb

@@ -0,0 +1,396 @@
+require "net/https"
+require "timeout"
+require "json"
+
+require "snitcher/api"
+require "snitcher/version"
+require "snitcher/api/snitch"
+require "snitcher/api/error"
+
+class Snitcher::API::Client
+  DEFAULT_ENDPOINT = "https://api.deadmanssnitch.com"
+
+  # Public: Create a new Client
+  #
+  # key - Access key available at https://deadmanssnitch.com/account/keys.
+  #
+  # options
+  #   endpoint - String URL of the DMS API connecting to.
+  #   timeout  - Number of seconds to wait at most when making a request.
+  #
+  # Example
+  #
+  #   Initialize API client for user with api key "abc123"
+  #     @client = Snitcher::API::Client.new("abc123")
+  #
+  def initialize(key, options = {})
+    endpoint = options[:endpoint] || DEFAULT_ENDPOINT
+
+    @key      = key
+    @endpoint = URI.parse(endpoint).freeze
+    @timeout  = options.fetch(:timeout, 5.0)
+  end
+
+  # Public: List snitches on the account
+  #
+  # Example
+  #
+  #   Get a list of all snitches
+  #     @client.snitches
+  #     => [#<Snitcher::API::Snitch:0x007fdcf51ec380 @token="c2354d53d3",
+  #          @name="Daily Backups", @tags=["production", "critical"],
+  #          @status="healthy", @checked_in_at="2014-01-01T12:00:00.000Z",
+  #          @interval="daily", @check_in_url="https://nosnch.in/c2354d53d3",
+  #          @created_at="2014-01-01T08:00:00.000Z", @notes=nil>,
+  #         #<Snitcher::API::Snitch:0x007fdcf51ec358 @token="c2354d53d4",
+  #          @name="Hourly Emails", @tags=[], @status="healthy",
+  #          @checked_in_at="2014-01-01T12:00:00.000Z", @interval="hourly",
+  #          @check_in_url="https://nosnch.in/c2354d53d4",
+  #          @created_at="2014-01-01T07:50:00.000Z", @notes=nil>]
+  #
+  # Raise Timeout::Error if the API request times out
+  def snitches
+    snitch_array(get("/v1/snitches"))
+  end
+
+  # Public: Get a single snitch by unique token
+  #
+  # token: The unique token of the snitch to get. Should be a string.
+  #
+  # Example
+  #
+  #   Get the snitch with token "c2354d53d2"
+  #
+  #     @client.snitch("c2354d53d2")
+  #     => #<Snitcher::API::Snitch:0x007fdcf50ad2d0 @token="c2354d53d3",
+  #         @name="Daily Backups", @tags=["production", "critical"],
+  #         @status="pending", @checked_in_at=nil, @interval="daily",
+  #         @check_in_url="https://nosnch.in/c2354d53d3",
+  #         @created_at="2015-08-15T12:15:00.234Z",
+  #         @notes="Important user data.">
+  #
+  # Raise Timeout::Error if the API request times out
+  def snitch(token)
+    payload = get("/v1/snitches/#{token}")
+    Snitcher::API::Snitch.new(payload)
+  end
+
+  # Public: Retrieve snitches that match all of the tags in a list
+  #
+  # tags: An array of strings. Each string is a tag.
+  #
+  # Example
+  #
+  #   Get the snitches that match a list of tags
+  #     @client.tagged_snitches(["production","critical"])
+  #     => [#<Snitcher::API::Snitch:0x007fdcf51ec380 @token="c2354d53d3",
+  #          @name="Daily Backups", @tags=["production", "critical"],
+  #          @status="pending", @checked_in_at=nil, @interval="daily",
+  #          @check_in_url="https://nosnch.in/c2354d53d3",
+  #          @created_at="2014-01-01T08:00:00.000Z", @notes=nil>,
+  #         #<Snitcher::API::Snitch:0x007fdcf51ec358 @token="c2354d53d4",
+  #          @name="Hourly Emails", @tags=["production", "critical"],
+  #          @status="healthy", @checked_in_at="2014-01-01T12:00:00.000Z",
+  #          @interval="hourly", @check_in_url="https://nosnch.in/c2354d53d4",
+  #          @created_at="2014-01-01T07:50:00.000Z", @notes=nil>]
+  #
+  # Raise Timeout::Error if the API request times out
+  def tagged_snitches(*tags)
+    (tags ||= []).flatten!
+
+    query = URI.encode_www_form({
+      # Strip extra spaces, dedupe, and clean up the list of tags to be filtered
+      # by.
+      tags: tags.map(&:strip).compact.uniq.join(","),
+    })
+
+    snitch_array(get("/v1/snitches?#{query}"))
+  end
+
+  # Public: Create a snitch using passed-in values. Returns the new snitch.
+  #
+  # attributes: A hash of the snitch properties. It should include these keys:
+  #               "name":     String value is the name of the snitch
+  #               "interval": String value representing how often the snitch is
+  #                           expected to fire. Options are "hourly", "daily",
+  #                           "weekly", "monthly"
+  #               "notes":    Optional string value for recording additional
+  #                           information about the snitch
+  #               "tags":     Optional array of string tags
+  #
+  # Example
+  #
+  #   Create a new snitch
+  #     attributes = {
+  #       "name": "Daily Backups",
+  #       "interval": "daily",
+  #       "notes": "Customer and supplier tables",
+  #       "tags": ["backups", "maintenance"]
+  #     }
+  #     @client.create_snitch(attributes)
+  #     => #<Snitcher::API::Snitch:0x007fdcf50ad2d0 @token="c2354d53d3",
+  #         @name="Daily Backups", @tags=["backups", "maintenance"],
+  #         @status="pending", @checked_in_at=nil, @interval="daily",
+  #         @check_in_url="https://nosnch.in/c2354d53d3",
+  #         @created_at="2015-08-15T12:15:00.234Z",
+  #         @notes="Customer and supplier tables">
+  #
+  # Raise Timeout::Error if the API request times out
+  def create_snitch(attributes={})
+    payload = post("/v1/snitches", attributes)
+    Snitcher::API::Snitch.new(payload)
+  end
+
+  # Public: Edit an existing snitch, identified by token, using passed-in
+  #         values. Only changes those values included in the attributes
+  #         hash; other attributes are not changed. Returns the updated snitch.
+  #
+  # token:      The unique token of the snitch to get. Should be a string.
+  # attributes: A hash of the snitch properties. It should only include those
+  #             values you want to change. Options include these keys:
+  #               "name":     String value is the name of the snitch
+  #               "interval": String value representing how often the snitch
+  #                           is expected to fire. Options are "hourly",
+  #                           "daily", "weekly", and "monthly".
+  #               "notes":    Optional string value for recording additional
+  #                           information about the snitch
+  #               "tags":     Optional array of string tags
+  #
+  # Example
+  #
+  #   Edit an existing snitch using values passed in a hash.
+  #     token      = "c2354d53d2"
+  #     attributes = {
+  #       "name":     "Monthly Backups",
+  #       "interval": "monthly"
+  #     }
+  #     @client.edit_snitch(token, attributes)
+  #     => #<Snitcher::API::Snitch:0x007fdcf50ad2d0 @token="c2354d53d3",
+  #         @name="Monthly Backups", @tags=["backups", "maintenance"],
+  #         @status="pending", @checked_in_at=nil, @interval="monthly",
+  #         @check_in_url="https://nosnch.in/c2354d53d3",
+  #         @created_at="2015-08-15T12:15:00.234Z",
+  #         @notes="Customer and supplier tables">
+  #
+  # Raise Timeout::Error if the API request times out
+  def edit_snitch(token, attributes={})
+    payload = patch("/v1/snitches/#{token}", attributes)
+    Snitcher::API::Snitch.new(payload)
+  end
+
+  # Public: Add one or more tags to an existing snitch, identified by token.
+  #         Returns an array of the snitch's tags.
+  #
+  # token:  The unique token of the snitch to edit. Should be a string.
+  # tags:   Array of string tags. Will append these tags to any existing tags.
+  #
+  # Example
+  #
+  #   Add tags to an existing snitch.
+  #     token = "c2354d53d2"
+  #     tags =  [ "red", "green" ]
+  #     @client.add_tags(token, tags)
+  #     => [
+  #           "red",
+  #           "green"
+  #        ]
+  #
+  # Raise Timeout::Error if the API request times out
+  def add_tags(token, tags=[])
+    post("/v1/snitches/#{token}/tags", tags)
+  end
+
+  # Public: Remove a tag from an existing snitch, identified by token.
+  #         Returns an array of the snitch's tags.
+  #
+  # token:  The unique token of the snitch to edit. Should be a string.
+  # tag:    Tag to be removed from a snitch's tags. Should be a string.
+  #
+  # Example
+  #
+  #   Assume a snitch that already has the tags "critical" and "production"
+  #     token = "c2354d53d2"
+  #     tag =   "production"
+  #     @client.remove_tag(token, tag)
+  #     => [
+  #           "critical"
+  #        ]
+  #
+  # Raise Timeout::Error if the API request times out
+  def remove_tag(token, tag)
+    delete("/v1/snitches/#{token}/tags/#{tag}")
+  end
+
+  # Public: Replace all of a snitch's tags with those supplied.
+  #         Returns the updated snitch.
+  #
+  # token:  The unique token of the snitch to edit. Should be a string.
+  # tags:   Array of string tags. Will replace the snitch's current tags with
+  #         these.
+  #
+  # Example
+  #
+  #   Assume a snitch with the tag "critical". Replace with tags provided.
+  #     token = "c2354d53d3"
+  #     tags =  ["production", "urgent"]
+  #     @client.replace_tags(token, tags)
+  #     => #<Snitcher::API::Snitch:0x007fdcf50ad2d0 @token="c2354d53d3",
+  #         @name="Daily Backups", @tags=["production", "urgent"],
+  #         @status="pending", @checked_in_at=nil, @interval="daily",
+  #         @check_in_url="https://nosnch.in/c2354d53d3",
+  #         @created_at="2015-08-15T12:15:00.234Z",
+  #         @notes="Customer and supplier tables">
+  #
+  # Raise Timeout::Error if the API request times out
+  def replace_tags(token, tags=[])
+    attributes = {"tags" => tags}
+
+    edit_snitch(token, attributes)
+  end
+
+  # Public: Remove all of a snitch's tags.
+  #         Returns the updated snitch.
+  #
+  # token: The unique token of the snitch to edit. Should be a string.
+  #
+  # Example
+  #
+  #   Remove all tags.
+  #     token = "c2354d53d3"
+  #     @client.clear_tags(token)
+  #     => #<Snitcher::API::Snitch:0x007fdcf50ad2d0 @token="c2354d53d3",
+  #         @name="Daily Backups", @tags=[], @status="pending",
+  #         @checked_in_at=nil, @interval="daily",
+  #         @check_in_url="https://nosnch.in/c2354d53d3",
+  #         @created_at="2015-08-15T12:15:00.234Z",
+  #         @notes="Customer and supplier tables">
+  #
+  # Raise Timeout::Error if the API request times out
+  def clear_tags(token)
+    edit_snitch(token, :tags => [])
+  end
+
+  # Public: Pauses a snitch. The return is a hash with the message "Response
+  #         complete".
+  #
+  # token: The unique token of the snitch to pause. Should be a string.
+  #
+  # Example
+  #
+  #   Pause a snitch.
+  #     token = "c2354d53d3"
+  #     @client.pause_snitch(token)
+  #     => { :message => "Response complete" }
+  #
+  # Raise Timeout::Error if the API request times out
+  def pause_snitch(token)
+    post("/v1/snitches/#{token}/pause")
+  end
+
+  # Public: Deletes a snitch. The return is a hash with the message "Response
+  #         complete".
+  #
+  # token: The unique token of the snitch to delete. Should be a string.
+  #
+  # Example
+  #
+  #   Delete a snitch.
+  #     token = "c2354d53d3"
+  #     @client.delete_snitch(token)
+  #     => { :message => "Response complete" }
+  #
+  # Raise Timeout::Error if the API request times out
+  def delete_snitch(token)
+    delete("/v1/snitches/#{token}")
+  end
+
+  protected
+
+  def user_agent
+    # RUBY_ENGINE was not added until 1.9.3
+    engine = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "Ruby"
+
+    "Snitcher; #{engine}/#{RUBY_VERSION}; #{RUBY_PLATFORM}; v#{::Snitcher::VERSION}"
+  end
+
+  def execute_request(request, options={})
+    http_options = {
+      open_timeout: @timeout,
+      read_timeout: @timeout,
+      ssl_timeout:  @timeout,
+      use_ssl:      @endpoint.scheme == "https",
+    }
+
+    Net::HTTP.start(@endpoint.host, @endpoint.port, http_options) do |http|
+      request.basic_auth(@key, "")
+      request["User-Agent"] = user_agent
+
+      # All requests (with bodies) are made using JSON.
+      if request.body
+        request["Content-Type"] = "application/json"
+
+        # Some trickiery to allow pushing the JSON rendering down as far as
+        # possible.
+        if !request.body.is_a?(String)
+          request.body = JSON.generate(request.body)
+        end
+      end
+
+      response = http.request(request)
+      evaluate_response(response)
+    end
+  end
+
+  def evaluate_response(response)
+    case response
+    when Net::HTTPNoContent
+      nil
+    when Net::HTTPSuccess
+      JSON.parse(response.body)
+    when Net::HTTPInternalServerError
+      # InternalServerError does not have a parseable body as the error may not
+      # be generated by the application itself.
+      raise ::Snitcher::API::InternalServerError.new(
+        "http_#{response.code}", response.body
+      )
+    else
+      error = JSON.parse(response.body)
+
+      raise ::Snitcher::API::Error.new(error)
+    end
+  end
+
+  def get(path, options={})
+    request = Net::HTTP::Get.new(path)
+    execute_request(request, options)
+  end
+
+  def post(path, data=nil, options={})
+    request = Net::HTTP::Post.new(path)
+    request.body = data
+
+    execute_request(request, options)
+  end
+
+  def patch(path, data, options={})
+    request = Net::HTTP::Patch.new(path)
+    request.body = data
+
+    execute_request(request, options)
+  end
+
+  def delete(path, options={})
+    request = Net::HTTP::Delete.new(path)
+    execute_request(request, options)
+  end
+
+  private
+
+  def snitch_array(json_payload)
+    arr = []
+    json_payload.each do |payload|
+      arr << Snitcher::API::Snitch.new(payload)
+    end
+    arr
+  end
+end