airbrake-api 3.3.0 → 4.0.0

data/.travis.yml

@@ -1,7 +1,13 @@
+language: ruby
+matrix:
+  allow_failures:
+    - rvm:
+      - rbx-18mode
+      - rbx-19mode
+      - ruby-head
 rvm:
   - 1.8.7
   - 1.9.2
+  - 1.9.3
   - jruby
-  - rbx
   - ree
-  - ruby-head

data/README.md

@@ -1,78 +1,102 @@
-Airbrake API [![Build Status](https://secure.travis-ci.org/spagalloco/airbrake-api.png)](http://travis-ci.org/spagalloco/airbrake-api)
-======================================================================================================================================
+# Airbrake API [![Build Status](https://secure.travis-ci.org/spagalloco/airbrake-api.png)](http://travis-ci.org/spagalloco/airbrake-api)
 
-A ruby wrapper for the [Airbrake API](http://airbrakeapp.com/pages/api)
+A ruby client for the [Airbrake API](http://help.airbrake.io/kb/api-2/api-overview)
 
-Usage
------
+## Changes in 4.0
 
-The first thing you need to set is the account name.  This is the same as the web address for your account.
+AirbrakeAPI has been completely rewritten in 4.0.  Why the high version number?
+This was the first gem I ever wrote and it's wandered a path that started with
+ActiveResource, followed by HTTParty, and now Faraday.  Along the way, AirbrakeAPI
+has lost it's ActiveRecord-like syntax for a more concise and simple API.  Instead
+of using classes such as `AirbrakeAPI::Error`, the entire API is contained within
+`AirbrakeAPI::Client`.
 
-    AirbrakeAPI.account = 'myaccount'
+The following classes are now deprecated:
 
-Then, you should set the authentication token.
+* `AirbrakeAPI::Error`
+* `AirbrakeAPI::Notice`
+* `AirbrakeAPI::Project`
 
-    AirbrakeAPI.auth_token = 'abcdefg'
+While your code will continue to work using the old API, they will ultimately be removed in favor of `AirbrakeAPI::Client`.
 
-If your account uses ssl then turn it on:
+## Configuration
 
-    AirbrakeAPI.secure = true
-
-Optionally, you can configure through a single method:
+AirbrakeAPI can be configured by passing a hash to the configure method:
 
     AirbrakeAPI.configure(:account => 'anapp', :auth_token => 'abcdefg', :secure => true)
 
-Once you've configured authentication, you can make calls against the API.  If no token or authentication is given, an AirbrakeError exception will be raised.
+or via a block:
+
+    AirbrakeAPI.configure do |config|
+      config.account = 'anapp'
+      config.auth_token = 'abcdefg'
+      config.secure = true
+    end
 
-Finding Errors
---------------
+## Finding Errors
 
 Errors are paginated, the API responds with 25 at a time, pass an optional params hash for additional pages:
 
-    AirbrakeAPI::Error.find(:all)
-    AirbrakeAPI::Error.find(:all, :page => 2)
+    AirbrakeAPI.errors
+    AirbrakeAPI.errors(:page => 2)
 
 To find an individual error, you can find by ID:
 
-    AirbrakeAPI::Error.find(error_id)
+    AirbrakeAPI.error(error_id)
+
+
+## Finding Notices
 
 Find *all* notices of an error:
 
-    AirbrakeAPI::Notice.find_all_by_error_id(error_id)
+    AirbrakeAPI.notices(error_id)
 
 Find an individual notice:
 
-    AirbrakeAPI::Notice.find(notice_id, error_id)
+    AirbrakeAPI.notice(notice_id, error_id)
 
 To resolve an error via the API:
 
-    AirbrakeAPI::Error.update(1696170, :group => { :resolved => true})
+    AirbrakeAPI.update(1696170, :group => { :resolved => true})
 
 Recreate an error:
 
     STDOUT.sync = true
-    AirbrakeAPI::Notice.find_all_by_error_id(error_id) do |batch|
+    AirbrakeAPI.notices(error_id) do |batch|
       batch.each do |notice|
         result = system "curl --silent '#{notice.request.url}' > /dev/null"
         print (result ? '.' : 'F')
       end
     end
 
-Projects
---------
+## Projects
 
 To retrieve a list of projects:
 
-    AirbrakeAPI::Project.find(:all)
+    AirbrakeAPI.projects
+
+## Deployments
+
+To retrieve a list of deployments: 
+
+    AirbrakeAPI.deployments
+
+## Connecting to more than one account
+
+While module-based configuration will work in most cases, if you'd like to simultaneously connect to more than one account at once, you can create instances of `AirbrakeAPI::Client` to do so:
 
-Responses
----------
+    client = AirbrakeAPI::Client.new(:account => 'myaccount', :auth_token => 'abcdefg', :secure => true)
+    altclient = AirbrakeAPI::Client.new(:account => 'anotheraccount', :auth_token => '123456789', :secure => false)
+    
+    client.errors
+    
+    altclient.projects
 
-If an error is returned from the API, an AirbrakeError will be raised.  Successful responses will return a Hashie::Mash object based on the data from the response.
+## Responses
 
+If an error is returned from the API, an AirbrakeError exception will be raised.  Successful responses will return a Hashie::Mash object based on the data from the response.
 
-Contributors
-------------
+## Contributors
 
 * [Matias Käkelä](https://github.com/massive) - SSL Support
 * [Jordan Brough](https://github.com/jordan-brough) - Notices

data/airbrake-api.gemspec

@@ -14,9 +14,11 @@ Gem::Specification.new do |s|
   s.email     = ['steve.agalloco@gmail.com']
   s.homepage  = 'https://github.com/spagalloco/airbrake-api'
 
-  s.add_dependency 'httparty', '~> 0.8.0'
   s.add_dependency 'hashie', '~> 1.2'
   s.add_dependency 'parallel', '~> 0.5.0'
+  s.add_dependency 'faraday_middleware', '~> 0.8'
+  s.add_dependency 'multi_xml', '~> 0.4'
+  s.add_dependency 'mash'
 
   s.add_development_dependency 'rake', '~> 0.9.2'
   s.add_development_dependency 'rspec', '~> 2.6.0'

data/lib/airbrake-api.rb

@@ -1,29 +1,11 @@
-require 'hashie'
-require 'httparty'
+require 'airbrake-api/configuration'
 
 module AirbrakeAPI
-  extend self
-  attr_accessor :account, :auth_token, :secure
+  extend Configuration
 
   class AirbrakeError < StandardError; end
-
-  def configure(options={})
-    @account = options[:account] if options.has_key?(:account)
-    @auth_token = options[:auth_token] if options.has_key?(:auth_token)
-    @secure = options[:secure] if options.has_key?(:secure)
-  end
-
-  def account_path
-    "#{protocol}://#{@account}.airbrake.io"
-  end
-
-  def protocol
-    secure ? "https" : "http"
-  end
-
 end
 
-require 'airbrake-api/core_extensions'
 require 'airbrake-api/client'
 require 'airbrake-api/error'
 require 'airbrake-api/notice'

data/lib/airbrake-api/base.rb

@@ -0,0 +1,17 @@
+# placeholder since pre-refactor classes used AirbrakeAPI::Base
+module AirbrakeAPI
+  class Base
+    class << self
+      def setup
+      end
+
+      def fetch(path, options)
+        Client.new.get(path, options)
+      end
+
+      def deprecate(msg)
+        Kernel.warn("[Deprecation] - #{msg}")
+      end
+    end
+  end
+end

data/lib/airbrake-api/client.rb

@@ -1,41 +1,164 @@
+require 'faraday_middleware'
+require 'airbrake-api/middleware/scrub_response'
+require 'airbrake-api/middleware/raise_server_error'
+require 'airbrake-api/middleware/raise_response_error'
+
 module AirbrakeAPI
-  class Base
-    include HTTParty
-    format :xml
+  class Client
 
-    private
+    PER_PAGE = 30
+    PARALLEL_WORKERS = 10
 
-    def self.setup
-      base_uri AirbrakeAPI.account_path
-      default_params :auth_token => AirbrakeAPI.auth_token
+    attr_accessor *AirbrakeAPI::Configuration::VALID_OPTIONS_KEYS
 
-      check_configuration
+    def initialize(options={})
+      attrs = AirbrakeAPI.options.merge(options)
+      AirbrakeAPI::Configuration::VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", attrs[key])
+      end
     end
 
-    def self.check_configuration
-      raise AirbrakeError.new('API Token cannot be nil') if default_options.nil? || default_options[:default_params].nil? || !default_options[:default_params].has_key?(:auth_token)
-      raise AirbrakeError.new('Account cannot be nil') unless default_options.has_key?(:base_uri)
+    # deploys
+
+    def deploys(project_id, options = {})
+      results = request(:get, deploys_path(project_id), options)
+      results.projects.respond_to?(:deploy) ? results.projects.try(:deploy) : []
+    end
+
+    def deploys_path(project_id)
+      "/projects/#{project_id}/deploys.xml"
+    end
+
+    # projects
+    def projects_path
+      '/data_api/v1/projects.xml'
+    end
+
+    def projects(options = {})
+      results = request(:get, projects_path, options)
+      results.projects.project
+    end
+
+    # errors
+
+    def error_path(error_id)
+      "/errors/#{error_id}.xml"
     end
 
-    def self.fetch(path, options)
-      response = get(path, { :query => options })
-      if response.code == 403
-        raise AirbrakeError.new('SSL should be enabled - use AirbrakeAPI.secure = true in configuration')
+    def errors_path
+      '/errors.xml'
+    end
+
+    def update(error, options = {})
+      results = request(:put, error_path(error), :body => options)
+      results.group
+    end
+
+    def error(error_id, options = {})
+      results = request(:get, error_path(error_id), options)
+      results.group || results.groups
+    end
+
+    def errors(options = {})
+      results = request(:get, errors_path, options)
+      results.group || results.groups
+    end
+
+    # notices
+
+    def notice_path(notice_id, error_id)
+      "/errors/#{error_id}/notices/#{notice_id}.xml"
+    end
+
+    def notices_path(error_id)
+      "/errors/#{error_id}/notices.xml"
+    end
+
+    def notice(notice_id, error_id, options = {})
+      hash = request(:get, notice_path(notice_id, error_id), options)
+      hash.notice
+    end
+
+    def notices(error_id, notice_options = {}, &block)
+      options     = {}
+      notices     = []
+      page        = notice_options[:page]
+      page_count  = 0
+
+      # a specific page is requested, only return that page
+      # if no page is specified, start on page 1
+      if page
+        notice_options[:pages] = 1
+      else
+        page = 1
       end
 
-      Hashie::Mash.new(response)
+      while !notice_options[:pages] || (page_count + 1) <= notice_options[:pages]
+        options[:page] = page + page_count
+        hash = request(:get, notices_path(error_id), options)
+
+        batch = Parallel.map(hash.notices, :in_threads => PARALLEL_WORKERS) do |notice_stub|
+          notice(notice_stub.id, error_id)
+        end
+        yield batch if block_given?
+        batch.each{|n| notices << n }
+
+        break if batch.size < PER_PAGE
+        page_count += 1
+      end
+      notices
     end
 
-  end
-end
+    private
+
+    def account_path
+      "#{protocol}://#{@account}.airbrake.io"
+    end
+
+    def protocol
+      @secure ? "https" : "http"
+    end
+
+    # Perform an HTTP request
+    def request(method, path, params = {}, options = {})
+
+      raise AirbrakeError.new('API Token cannot be nil') if @auth_token.nil?
+      raise AirbrakeError.new('Account cannot be nil') if @account.nil?
+
+      params.merge!(:auth_token => @auth_token)
+
+      response = connection(options).run_request(method, nil, nil, nil) do |request|
+        case method.to_sym
+        when :delete, :get
+          request.url(path, params)
+        when :post, :put
+          request.path = path
+          request.body = params unless params.empty?
+        end
+      end
+      response.body
+    end
+
+    def connection(options={})
+      default_options = {
+        :headers => {
+          :accept => 'application/xml',
+          :user_agent => user_agent,
+        },
+        :ssl => {:verify => false},
+        :url => account_path,
+      }
+      @connection ||= Faraday.new(default_options.deep_merge(connection_options)) do |builder|
+        builder.use Faraday::Request::UrlEncoded
+        builder.use AirbrakeAPI::Middleware::RaiseResponseError
+        builder.use FaradayMiddleware::Mashify
+        builder.use FaradayMiddleware::ParseXml
+        builder.use AirbrakeAPI::Middleware::ScrubResponse
+        builder.use AirbrakeAPI::Middleware::RaiseServerError
+
+        builder.adapter adapter
+      end
+    end
 
-# airbrake sometimes returns broken xml with invalid xml tag names
-# so we remove them
-require 'httparty/parser'
-class HTTParty::Parser
-  def xml
-    body.gsub!(/<__utmz>.*?<\/__utmz>/m,'')
-    body.gsub!(/<[0-9]+.*?>.*?<\/[0-9]+.*?>/m,'')
-    MultiXml.parse(body)
   end
 end

data/lib/airbrake-api/configuration.rb

@@ -0,0 +1,55 @@
+require 'airbrake-api/version'
+
+module AirbrakeAPI
+  module Configuration
+    VALID_OPTIONS_KEYS = [
+      :account,
+      :auth_token,
+      :secure,
+      :connection_options,
+      :adapter,
+      :user_agent]
+
+    attr_accessor *VALID_OPTIONS_KEYS
+
+    DEFAULT_ADAPTER     = :net_http
+    DEFAULT_USER_AGENT  = "AirbrakeAPI Ruby Gem #{AirbrakeAPI::VERSION}"
+    DEFAULT_CONNECTION_OPTIONS = {}
+
+    def self.extended(base)
+      base.reset
+    end
+
+    def configure(options={})
+      @account    = options[:account] if options.has_key?(:account)
+      @auth_token = options[:auth_token] if options.has_key?(:auth_token)
+      @secure     = options[:secure] if options.has_key?(:secure)
+      yield self if block_given?
+      self
+    end
+
+    def options
+      options = {}
+      VALID_OPTIONS_KEYS.each{|k| options[k] = send(k)}
+      options
+    end
+
+    def account_path
+      "#{protocol}://#{@account}.airbrake.io"
+    end
+
+    def protocol
+      @secure ? "https" : "http"
+    end
+
+    def reset
+      @account    = nil
+      @auth_token = nil
+      @secure     = false
+      @adapter    = DEFAULT_ADAPTER
+      @user_agent = DEFAULT_USER_AGENT
+      @connection_options = DEFAULT_CONNECTION_OPTIONS
+    end
+
+  end
+end