newrelic_rpm 2.8.11 → 2.9.2

data/lib/new_relic/metric_parser/controller_cpu.rb

@@ -0,0 +1,38 @@
+class NewRelic::MetricParser::ControllerCPU < NewRelic::MetricParser
+  
+  def is_controller_cpu?; true; end
+  
+  def controller_name
+    segments[1..-2].join('/').camelize+"Controller"
+  end
+
+  def action_name
+    segments[-1]
+  end
+
+  def developer_name
+    "#{controller_name}##{action_name}"
+  end
+
+  def base_metric_name
+    "Controller/" + segments[1..-1].join('/')
+  end
+  
+  def short_name
+    # standard controller actions
+    if segments.length > 1
+      url
+    else
+      'All Controller Actions'
+    end
+  end
+  
+  def url
+    '/' + segments[1..-1].join('/')
+  end
+
+  def call_rate_suffix
+    'rpm'
+  end
+
+end

data/lib/new_relic/metric_parser/database.rb

@@ -0,0 +1,23 @@
+class NewRelic::MetricParser::Database < NewRelic::MetricParser
+  def is_database?; true; end
+
+  def database
+    segments[1]
+  end
+  
+  def active_record_class
+    segments[2].split(' ').first
+  end
+  
+  def operation
+    op = segments.last
+    op_split = op.split(' ')
+    
+    return op if op == 'Join Table Columns'
+    op_split.last
+  end
+  
+  def developer_name
+    (segments[2]) ? "#{segments[1]} - #{segments[2]}" : "#{segments[1]} - unknown" 
+  end
+end

data/lib/new_relic/metric_parser/errors.rb

@@ -0,0 +1,6 @@
+class NewRelic::MetricParser::Errors < NewRelic::MetricParser
+  def is_error?; true; end
+  def short_name
+    segments[2..-1].join(NewRelic::MetricParser::SEPARATOR)
+  end
+end

data/lib/new_relic/metric_parser/mem_cache.rb

@@ -0,0 +1,12 @@
+class NewRelic::MetricParser::MemCache < NewRelic::MetricParser
+  def is_memcache?; true; end
+  
+  # for MemCache metrics, the short name is actually
+  # the full name
+  def short_name
+    name
+  end
+  def developer_name
+    "MemCache #{segments[1..-1].join '/'}"
+  end
+end

data/lib/new_relic/metric_parser/view.rb

@@ -0,0 +1,61 @@
+class NewRelic::MetricParser::View < NewRelic::MetricParser
+  def is_view?; true; end
+
+  def is_render?
+    segments.last == "Rendering"
+  end
+  def is_compiler?
+    segments.last == "Compile"
+  end
+  def pie_chart_label
+    case segments.last
+      when "Rendering"
+        "#{file_name(segments[-2])} Template"
+      when "Partial"
+        "#{file_name(segments[-2])} Partial"
+      when ".rhtml Processing"
+        "ERB compilation"
+      else 
+        segments[1..-1]
+    end
+  end
+  def template_label
+    case segments.last
+      when "Rendering"
+        "#{file_name(segments[1..-2].join(NewRelic::MetricParser::SEPARATOR))} Template"
+      when "Partial"
+        "#{file_name(segments[1..-2].join(NewRelic::MetricParser::SEPARATOR))} Partial"
+      when ".rhtml Processing"
+        "ERB compilation"
+      else 
+        segments[1..-1].join("/")
+    end
+  end
+  
+  def short_name
+    segments[1..-2].join(NewRelic::MetricParser::SEPARATOR)
+  end
+  
+  def controller_name
+    template_label
+  end
+
+  def action_name
+    # Strip the extension
+    segments[-2].gsub(/\..*$/, "")
+  end
+
+  def developer_name
+    template_label
+  end
+  
+  def url
+    '/' + file_name(segments[1..-2].join('/'))
+  end
+  private
+  def file_name(path)
+    label = path.gsub /\.html\.rhtml/, '.rhtml'
+    label = segments[1] if label.empty?
+    label
+  end
+end

data/lib/new_relic/metric_parser/web_service.rb

@@ -0,0 +1,9 @@
+class NewRelic::MetricParser::WebService < NewRelic::MetricParser
+  def is_web_service?
+    segments[1] != 'Soap' && segments[1] != 'Xml Rpc'
+  end
+
+  def webservice_call_rate_suffix
+    'rpm'
+  end
+end

data/lib/new_relic/metric_parser.rb

@@ -0,0 +1,107 @@
+module NewRelic
+  # Metric parsing logic mixin.  Given a metric name (attribute called "name"), provide a set of accessors
+  # that enable inspection of the metric.  A metric has 2 or more segments, each separated
+  # by the '/' character.  The metric's category is specified by its first segment. Following
+  # are the set of categories currently supported by NewRelic's default metric set:
+  #
+  # * Controller
+  # * ActiveRecord
+  # * Rails
+  # * WebService
+  # * View
+  # * Database
+  # * Custom
+  #
+  # Based on the category of the metric, specific parsing logic is defined in the source files
+  # countained in the "metric_parsers" sub directory local to this file.
+  #
+  
+  class MetricParser
+    
+    SEPARATOR = '/' unless defined? SEPARATOR
+    attr_reader :name
+    
+    # Load in the parsers classes in the plugin:
+    Dir[File.join(File.dirname(__FILE__), "metric_parser", "*.rb")].each { | file | require file }
+    
+    # return a string that is parsable via the Metric parser APIs
+    def self.for_metric_named(s)
+      category = (s =~ /^([^\/]*)/) && $1
+      parser_class = self
+      if category
+        parser_class = NewRelic::MetricParser.const_get(category) if (NewRelic::MetricParser.const_defined?(category) rescue nil)
+      end
+      parser_class.new s
+    end
+
+    def self.parse(s)
+      for_metric_named(s)
+    end
+    
+    def method_missing(method_name, *args)
+      return false if method_name.to_s =~ /^is_.*\?/
+      super
+    end
+    # The short name for the metric is defined as all of the segments
+    # of the metric name except for its first (its domain).
+    def short_name
+      if segments.empty?
+        ''
+      elsif segments.length == 1
+        segments[0]
+      else
+        segments[1..-1].join(SEPARATOR)
+      end
+    end
+    
+    def pie_chart_label
+      developer_name
+    end
+    
+    def developer_name
+      short_name
+    end
+    
+    # Return the name of another metric if the current
+    # metric is really add-on data for another metric.
+    def base_metric_name
+      nil
+    end
+    
+    def category
+      segments[0]
+    end
+    
+    def segments
+      return [] if !name
+      @segments ||= name.split(SEPARATOR).freeze
+    end
+    
+    # --
+    # These accessors are used to allow chart to use a specific segment  in the metric
+    # name for label construction as a zero-arg accessor
+    # ++
+    def segment_0; segments[0]; end
+    def segment_1; segments[1]; end
+    def segment_2; segments[2]; end
+    def segment_3; segments[3]; end
+    def segment_4; segments[4]; end
+    def last_segment; segments.last; end
+    
+    # This is the suffix used for call rate or throughput.  By default, it's cpm
+    # but things like controller actions will override to use something like 'rpm'
+    # for requests per minute
+    def call_rate_suffix
+    'cpm'
+    end
+    
+    def url
+    ''
+    end
+
+    def initialize(name)
+      @name = name
+    end
+    
+  end  
+end

data/lib/new_relic/metric_spec.rb

@@ -20,6 +20,11 @@ class NewRelic::MetricSpec
     h
   end
   
+  def to_json(*a)
+    {'name' => name, 
+    'scope' => scope}.to_json(*a)
+  end
+  
   def <=>(o)
     namecmp = name <=> o.name
     return namecmp if namecmp != 0

data/lib/new_relic/noticed_error.rb

@@ -15,7 +15,11 @@ class NewRelic::NoticedError
     else
       self.message = exception.message
     end
+    
+    # clamp long messages to 4k so that we don't send a lot of
+    # overhead across the wire
+    self.message = self.message[0..4096] if self.message.length > 4096
 
     self.timestamp = Time.now
   end
-end
+end

data/lib/new_relic/rack/metric_app.rb

@@ -0,0 +1,57 @@
+require 'fileutils'
+module NewRelic::Rack
+  class MetricApp
+    def initialize(options)
+      if options[:install]
+        FileUtils.copy File.join(File.dirname(__FILE__), "newrelic.yml"), "."
+        NewRelic::Control.instance.log.info "==============================="
+        NewRelic::Control.instance.log.info "A newrelic.yml template was copied to #{File.expand_path('.')}."
+        NewRelic::Control.instance.log.info "Please add a license key to the file and restart #{$0}"
+        exit 0
+      end
+      options[:app_name] ||= 'EPM Monitor'
+      options[:disable_samplers] = true
+      NewRelic::Agent.manual_start options
+      @stats_engine = NewRelic::Agent.instance.stats_engine
+      unless NewRelic::Control.instance.license_key
+        NewRelic::Control.instance.log.error "Please add a valid license key to newrelic.yml."
+        exit 1
+      end
+    end
+    def call(env)
+      request = ::Rack::Request.new env
+      segments = request.url.gsub(/^.*?\/metrics\//, '').split("?")[0].split("/")
+      metric = "Custom/" + segments.join("/")
+      raise "Expected value parameter!" unless request['value']
+      data = request['value'].to_f
+      stats = @stats_engine.get_stats(metric, false)
+      stats.record_data_point data
+      response = ::Rack::Response.new "#{metric}=#{data}" 
+      response.finish
+    end
+  end
+  class Status
+    def call(env)
+      request = ::Rack::Request.new env
+      data_url = "http://#{env['HTTP_HOST']}/metrics/path?value=nnn"
+      body = StringIO.new
+      body.puts "<html><body>"
+      body.puts "<h1>New Relic Actively Monitoring #{NewRelic::Control.instance.app_names.join(' and ')}</h1>"
+      body.puts "<p>To submit a metric value, use <a href='#{data_url}'>#{data_url}</a></p>"
+      body.puts "<h2>Request Details</h2>"
+      body.puts "<dl>"
+      body.puts "<dt>ip<dd>#{request.ip}"
+      body.puts "<dt>host<dd>#{request.host}"
+      body.puts "<dt>path<dd>#{request.url}"
+      body.puts "<dt>query<dd>#{request.query_string}"
+      body.puts "<dt>params<dd>#{request.params.inspect}"
+      body.puts "</dl>"
+      body.puts "<h2>Complete ENV</h2>"
+      body.puts "<ul>"
+      body.puts env.to_a.map{|k,v| "<li>#{k} = #{v}</li>" }.join("\n")
+      body.puts "</ul></body></html>"
+      response = ::Rack::Response.new body.string
+      response.finish
+    end
+  end
+end

data/lib/new_relic/rack/newrelic.ru

@@ -0,0 +1,25 @@
+# This is so that we don't detect a dispatcher like mongrel and think we are
+# monitoring it.
+ENV['NEWRELIC_DISPATCHER'] = 'none'
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..','..'))
+
+require 'new_relic/rack'
+
+# Valid options which may be present in this binding:
+# :license_key   optional license key override
+# :app_name      optional name of app
+# :logging       optional, false to omit request logging to stdout
+
+options ||= {}
+
+use Rack::CommonLogger unless options[:logging] == false
+use Rack::ShowExceptions
+map "http://localhost/metrics" do
+  run NewRelic::Rack::MetricApp.new(options)
+end
+map "/" do
+  run NewRelic::Rack::Status.new
+end
+
+

data/lib/new_relic/rack/newrelic.yml

@@ -0,0 +1,25 @@
+#
+# This file configures the Rack NewRelic Metric Application.  Place a copy of this file
+# in the directory where you start the mongrel_rpm process.
+#
+common: &default_settings
+  log_level: info
+  
+  # This is the key generated by script/create_admin
+  license_key: 'your_license_key_here'
+  
+  # Replace this with the name of the application feeding
+  # metrics into the Metric application;
+  app_name: Application Monitor
+    
+# If RAILS_ENV or RUBY_ENV is defined to be one of the following
+# these values will be overrides
+
+production:
+  <<: *default_settings
+  app_name: Production Monitor
+  
+staging:
+  <<: *default_settings
+  app_name: Staging Monitor
+

data/lib/new_relic/rack.rb

@@ -0,0 +1,5 @@
+require 'rack/response'
+require 'newrelic_rpm'
+
+# Rack middlewares and applications used by New Relic
+require 'new_relic/rack/metric_app'

data/lib/new_relic/recipes.rb

@@ -16,8 +16,8 @@ make_notify_task = lambda do
     desc "Record a deployment in New Relic RPM (rpm.newrelic.com)"
     task :notice_deployment, :roles => :app, :except => {:no_release => true } do
       rails_env = fetch(:rails_env, "production")
+      require File.join(File.dirname(__FILE__), 'commands', 'deployments.rb')
       begin
-        require File.join(File.dirname(__FILE__), 'commands', 'deployments.rb')
         # Try getting the changelog from the server.  Then fall back to local changelog
         # if it doesn't work.  Problem is that I don't know what directory the .git is
         # in when using git.  I could possibly use the remote cache but i don't know
@@ -35,10 +35,17 @@ make_notify_task = lambda do
         if !changelog
           logger.debug "Getting log of changes for New Relic Deployment details"
           from_revision = source.next_revision(current_revision)
-          log_command = "#{source.log(from_revision)}"
+          if scm == :git
+            log_command = "git log --no-color --pretty=format:'  * %an: %s' --abbrev-commit --no-merges #{previous_revision}..#{real_revision}"
+          else
+            log_command = "#{source.log(from_revision)}"
+          end
           changelog = `#{log_command}`
         end
-        new_revision = rev || source.query_revision(source.head()) { |cmd| `#{cmd}` } 
+        new_revision = rev || source.query_revision(source.head()) do |cmd| 
+          logger.debug "executing locally: '#{cmd}'"
+          `#{cmd}` 
+        end
         deploy_options = { :environment => rails_env,
           :revision => new_revision,
           :changelog => changelog, 

data/lib/new_relic/stats.rb

@@ -7,6 +7,17 @@ module NewRelic
       call_count == 0
     end  
 
+    def time_str(value_ms)
+      case
+        when value_ms >= 10000 
+       "%.1f s" % (value_ms / 1000.0)
+        when value_ms >= 5000 
+       "%.2f s" % (value_ms / 1000.0)
+      else
+       "%.0f ms" % value_ms
+      end
+    end
+    
     def average_call_time
       return 0 if call_count == 0
       total_call_time / call_count
@@ -54,9 +65,10 @@ module NewRelic
       timeslices = []
       while current_end_time < self.end_time do
         ts = yield(current_begin_time, current_end_time)
-        
-        ts.fraction_of(self)
-        timeslices << ts
+        if ts
+          ts.fraction_of(self)
+          timeslices << ts
+        end
         current_begin_time = current_end_time
         current_end_time = current_begin_time + rollup_period
       end
@@ -64,13 +76,19 @@ module NewRelic
       if self.end_time > current_begin_time
         percentage = rollup_period / self.duration + (self.begin_time - rollup_begin_time) / rollup_period
         ts = yield(current_begin_time, self.end_time)
-        ts.fraction_of(self)
-        timeslices << ts
+        if ts
+          ts.fraction_of(self)
+          timeslices << ts
+        end
       end
       
       timeslices
     end
     
+    def is_reset?
+      call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
+    end
+    
     def reset
       self.call_count = 0
       self.total_call_time = 0.0
@@ -84,13 +102,13 @@ module NewRelic
     
     def as_percentage_of(other_stats)
       return 0 if other_stats.total_call_time == 0
-      return (total_call_time / other_stats.total_call_time).to_percentage
+      return to_percentage(total_call_time / other_stats.total_call_time)
     end
     
     # the stat total_call_time is a percent
     def as_percentage
       return 0 if call_count == 0
-      (total_call_time / call_count).to_percentage
+      to_percentage(total_call_time / call_count)
     end
     
     def duration
@@ -103,9 +121,11 @@ module NewRelic
     end
     
     def calls_per_second
-      (calls_per_minute / 60).round_to(2)
+      round_to_2 calls_per_minute / 60
+    end
+    def total_call_time_per_minute
+      60.0 * time_percentage
     end
-    
     def standard_deviation
       return 0 if call_count < 2 || self.sum_of_squares.nil?
       
@@ -130,35 +150,36 @@ module NewRelic
     end
 
     alias average_value average_call_time
-    alias average_response_time average_call_time 
+    alias average_response_time average_call_time
+    alias requests_per_minute calls_per_minute
     
     def to_s
       s = "Begin=#{begin_time}, "
       s << "Duration=#{duration} s, "
       s << "Count=#{call_count}, "
-      s << "Total=#{total_call_time.to_ms}, "
-      s << "Total Exclusive=#{total_exclusive_time.to_ms}, "
-      s << "Avg=#{average_call_time.to_ms}, "
-      s << "Min=#{min_call_time.to_ms}, "
-      s << "Max=#{max_call_time.to_ms}, "
-      s << "StdDev=#{standard_deviation.to_ms}"
+      s << "Total=#{to_ms(total_call_time)}, "
+      s << "Total Exclusive=#{to_ms(total_exclusive_time)}, "
+      s << "Avg=#{to_ms(average_call_time)}, "
+      s << "Min=#{to_ms(min_call_time)}, "
+      s << "Max=#{to_ms(max_call_time)}, "
+      s << "StdDev=#{to_ms(standard_deviation)}"
     end
     
     # Summary string to facilitate testing
     def summary
       format = "%m/%d %I:%M%p"
-      "[#{Time.at(begin_time).strftime(format)}, #{duration}s. #{call_count} calls; #{average_call_time.to_ms}ms]"
+      "[#{Time.at(begin_time).strftime(format)}, #{duration}s. #{call_count} calls; #{to_ms(average_call_time)}ms]"
     end
     
     # round all of the values to n decimal points
-    def round!(decimal_places = 3)
-      self.total_call_time = total_call_time.round_to(decimal_places)
-      self.total_exclusive_time = total_exclusive_time.round_to(decimal_places)
-      self.min_call_time = min_call_time.round_to(decimal_places)
-      self.max_call_time = max_call_time.round_to(decimal_places)
-      self.sum_of_squares = sum_of_squares.round_to(decimal_places)
-      self.begin_time = begin_time.round
-      self.end_time = end_time.round
+    def round!
+      self.total_call_time = round_to_3(total_call_time)
+      self.total_exclusive_time = round_to_3(total_exclusive_time)
+      self.min_call_time = round_to_3(min_call_time)
+      self.max_call_time = round_to_3(max_call_time)
+      self.sum_of_squares = round_to_3(sum_of_squares)
+      self.begin_time = begin_time
+      self.end_time = end_time
     end
 
     # calculate this set of stats to be a percentage fraction 
@@ -185,16 +206,38 @@ module NewRelic
       self
     end
     
+
+    # returns s,t,f
     def get_apdex
-      [@call_count, @total_call_time, @total_exclusive_time, @sum_of_squares]
-    end    
+      [@call_count, @total_call_time.to_i, @total_exclusive_time.to_i]
+    end
+
+		def apdex_score
+			s, t, f = get_apdex
+			(s.to_f + (t.to_f / 2)) / (s+t+f).to_f
+		end
+    private
+    def to_ms(number)
+      (number*1000).round
+    end
+    # utility method that converts floating point percentage values
+    # to integers as a percentage, to improve readability in ui
+    def to_percentage(value)
+      round_to_2(value * 100)
+    end
     
+    def round_to_2(val)
+      (val * 100).round / 100.0
+    end
+    def round_to_3(val)
+      (val * 1000).round / 1000.0
+    end
   end
   
-  # Statistics used to track the performance of traced methods
-  class MethodTraceStats
+  
+  class StatsBase
     include Stats
-    
+
     attr_accessor :call_count
     attr_accessor :min_call_time
     attr_accessor :max_call_time
@@ -202,53 +245,25 @@ module NewRelic
     attr_accessor :total_exclusive_time
     attr_accessor :sum_of_squares
     
-    alias data_point_count call_count
-    
     def initialize 
       reset
     end
     
-    # record a single data point into the statistical gatherer.  The gatherer
-    # will aggregate all data points collected over a specified period and upload
-    # its data to the NewRelic server
-    def record_data_point(value, exclusive_time = value)
-      @call_count += 1
-      @total_call_time += value
-      @min_call_time = value if value < @min_call_time || @call_count == 1
-      @max_call_time = value if value > @max_call_time
-      @total_exclusive_time += exclusive_time
-
-      @sum_of_squares += (value * value)
-      self
-    end
-    
-    alias trace_call record_data_point
-    
-    def record_apdex_s(cpu)
-      @call_count += 1
-      @sum_of_squares += cpu
-    end
-    
-    def record_apdex_t(cpu)
-      @total_call_time += 1
-      @sum_of_squares += cpu
-    end
-    
-    def record_apdex_f(cpu)
-      @total_exclusive_time += 1
-      @sum_of_squares += cpu
-    end
-    
-    def increment_count(value = 1)
-      @call_count += value
-    end
-
-
     def freeze
       @end_time = Time.now
       super
     end
     
+    def to_json(*a)
+      {'call_count' => call_count, 
+      'min_call_time' => min_call_time, 
+      'max_call_time' => max_call_time, 
+      'total_call_time' => total_call_time,
+      'total_exclusive_time' => total_exclusive_time,
+      'sum_of_squares' => sum_of_squares}.to_json(*a)
+    end
+
+    
     # In this class, we explicitly don't track begin and end time here, to save space during
     # cross process serialization via xml.  Still the accessor methods must be provided for merge to work.
     def begin_time=(t)
@@ -266,94 +281,65 @@ module NewRelic
     end
   end
   
-  class ScopedMethodTraceStats < MethodTraceStats
-    def initialize(unscoped_stats)
-      super()
-      
-      @unscoped_stats = unscoped_stats
+  
+  class BasicStats < StatsBase
+  end
+  
+  class ApdexStats < StatsBase
+    
+    def record_apdex_s
+      @call_count += 1
     end
     
-    def trace_call(call_time, exclusive_time = call_time)
-      @unscoped_stats.trace_call call_time, exclusive_time
-      super call_time, exclusive_time
+    def record_apdex_t
+      @total_call_time += 1
     end
-  end
-end
-
-class Numeric
-  
-  # copied from rails
-  def with_delimiter(delimiter=",", separator=".")
-    begin
-      parts = self.to_s.split('.')
-      parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
-      parts.join separator
-    rescue
-      self
+    
+    def record_apdex_f
+      @total_exclusive_time += 1
     end
   end
   
-  # utlity method that converts floating point time values in seconds
-  # to integers in milliseconds, to improve readability in ui
-  def to_ms(decimal_places = 0)
-    (self * 1000).round_to(decimal_places)
-  end
-  
-  # return the number of decimal points that this number would best render in
-  #
-  def get_number_decimals_ms
-    base = 0.010
-    decimal = 0
+  # Statistics used to track the performance of traced methods
+  class MethodTraceStats < StatsBase
+    
+    alias data_point_count call_count
     
-    while decimal <= 6 && self < base do
-      base /= 10.0
-      decimal += 1
+    # record a single data point into the statistical gatherer.  The gatherer
+    # will aggregate all data points collected over a specified period and upload
+    # its data to the NewRelic server
+    def record_data_point(value, exclusive_time = value)
+      @call_count += 1
+      @total_call_time += value
+      @min_call_time = value if value < @min_call_time || @call_count == 1
+      @max_call_time = value if value > @max_call_time
+      @total_exclusive_time += exclusive_time
+
+      @sum_of_squares += (value * value)
+      self
     end
     
-    decimal
-  end
-  
-  # auto-adjust the precision based on the value
-  def to_smart_ms
-    to_ms get_number_decimals_ms
-  end
-  
-  
-  def to_ns(decimal_places = 0)
-    (self * 1000000).round_to(decimal_places)
-  end
-  
-  def to_minutes(decimal_places = 0)
-    (self / 60).round_to(decimal_places)
-  end
-  
-  # utility method that converts floating point percentage values
-  # to integers as a percentage, to improve readability in ui
-  def to_percentage(decimal_places = 2)
-    (self * 100).round_to(decimal_places)
+    alias trace_call record_data_point
+    
+    def increment_count(value = 1)
+      @call_count += value
+    end
+
   end
   
-  def round_to(decimal_places)
-    x = self
-    decimal_places.times do
-      x = x * 10
+  class ScopedMethodTraceStats < MethodTraceStats
+    def initialize(unscoped_stats)
+        super()
+      @unscoped_stats = unscoped_stats
+    end
+    
+    def trace_call(call_time, exclusive_time = call_time)
+      @unscoped_stats.trace_call call_time, exclusive_time
+      super call_time, exclusive_time
     end
-    x = x.round
-    decimal_places.times do
-      x = x.to_f / 10
+    def unscoped_stats
+      @unscoped_stats
     end
-    x
-  end
-  
-  def round_to_1
-    round_to(1)
-  end
-
-  def round_to_2
-    round_to(2)
   end
+end
 
-  def round_to_3
-    round_to(3)
-  end
-end