scout_api 0.9.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/CHANGELOG

@@ -0,0 +1,3 @@
+== 0.9.0
+
+Initial release.

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem "hashie", "~> 0.1.8"
+gem "httparty", "~> 0.5.0"
+gem "nokogiri"
+
+group :development do
+  gem "fakeweb"
+  gem "jeweler", "~> 1.5.0"
+end

data/Gemfile.lock

@@ -0,0 +1,25 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    crack (0.1.6)
+    fakeweb (1.3.0)
+    git (1.2.5)
+    hashie (0.1.8)
+    httparty (0.5.2)
+      crack (= 0.1.6)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    nokogiri (1.4.4)
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakeweb
+  hashie (~> 0.1.8)
+  httparty (~> 0.5.0)
+  jeweler (~> 1.5.0)
+  nokogiri

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jesse Newland
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,81 @@
+= scout_api
+
+A library for interacting with Scout[http://scoutapp.com], a hosted server monitoring service. 
+Query for metric data, manage servers, and more.
+
+== Getting Started 
+
+Install the gem if you haven't already:
+
+  gem install scout_api
+
+Require the gem and authenticate to get your Scout on:
+
+  require 'scout_api'
+  scout = Scout::Account.new('youraccountname', 'your@awesome.com', 'sekret')
+
+== Basics
+
+You can query for the following high-level objects:
+
+* Scout::Server
+* Scout::Group
+* Scout::Metric
+
+Each of the classes have Rails-like finder methods. For example:
+
+  # all servers
+  Scout::Server.all
+
+  # first server
+  Scout::Server.first
+
+  # first metric with ID=1
+  Scout::Metric.first(1)
+
+  # all groups with name =~ 'Web'
+  Scout::Group.all(:name => 'Web')
+
+== Metrics
+
+Access your metric data stored in Scout. You can retrieve data for a specific metric,
+a group of metrics, and aggregated metrics. For example:
+
+  # average value of the metric with ID=1 over the past hour
+  Scout::Metric.average(1)
+
+  # maximum rate of insert queries over the previous 24 hours
+  Scout::Server.first(:name => "DB Server").metrics.maximum('inserts',:start => Time.now.utc-(24*3600)*2,:end => Time.now.utc-(24*3600))
+
+  # average memory used across all servers in the 'web servers' group
+  Scout::Group.first(:name => 'web servers').metrics.average('mem_used')
+  Scout::Group.first(:name => 'web servers').metrics.average('mem_used', :format => 'sparkline').to_sparkline
+  Scout::Group.first(:name => 'web servers').metrics.average('mem_used').to_a
+
+  # total throughput across web servers
+  Scout::Group.first(:name => 'web servers').metrics.average('request_rate', :aggregate => true)
+
+== Server Management
+
+Create and delete servers:
+  
+  # create a server using the server with id=6 as the template.
+  Scout::Server.create('heavy metal',:id => 6) => <#Scout::Server>
+  
+  # delete the server with id=10
+  Scout::Server.delete(10)
+
+== Note on Patches/Pull Requests
+
+* Fork the project[https://github.com/highgroove/scout-api].
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a
+  commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Jesse Newland, Derek Haynes. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,43 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+$LOAD_PATH.unshift 'lib'
+require 'scout_api/version'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.version = Scout::VERSION
+  gem.name = "scout_api"
+  gem.summary = %Q{API wrapper for scoutapp.com}
+  gem.description = %Q{A library for interacting with Scout (http://scoutapp.com), a hosted server monitoring service. Query for metric data, manage servers, and more.}
+  gem.email = "support@scoutapp.com"
+  gem.homepage = "https://scoutapp.com/info/api"
+  gem.authors = ["Jesse Newland", "Derek Haynes"]
+  # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  # dependencies are handled in Gemfile
+end
+Jeweler::GemcutterTasks.new
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = Scout::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "scout_api #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r scout.rb"
+end
+
+require "rake/testtask"
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = [ "test/*.rb" ]
+  test.verbose = true
+end
+
+task :default => :test

data/lib/scout_api/account.rb

@@ -0,0 +1,72 @@
+class Scout::Account
+  include HTTParty
+  base_uri 'https://scoutapp.com'
+  #base_uri 'http://localhost:3000'
+  
+  format :xml
+  mattr_inheritable :param
+
+  def initialize(account_param, username, password)
+    self.class.param = account_param
+    self.class.basic_auth username, password
+  end
+
+  # Recent alerts across all servers on this account
+  #
+  # @return [Array] An array of Scout::Alert objects
+  def alerts
+    response = self.class.get("/activities.xml")
+    response['alerts'] ? response['alerts'].map { |alert| Scout::Alert.new(alert) } : Array.new
+  end
+
+  # All servers on this account
+  #
+  # @return [Array] An array of Scout::Server objects
+  def servers
+    warn "Scout#servers is deprecated. Use Scout::Server.all() instead."
+    response = self.class.get("/clients.xml")
+    response['clients'] ? response['clients'].map { |client| Scout::Server.new(client) } : Array.new
+  end
+
+  def people
+    response = self.class.get("/account_memberships")
+    doc = Nokogiri::HTML(response.body)
+
+    tables = doc.css('table.list')
+    # first table is pending
+    # second is active
+    active_table = tables.last
+    user_rows = active_table.css('tr')[1..-1] # skip first row, which is headings
+
+    user_rows.map do |row|
+      name_td, email_td, admin_td, links_td = *row.css('td')
+
+      name = name_td.content.gsub(/[\t\n]/, '')
+      email = email_td.content.gsub(/[\t\n]/, '')
+      admin = admin_td.content.gsub(/[\t\n]/, '') == 'Yes'
+      id = if links_td.inner_html =~ %r{/#{self.class.param}/account_memberships/(\d+)}
+             $1.to_i
+           end
+
+      Scout::Person.new :id => id, :name => name, :email => email, :admin => admin
+    end
+
+  end
+  
+  class << self
+    alias_method :http_get, :get
+  end
+  
+  # Checks for errors via the HTTP status code. If an error is found, a 
+  # Scout::Error is raised. Otherwise, the response.
+  # 
+  # @return HTTParty::Response
+  def self.get(uri)
+    raise Scout::Error, 
+          "Authentication is required (scout = Scout::Account.new('youraccountname', 'your@awesome.com', 'sekret'))" if param.nil?
+    uri = "/#{param}" + uri + (uri.include?('?') ? '&' : '?') + "api_version=#{Scout::VERSION}"
+    #puts "GET: #{uri}"
+    response = http_get(uri)
+    response.code.to_s =~ /^(4|5)/ ? raise( Scout::Error,response.message) : response
+  end
+end

data/lib/scout_api/alert.rb

@@ -0,0 +1,17 @@
+class Scout::Alert < Hashie::Mash
+  attr_writer :server
+
+  # The Scout server that generated this alert
+  #
+  # @return [Scout::Server]
+  def server
+    @server ||= Scout::Server.first(client_id)
+  end
+
+  # The Scout plugin that generated this alert
+  #
+  # @return [Scout::Plugin]
+  def plugin
+    server.plugin(plugin_id)
+  end
+end

data/lib/scout_api/group.rb

@@ -0,0 +1,73 @@
+# Groups represent a collection of servers. 
+# They can be created in the Scout UI to put similar servers together (ex: Web Servers, Database Servers).
+class Scout::Group < Hashie::Mash
+  # Retrieve metric information. See Scout::Metric#average for a list of options for the calculation
+  # methods (average, minimum, maximum).
+  # 
+  # Examples:
+  # 
+  # * <tt>Scout::Group.metrics => All metrics associated with this group.</tt>
+  # * <tt>Scout::Group.metrics.all(:name => 'mem_used') => Metrics with name =~ 'mem_used' across all servers in this group.</tt>
+  # * <tt>Scout::Group.metrics.average(:name => 'mem_used') => Average value of metrics with name =~ 'mem_used' across all servers in the group.</tt> 
+  # * <tt>Scout::Group.metrics.maximum(:name => 'mem_used')</tt>
+  # * <tt>Scout::Group.metrics.minimum(:name => 'mem_used')</tt>
+  # * <tt>Scout::Group.metrics.average(:name => 'request_rate', :aggregate => true) => Sum metrics, then take average</tt>
+  # * <tt>Scout::Group.metrics.average(:name => 'request_rate', :start => Time.now.utc-5*3600, :end => Time.now.utc-2*3600) => Retrieve data starting @ 5 hours ago ending at 2 hours ago</tt>
+  # * <tt>Scout::Group.metrics.average(:name => 'mem_used').to_array => An array of time series values over the past hour.</tt> 
+  # * <tt>Scout::Group.metrics.average(:name => 'mem_used').to_sparkline => A Url to a Google Sparkline Chart.</tt> 
+  attr_reader :metrics
+
+  def initialize(hash) #:nodoc:
+    @metrics = Scout::MetricProxy.new(self)
+    super(hash)
+  end
+  
+  # Finds the first group that meets the given conditions. Possible parameter formats:
+  # 
+  # * <tt>Scout::Group.first</tt>
+  # * <tt>Scout::Group.first(1)</tt>
+  # * <tt>Scout::Group.first(:name => 'db slaves')</tt>
+  #
+  # For the <tt>:name</tt>, a {MySQL-formatted Regex}[http://dev.mysql.com/doc/refman/5.0/en/regexp.html] can be used.
+  #
+  # @return [Scout::Group]
+  def self.first(id_or_options = nil)
+    if id_or_options.nil?
+      response = Scout::Account.get("/groups.xml?limit=1")
+      Scout::Group.new(response['groups'].first)
+    elsif id_or_options.is_a?(Hash)
+      if name=id_or_options[:name]
+        response = Scout::Account.get("/groups.xml?name=#{CGI.escape(name)}")
+        raise Scout::Error, 'Not Found' if response['groups'].nil?
+        Scout::Group.new(response['groups'].first)
+      else
+        raise Scout::Error, "Invalid finder condition"
+      end
+    elsif id_or_options.is_a?(Fixnum)
+      response = Scout::Account.get("/groups/#{id_or_options}.xml")
+      Scout::Group.new(response['group'])
+    else
+      raise Scout::Error, "Invalid finder condition"
+    end
+  end
+  
+  # Finds all groups that meets the given conditions. Possible parameter formats:
+  # 
+  # * <tt>Scout::Group.all</tt>
+  # * <tt>Scout::Group.all(:name => 'web')</tt>
+  #
+  # For the <tt>:name</tt>, a {MySQL-formatted Regex}[http://dev.mysql.com/doc/refman/5.0/en/regexp.html] can be used.
+  #
+  # @return [Array] An array of Scout::Group objects
+  def self.all(options = {})
+    if name=options[:name]
+      response = Scout::Account.get("/groups.xml?name=#{CGI.escape(name)}")
+    elsif options.empty?
+      response = Scout::Account.get("/groups.xml")
+    else
+      raise Scout::Error, "Invalid finder condition"
+    end
+    response['groups'] ? response['groups'].map { |g| Scout::Group.new(g) } : Array.new
+  end
+  
+end

data/lib/scout_api/metric.rb

@@ -0,0 +1,243 @@
+class Scout::Metric < Hashie::Mash
+  attr_accessor :server, :plugin
+  
+  def initialize(hash) #:nodoc:
+    super(hash)
+    @avg_calc = Scout::MetricCalculation.new(self,:AVG)
+    @avg_calc.metric_name = identifier
+    @min_calc = Scout::MetricCalculation.new(self,:MIN)
+    @min_calc.metric_name = identifier
+    @max_calc = Scout::MetricCalculation.new(self,:MAX)
+    @max_calc.metric_name = identifier
+  end
+  
+  # Finds a single metric that meets the given conditions. Possible parameter formats:
+  # 
+  # * <tt>Scout::Metric.first</tt> => Finds the metric
+  # * <tt>Scout::Metric.first(1)</tt> => Finds the metric with ID=1
+  # * <tt>Scout::Metric.first(:name => 'request_rate')</tt> => Finds the first metric where name=~'request_rate'
+  #
+  # For the <tt>:name</tt>, a {MySQL-formatted Regex}[http://dev.mysql.com/doc/refman/5.0/en/regexp.html] can be used.
+  #
+  # @return [Scout::Metric]
+  def self.first(id_or_options = nil)
+    if id_or_options.nil?
+      response = Scout::Account.get("/descriptors.xml?limit=1")
+      Scout::Metric.new(response['ar_descriptors'].first)
+    elsif id_or_options.is_a?(Hash)
+      if name=id_or_options[:name]
+        response = Scout::Account.get("/descriptors.xml?name=#{CGI.escape(name)}")
+        raise Scout::Error, 'Not Found' if response['ar_descriptors'].nil?
+        Scout::Metric.new(response['ar_descriptors'].first)
+      else
+        raise Scout::Error, "Invalid finder condition"
+      end
+    elsif id_or_options.is_a?(Fixnum)
+      response = Scout::Account.get("/descriptors/#{id_or_options}.xml")
+      Scout::Metric.new(response['ar_descriptor'])
+    else
+      raise Scout::Error, "Invalid finder condition"
+    end
+  end
+
+  # Search for metrics. MetricProxy uses this method to search for metrics. Refer to MetricProxy#all.
+  #
+  # @return [Array] An array of Scout::Metric objects
+  def self.all(options = {})
+    raise Scout::Error, "A finder condition is required" if options.empty?
+    response = Scout::Account.get("/descriptors.xml?name=#{CGI.escape(options[:name].to_s)}&ids=&plugin_ids=#{options[:plugin_ids]}&server_ids=#{options[:server_ids]}&group_ids=#{options[:group_ids]}")
+    response['ar_descriptors'] ? response['ar_descriptors'].map { |descriptor| Scout::Metric.new(descriptor) } : Array.new
+  end
+  
+  # Find the average value of a metric by ID or name (ex: <tt>'disk_used'</tt>). If the metric couldn't be found AND/OR
+  # hasn't reported since <tt>options[:start]</tt>, a [Scout::Error] is raised.
+  #
+  # A 3-element Hash is returned with the following keys:
+  # * <tt>:value</tt>
+  # * <tt>:units</tt>
+  # * <tt>:label</tt>
+  #
+  # <b>Options:</b>
+  #
+  # * <tt>:start</tt> - The start time for grabbing metrics. Default is 1 hour ago. Times will be converted to UTC.
+  # * <tt>:end</tt> - The end time for grabbing metrics. Default is <tt>Time.now.utc</tt>. Times will be converted to UTC.
+  # * <tt>:aggregate</tt> - Whether the metrics should be added together or an average across each metric should be returned.
+  #   Default is false. Note that total is not necessary equal to the value on each server * num of servers. 
+  #
+  # <b>When to use <tt>:aggregate</tt>?</b>
+  #
+  # If you have a number of web servers, you may be interested in the total throughput for your application, not just the average 
+  # on each server. For example:
+  #
+  # * Web Server No. 1 Average Throughput => 100 req/sec
+  # * Web Server No. 2 Average Throughput => 150 req/sec
+  #
+  # <tt>:aggregate => true</tt> will return ~ 250 req/sec, giving the total throughput for your entire app. 
+  # The default, <tt>:aggregate => false</tt>, will return ~ 125 req/sec, giving the average throughput across the web servers.
+  #
+  # <tt>:aggregate => true</tt> likely doesn't make sense for any metric that is on a 0-100 scale (like CPU Usage, Disk Capacity, etc.). 
+  #
+  # <b>Examples:</b>
+  #
+  #   # What is the average request time across my servers?
+  #   Scout::Metric.average('request_time') => {:value => 0.20, :units => 'sec', :label => 'Request Time'}
+  #
+  #   # What is the average TOTAL throughput across my servers?
+  #   Scout::Metric.average('request_rate', :aggregate => true)
+  #
+  #   # How much average memory did my servers use yesterday?
+  #   # Scout::Metric.average('mem_used', :start => Time.now-(24*60*60)*2, :end => Time.now-(24*60*60))
+  #
+  # @return [Hash]
+  def self.average(id_or_name,options = {})
+    calculate('AVG',id_or_name,options)
+  end
+  
+  # Find the maximum value of a metric by ID or name (ex: 'last_minute').
+  #
+  # See +average+ for options and examples.
+  #
+  # @return [Hash]
+  def self.maximum(id_or_name,options = {})
+    calculate('MAX',id_or_name,options)
+  end
+
+  # Find the minimum value of a metric by ID or name (ex: 'last_minute').
+  #
+  # See +average+ for options and examples.
+  #
+  # @return [Hash]
+  def self.minimum(id_or_name,options = {})
+    calculate('MIN',id_or_name,options)
+  end
+  
+  # Returns time series data.
+  #
+  # @return [Array]. This is a two-dimensional array, with the first element being the time in UTC and the second the value at that time.
+  def self.to_array(function,id_or_name,options = {})
+    start_time,end_time=format_times(options)
+    consolidate,name,ids=series_options(id_or_name,options)
+    
+    response = Scout::Account.get("/descriptors/series.xml?name=#{CGI.escape(name.to_s)}&ids=#{ids}&function=#{function}&consolidate=#{consolidate}&plugin_ids=#{options[:plugin_ids]}&server_ids=#{options[:server_ids]}&group_ids=#{options[:group_ids]}&start=#{start_time}&end=#{end_time}")
+
+    if response['records']
+      response['records']
+      response['records'].values.flatten.map { |r| [Time.parse(r['time']),r['value'].to_f] }
+    else
+      raise Scout::Error, response['error']
+    end
+  end
+  
+  # Generates a URL to a Google chart sparkline representation of the time series data.
+  #
+  # <b>Options:</b>
+  #
+  # * <tt>:size</tt> - The size of the image in pixels. Default is 200x30.
+  # * <tt>:line_color</tt> - The color of the line. Default is 0077cc (blue).
+  # * <tt>:line_width</tt> - The width of the line in pixels. Default is 2.
+  #
+  # @return [String]
+  def self.to_sparkline(function,id_or_name,options = {})
+    start_time,end_time=format_times(options)
+    consolidate,name,ids=series_options(id_or_name,options)
+    puts options.inspect
+    puts start_time.inspect
+    response = Scout::Account.get("/descriptors/sparkline?name=#{CGI.escape(name.to_s)}&ids=#{ids}&function=#{function}&consolidate=#{consolidate}&plugin_ids=#{options[:plugin_ids]}&server_ids=#{options[:server_ids]}&group_ids=#{options[:group_ids]}&start=#{start_time}&end=#{end_time}&size=#{options[:size]}&line_color=#{options[:line_color]}&line_width=#{options[:line_width]}")
+
+    if response['error']
+      raise Scout::Error, response['error']
+    else
+      response.body
+    end
+  end
+  
+  # See Scout::Metric#average for a list of options.
+  #
+  # @return [Hash]
+  def average(opts = {})
+    @avg_calc.options = opts
+    @avg_calc
+  end
+  alias avg average
+
+  # See Scout::Metric#average for a list of options.
+  #
+  # @return [Hash]
+  def maximum(opts = {})
+     @max_calc.options = opts
+     @max_calc
+  end
+  alias max maximum
+
+  # See Scout::Metric#average for a list of options.
+  #
+  # @return [Hash]
+  def minimum(opts = {})
+     @min_calc.options = opts
+     @min_calc
+  end
+  alias min minimum
+  
+  # Metrics are identified by either their given ID or their name. If ID is present,
+  # use it.
+  def identifier #:nodoc:
+    id? ? id : name
+  end
+  
+  # Used to apply finder conditions
+  def options_for_relationship(opts = {}) #:nodoc:
+    relationship_options = {}
+    if id?
+      relationship_options[:ids] = id
+    elsif plugin
+      relationship_options[:plugin_ids] = plugin.id
+    elsif server
+      relationship_options[:server_ids] = server.id
+    end
+    opts.merge(relationship_options)
+  end
+
+  protected
+  
+  def self.series_options(id_or_name,options) #:nodoc:
+    consolidate = options[:aggregate] ? 'SUM' : 'AVG'
+    
+    if id_or_name.is_a?(Fixnum)
+      name = nil
+      ids = id_or_name
+    else
+      name = id_or_name
+      ids = nil
+    end
+    
+    return [consolidate,name,ids]
+  end
+  
+  # The friendlier-named average, minimum, and maximum methods call this method.
+  def self.calculate(function,id_or_name,options = {}) #:nodoc:
+    start_time,end_time=format_times(options)
+    consolidate = options[:aggregate] ? 'SUM' : 'AVG'
+    
+    if id_or_name.is_a?(Fixnum)
+      name = nil
+      ids = id_or_name
+    else
+      name = id_or_name
+      ids = nil
+    end
+    
+    response = Scout::Account.get("/data/value?name=#{CGI.escape(name.to_s)}&ids=#{ids}&function=#{function}&consolidate=#{consolidate}&plugin_ids=#{options[:plugin_ids]}&server_ids=#{options[:server_ids]}&group_ids=#{options[:group_ids]}&start=#{start_time}&end=#{end_time}")
+
+    if response['data']
+      response['data']
+    else
+      raise Scout::Error, response['error']
+    end
+  end
+  
+   # API expects times in epoch.
+   def self.format_times(options)
+     options.values_at(:start,:end).map { |t| t ? t.to_i : nil }
+   end
+  
+end

data/lib/scout_api/metric_calculation.rb

@@ -0,0 +1,61 @@
+class Scout::MetricCalculation
+  instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+  attr_accessor :metric_name, :options
+  
+  def initialize(owner,function) #:nodoc:
+    @owner = owner
+    @function = function
+    @options = {}
+  end
+  
+  def to_sparkline(opts = {})
+    options.merge!(opts).merge!(owner_key_value)
+    Scout::Metric.to_sparkline(
+      @function,metric_name,options
+    )
+  end
+  
+  def to_array 
+    options.merge!(owner_key_value)
+    Scout::Metric.to_array(
+      @function,metric_name,options
+    )
+  end
+  alias to_a to_array
+  
+  def load_target #:nodoc:
+    @target = find_target
+  end
+  
+  def find_target #:nodoc:
+    options.merge!(owner_key_value)
+    Scout::Metric.calculate(
+      @function,metric_name,options
+    )
+  end
+  
+  private
+  
+  def owner_key_value
+    if @owner.is_a?(Scout::Metric)
+      @owner.options_for_relationship
+    else
+      { (@owner.owner.class.to_s.sub('Scout::','').downcase+'_ids').to_sym => @owner.owner.id}
+    end
+  end
+  
+  def method_missing(method, *args)
+    if load_target
+      unless @target.respond_to?(method)
+        message = "undefined method `#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
+        raise NoMethodError, message
+      end
+
+      if block_given?
+        @target.send(method, *args)  { |*block_args| yield(*block_args) }
+      else
+        @target.send(method, *args)
+      end
+    end
+  end
+end