newrelic_api 1.1.1

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'jeweler'
+require 'rdiscount'
+
+require 'ci/reporter/rake/test_unit'
+TITLE = %Q{Documentation and helper code for the New Relic API}
+RDOC_FILES=['README*', 'CHANGELOG', 'sample*']
+Jeweler::Tasks.new do |gem|
+  gem.name = "newrelic_api"
+  gem.homepage = "http://www.github.com/newrelic/newrelic_api"
+  gem.license = "MIT"
+  gem.summary = TITLE
+  gem.description = %Q{Use this gem to access New Relic application information via a REST api}
+  gem.email = "support@newrelic.com"
+  gem.authors = ["New Relic"]
+  gem.extra_rdoc_files = FileList[*RDOC_FILES]
+  gem.rdoc_options <<
+      "--line-numbers" <<
+      "--title" << TITLE <<
+      "-m" << "README.rdoc"
+end
+#Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = TITLE
+  rdoc.rdoc_files.include(*RDOC_FILES)
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.main = "README.rdoc"
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.2

data/lib/active_resource_associations.rb

@@ -0,0 +1,35 @@
+# This mixin defines ActiveRecord style associations (like has_many) for ActiveResource objects.
+# ActiveResource objects using this mixin must define the method 'query_params'.
+module ActiveResourceAssociations #:nodoc:
+  class << self
+    protected
+    def included(base)
+      class << base
+        # a special ActiveResource implementation of has_many
+        def has_many(*associations)
+          associations.to_a.each do |association|
+            define_method association do |*args|
+              val = attributes[association.to_s] # if we've already fetched the relationship in the initial fetch, return it
+              return val if val
+
+              options = args.extract_options!
+              type = args.first || :all
+
+              begin
+                # look for the class definition within the current class
+                clazz = ( self.class.name + '::' + association.to_s.camelize.singularize).constantize
+              rescue
+                # look for the class definition in the NRAPI module
+                clazz = ( "#{self.class.parent.name}::" + association.to_s.camelize.singularize).constantize
+              end
+              params = (options[:params] || {}).update(self.query_params)
+              options[:params] = params
+              clazz.find(type, options)
+            end
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/new_relic_api.rb

@@ -0,0 +1,231 @@
+require 'active_resource_associations'
+
+# = New Relic REST API
+#
+# This is a helper module for working with the New Relic API's XML interface.  Requires Rails 2.0 or later to be loaded.
+#
+# Can also be used as a script using script/runner.
+#
+# In this version of the api, authentication is handled using your account API key, available in your Account settings
+# in http://rpm.newrelic.com.  
+# Log in, click Account at the top of the page and check the "Make my account data accessible" checkbox.  An
+# API key will appear.
+#
+# Refer to the README file for details and examples on the REST API.
+#
+# == Examples
+#
+#   # Fetching the list of applications for an account
+#   NewRelicApi::Account.find(:first).applications
+#
+#   # Fetching the health values for all account applications
+#   NewRelicApi::Account.application_health
+#
+#   # Fetching the health values for an application
+#   NewRelicApi::Account.find(:first).applications.first.threshold_values
+#
+#   # Finding an application by name
+#   NewRelicApi::Account.find(:first).applications(:params => {:conditions => {:name => 'My App'}})
+#
+
+module NewRelicApi
+
+  class << self
+    attr_accessor :api_key, :ssl, :host, :port
+
+    # Resets the base path of all resources.  This should be called when overridding the newrelic.yml settings
+    # using the ssl, host or port accessors.
+    def reset!
+      @classes.each {|klass| klass.reset!} if @classes
+      NewRelicApi::Account.site_url
+    end
+
+
+    def track_resource(klass) #:nodoc:
+      (@classes ||= []) << klass
+    end
+  end
+
+  class BaseResource < ActiveResource::Base #:nodoc:
+    include ActiveResourceAssociations
+
+    class << self
+      def inherited(klass) #:nodoc:
+        NewRelicApi.track_resource(klass)
+      end
+
+      def headers
+        raise "api_key required" unless NewRelicApi.api_key
+        {'x-api-key' => NewRelicApi.api_key}
+      end
+
+      def site_url
+        host = NewRelicApi.host || 'rpm.newrelic.com'
+        port = NewRelicApi.port || 80
+        "#{port == 443 ? 'https' : 'http'}://#{host}:#{port}"
+      end
+
+      def reset!
+        self.site = self.site_url
+      end
+    end
+    self.site = self.site_url
+  end
+  ACCOUNT_RESOURCE_PATH = '/accounts/:account_id/' #:nodoc:
+  ACCOUNT_AGENT_RESOURCE_PATH = ACCOUNT_RESOURCE_PATH + 'agents/:agent_id/' #:nodoc:
+  ACCOUNT_APPLICATION_RESOURCE_PATH = ACCOUNT_RESOURCE_PATH + 'applications/:application_id/' #:nodoc:
+
+  module AccountResource #:nodoc:
+    def account_id
+      prefix_options[:account_id]
+    end
+    def account_query_params(extra_params = {})
+      {:account_id => account_id}.merge(extra_params)
+    end
+
+    def query_params#:nodoc:
+      account_query_params
+    end
+  end
+
+  module AgentResource #:nodoc:
+    include ActiveResourceAssociations
+  end
+
+  # An application has many:
+  # +agents+:: the agent instances associated with this app
+  # +threshold_values+:: the health indicators for this application.
+  class Application < BaseResource
+    include AccountResource
+    include AgentResource
+
+    has_many :agents, :threshold_values
+
+    self.prefix = ACCOUNT_RESOURCE_PATH
+
+    def query_params#:nodoc:
+      account_query_params(:application_id => id)
+    end
+
+    class Agent < BaseResource
+      include AccountResource
+      include AgentResource
+
+      self.prefix = ACCOUNT_APPLICATION_RESOURCE_PATH
+
+      def query_params#:nodoc:
+        super.merge(:application_id => cluster_agent_id)
+      end
+    end
+
+  end
+
+  # A threshold value represents a single health indicator for an application such as CPU, memory or response time.
+  #
+  # ==Fields
+  # +name+:: The name of the threshold setting associated with this threshold value.
+  # +begin_time+:: Time value indicating start of evaluation period, as a string.
+  # +threshold_value+:: A value of 0, 1, 2 or 3 representing gray (not reporting), green, yellow and red
+  # +metric_value+:: The metric value associated with this threshold
+  class ThresholdValue < BaseResource
+    self.prefix = ACCOUNT_APPLICATION_RESOURCE_PATH
+
+    #   attr_reader :name, :begin_time, :metric_value, :threshold_value
+
+    # Return theshold_value as 0, 1, 2, or 3 representing grey (not reporting)
+    # green, yellow, and red, respectively.
+    def threshold_value
+      super.to_i
+    end
+
+    # Return the actual value of the threshold as a Float
+    def metric_value
+      super.to_f
+    end
+    # Returns the color value for this threshold (Gray, Green, Yellow or Red).
+    def color_value
+      case threshold_value
+        when 3 then 'Red'
+        when 2 then 'Yellow'
+        when 1 then 'Green'
+      else 'Gray'
+      end
+    end
+
+    def to_s #:nodoc:
+      "#{name}: #{color_value} (#{formatted_metric_value})"
+    end
+  end
+
+  # An account contains your basic account information.
+  #
+  # Accounts have many
+  # +applications+:: the applications contained within the account
+  #
+  # Find Accounts
+  #
+  #   NewRelicApi::Account.find(:first) # find account associated with the api key
+  #   NewRelicApi::Account.find(44)     # find individual account by ID
+  #
+  class Account < BaseResource
+    has_many :applications
+    has_many :account_views
+
+    def query_params #:nodoc:
+      {:account_id => id}
+    end
+
+    # Returns an account including all of its applications and the threshold values for each application.
+    def self.application_health(type = :first)
+      find(type, :params => {:include => :application_health})
+    end
+
+    class AccountView < BaseResource
+      self.prefix = ACCOUNT_RESOURCE_PATH
+
+      def query_params(extra_params = {}) #:nodoc:
+        {:account_id => account_id}.merge(extra_params)
+      end
+
+      def user
+        @attributes['user']
+      end
+    end
+
+    class AccountUsage < BaseResource
+    end
+  end
+
+  # This model is used to mark production deployments in RPM
+  # Only create is supported.
+  # == Options
+  # 
+  # Exactly one of the following is required:
+  # * <tt>app_name</tt>: The value of app_name in the newrelic.yml file used by the application.  This may be different than the label that appears in the RPM UI.  You can find the app_name value in RPM by looking at the label settings for your application.
+  # * <tt>application_id</tt>: The application id, found in the URL when viewing the application in RPM.
+  #
+  # Following are optional parameters:
+  # * <tt>description</tt>: Text annotation for the deployment &mdash; notes for you
+  # * <tt>changelog</tt>: A list of changes for this deployment
+  # * <tt>user</tt>: The name of the user/process that triggered this deployment
+  #
+  # ==Example
+  #
+  #   NewRelicApi::Deployment.create :application_id => 11142007, :description => "Update production", :user => "Big Mike"
+  #
+  #   NewRelicApi::Deployment.create :app_name => "My Application", :description => "Update production", :user => "Big Mike"
+  #
+  class Deployment < BaseResource
+  end
+
+  class Subscription < BaseResource
+    def query_params(extra_params = {}) #:nodoc:
+      {:account_id => account_id}.merge(extra_params)
+    end
+  end
+
+  class User < BaseResource
+  end
+
+end
+

data/newrelic_api.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{newrelic_api}
+  s.version = "1.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["New Relic"]
+  s.date = %q{2011-01-12}
+  s.description = %q{Use this gem to access New Relic application information via a REST api}
+  s.email = %q{support@newrelic.com}
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".project",
+    "CHANGELOG",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/active_resource_associations.rb",
+    "lib/new_relic_api.rb",
+    "newrelic_api.gemspec",
+    "test/integration/newrelic_api_test.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://www.github.com/newrelic/newrelic_api}
+  s.licenses = ["MIT"]
+  s.rdoc_options = ["--line-numbers", "--title", "Documentation and helper code for the New Relic API", "-m", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Documentation and helper code for the New Relic API}
+  s.test_files = [
+    "test/integration/newrelic_api_test.rb",
+    "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rails>, ["= 3.0.3"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, ["~> 2.10.3"])
+      s.add_development_dependency(%q<ci_reporter>, ["= 1.6.0"])
+      s.add_development_dependency(%q<rdiscount>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, [">= 3.3"])
+    else
+      s.add_dependency(%q<rails>, ["= 3.0.3"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<shoulda>, ["~> 2.10.3"])
+      s.add_dependency(%q<ci_reporter>, ["= 1.6.0"])
+      s.add_dependency(%q<rdiscount>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 3.3"])
+    end
+  else
+    s.add_dependency(%q<rails>, ["= 3.0.3"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<shoulda>, ["~> 2.10.3"])
+    s.add_dependency(%q<ci_reporter>, ["= 1.6.0"])
+    s.add_dependency(%q<rdiscount>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 3.3"])
+  end
+end
+

data/test/integration/newrelic_api_test.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'zlib'
+require 'new_relic_api'
+
+# This test runs against our integration server, which is loaded with fixture data.
+class NewrelicApiTest < ActiveSupport::TestCase
+
+  # Accounts may be identified either by their ID or by their license key.
+  # This is the license key for the "gold" fixture in the New Relic fixture data.
+  LICENSE_KEY = '8022da2f6d143de67e056741262a054547b43479'
+
+  def setup
+    NewRelicApi.api_key = LICENSE_KEY
+    if ENV['LOCAL']
+      # Run your local instance in RAILS_ENV=test to load the fixture data
+      NewRelicApi.host = 'localhost'
+      NewRelicApi.port = 3000
+    else
+      NewRelicApi.host = 'integration.newrelic.com'
+    end
+    NewRelicApi.reset!
+  end
+
+  def test_find_default
+    account = NewRelicApi::Account.find(:first)
+    assert_equal 'Gold', account.name
+    assert_equal LICENSE_KEY, account.license_key
+  end
+
+  def test_account_find
+    accounts = NewRelicApi::Account.find(:all)
+    assert_equal 1, accounts.length
+    assert_equal 'Gold', accounts.first.name
+    assert_equal LICENSE_KEY, accounts.first.license_key
+  end
+
+  def test_account_show
+    nr_account = NewRelicApi::Account.find(LICENSE_KEY)
+    assert_not_nil nr_account
+
+    account2 = NewRelicApi::Account.find(nr_account.id)
+    assert_not_nil account2
+  end
+
+  def test_account_show_applications
+    account = NewRelicApi::Account.find(LICENSE_KEY)
+    assert_not_nil account
+
+    apps = account.applications
+
+    check_applications(apps)
+    ui_app = apps.first
+
+    # Unfortunately, if you ask for a non-existent app, you get a redirect right now.
+    assert_raises ActiveResource::Redirection do
+      account.applications(9999)
+    end
+
+    ui_app = account.applications(ui_app.id)
+    assert_not_nil ui_app
+
+    threshold_values = ui_app.threshold_values
+    assert_equal 9, threshold_values.length
+  end
+
+  def test_application_health
+    account = NewRelicApi::Account.application_health
+    check_applications(account.applications)
+  end
+
+  def test_application_health_with_no_health
+    NewRelicApi.api_key = '9042da2f6d143de67e056741262a051234b434659042'
+    account = NewRelicApi::Account.application_health
+    assert_equal 1, account.applications.length
+    assert_equal 0, account.applications.first.threshold_values.length
+  end
+
+  def test_deployments
+    # lookup an app by name
+    deployment = NewRelicApi::Deployment.create :appname => 'gold app'
+    assert deployment.valid?, deployment.inspect
+
+    # lookup an app by name
+    deployment = NewRelicApi::Deployment.create :application_id => 'gold app'
+    assert deployment.valid?, deployment.inspect
+
+    account = NewRelicApi::Account.find(LICENSE_KEY)
+    apps = account.applications
+    application_id = apps.first.id
+
+    # lookup by id won't work with appname
+    deployment = NewRelicApi::Deployment.create :appname => application_id
+    assert !deployment.valid?, deployment.inspect
+
+    # lookup by id works with application_id
+    deployment = NewRelicApi::Deployment.create :application_id => application_id
+    assert deployment.valid?, deployment.inspect
+  end
+
+  def test_restricted_partner_account
+    NewRelicApi.api_key = '9042da2f6d143de67e056741262a051234b43475'
+    NewRelicApi.reset!
+
+    account = NewRelicApi::Account.find('9042da2f6d143de67e056741262a051234b43475')
+    assert_equal "Clouds 'R' Us", account.name
+  end
+
+  protected
+  def check_applications(apps)
+    app_names = apps.collect { |app| app.name }
+
+    assert_equal 1, app_names.length
+    assert_equal 'gold app', app_names.first
+
+    apps.each do |app|
+      threshold_values = app.threshold_values
+
+      assert_equal 9, threshold_values.length
+      threshold_values.each do |val|
+        assert [0, 1, 2, 3].include?(val.threshold_value), val.threshold_value
+        assert ['Gray', 'Green', 'Yellow', 'Red'].include?(val.color_value), val.color_value
+
+        assert_not_nil val.formatted_metric_value
+
+        assert_not_nil val.metric_value
+        #> 0 || val.name == 'Errors', val.name
+      end
+    end
+  end
+
+end