profile_it 0.2.4

data/lib/profile_it/agent/logging.rb

@@ -0,0 +1,44 @@
+# Contains methods specific to logging (initializing the log file, applying the log level, applying the log format, etc.)
+module ProfileIt
+  class Agent
+    module Logging
+      def log_path
+        "#{environment.root}/log"
+      end
+      
+      def init_logger
+        @log_file = "#{log_path}/profile_it.log"
+        begin 
+          @logger = Logger.new(@log_file) 
+          @logger.level = log_level
+          apply_log_format
+        rescue Exception => e
+          @logger = Logger.new(STDOUT)
+          apply_log_format
+          @logger.error "Unable to access log file: #{e.message}"
+        end
+        @logger
+      end
+
+      def apply_log_format
+        def logger.format_message(severity, timestamp, progname, msg)
+          # since STDOUT isn't exclusive like the profile_it.log file, apply a prefix.
+          prefix = @logdev.dev == STDOUT ? "profile_it " : ''
+          prefix + "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
+        end
+      end
+
+      def log_level
+        case config.settings['log_level'].downcase
+          when "debug" then Logger::DEBUG
+          when "info" then Logger::INFO
+          when "warn" then Logger::WARN
+          when "error" then Logger::ERROR
+          when "fatal" then Logger::FATAL
+          else Logger::INFO
+        end
+      end
+    end # module Logging
+    include Logging
+  end # class Agent
+end # moudle ProfileIt

data/lib/profile_it/agent/reporting.rb

@@ -0,0 +1,84 @@
+# Methods related to sending metrics to profile_itapp.com.
+module ProfileIt
+  class Agent
+    module Reporting
+
+      CA_FILE     = File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] )
+      VERIFY_MODE = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+
+      def checkin_uri
+        URI.parse("#{config.settings['host']}/#{config.settings['key']}/profiles/create?name=#{CGI.escape(config.settings['name'])}&rails_version=#{Rails::VERSION::STRING}&gem_version=#{ProfileIt::VERSION}")
+      end
+
+      def send_profile(profile)
+        uri = checkin_uri
+        logger.debug "Sending profile [#{profile.uri}] to #{uri}"
+        form_data = profile.to_form_data.merge({
+                "profile[extension_version]" => Thread::current[:profile_it_extension_version],
+                "profile[extension_fingerprint]" => Thread::current[:profile_it_extension_fingerprint],
+                "profile[user_id]" => Thread::current[:profile_it_user_id]
+            })
+        Thread.new do
+          begin
+            response =  post(uri, form_data)
+            if response and response.is_a?(Net::HTTPSuccess)
+              logger.debug "Profile Sent [#{profile.uri}]."
+            else
+              logger.debug "Error sending profile [#{profile.uri}]."
+            end
+          rescue Exception => e
+            logger.error "Exception sending profile [#{profile.uri}]: [#{e}]"
+            logger.error e.backtrace.join("\n")
+          end
+        end
+      end
+
+      def post(url, data, headers = Hash.new)
+        response = nil
+        request(url) do |connection|
+          post = Net::HTTP::Post.new( url.path +
+                                      (url.query ? ('?' + url.query) : ''),
+                                      HTTP_HEADERS.merge(headers) )
+          post.set_form_data(data)
+
+          response=connection.request(post)
+        end
+        response
+      end
+
+      def request(url, &connector)
+        response           = nil
+        response           = build_http(url).start(&connector)
+        logger.debug "got response: #{response.inspect}"
+        case response
+        when Net::HTTPSuccess, Net::HTTPNotModified
+          logger.debug "/checkin OK"
+        when Net::HTTPBadRequest
+          logger.warn "/checkin FAILED: The Account Key [#{config.settings['key']}] is invalid."
+        else
+          logger.debug "/checkin FAILED: #{response.inspect}"
+        end
+      rescue Exception
+        logger.debug "Exception sending request to server: #{$!.message}"
+      ensure
+        response
+      end
+
+      # take care of http/https proxy, if specified in command line options
+      # Given a blank string, the proxy_uri URI instance's host/port/user/pass will be nil
+      # Net::HTTP::Proxy returns a regular Net::HTTP class if the first argument (host) is nil
+      def build_http(uri)
+        proxy_uri = URI.parse(config.settings['proxy'].to_s)
+        http = Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.port).new(uri.host, uri.port)
+
+        if uri.is_a?(URI::HTTPS)
+          http.use_ssl = true
+          http.ca_file = CA_FILE
+          http.verify_mode = VERIFY_MODE
+        end
+        http
+      end
+    end # module Reporting
+    include Reporting
+  end # class Agent
+end # module ProfileIt

data/lib/profile_it/agent.rb

@@ -0,0 +1,98 @@
+module ProfileIt
+  # The agent gathers performance data from a Ruby application. One Agent instance is created per-Ruby process. 
+  #
+  # Each Agent object creates a worker thread (unless monitoring is disabled or we're forking). 
+  # The worker thread wakes up every +Agent#period+, merges in-memory metrics w/those saved to disk, 
+  # saves the merged data to disk, and sends it to the profile_it server.
+  class Agent
+    # Headers passed up with all API requests.
+    HTTP_HEADERS = { "Agent-Hostname" => Socket.gethostname }
+    # see self.instance
+    @@instance = nil 
+    
+    # Accessors below are for associated classes
+    attr_accessor :store
+    attr_accessor :config
+    attr_accessor :environment
+    
+    attr_accessor :logger
+    attr_accessor :log_file # path to the log file
+    attr_accessor :options # options passed to the agent when +#start+ is called.
+    attr_accessor :metric_lookup # Hash used to lookup metric ids based on their name and scope
+    
+    # All access to the agent is thru this class method to ensure multiple Agent instances are not initialized per-Ruby process. 
+    def self.instance(options = {})
+      @@instance ||= self.new(options)
+    end
+    
+    # Note - this doesn't start instruments or the worker thread. This is handled via +#start+ as we don't 
+    # want to start the worker thread or install instrumentation if (1) disabled for this environment (2) a worker thread shouldn't
+    # be started (when forking).
+    def initialize(options = {})
+      @started = false
+      @options ||= options
+      @store = ProfileIt::Store.new
+      @config = ProfileIt::Config.new(options[:config_path])
+      @metric_lookup = Hash.new
+    end
+    
+    def environment
+      @environment ||= ProfileIt::Environment.new
+    end
+    
+    # This is called via +ProfileIt::Agent.instance.start+ when ProfileIt is required in a Ruby application.
+    # It initializes the agent and starts the worker thread (if appropiate).
+    def start(options = {})
+      @options.merge!(options)
+      init_logger
+      logger.info "Attempting to start profileit.io [#{ProfileIt::VERSION}] on [#{Socket.gethostname}] reporting to #{config.settings['host']}"
+      if !config.settings['profile']
+        logger.warn "Profiling isn't enabled for the [#{environment.env}] environment."
+        return false
+      # elsif !environment.app_server
+      #   logger.warn "Couldn't find a supported app server. Not starting agent."
+      #   return false
+      elsif started?
+        logger.warn "Already started profileit.io."
+        return false
+      end
+      @started = true
+      logger.info "Starting profiling. Framework [#{environment.framework}] App Server [#{environment.app_server}]."
+      start_instruments
+      logger.info "ProfileIt [#{ProfileIt::VERSION}] Initialized"
+    end
+   
+    def started?
+      @started
+    end
+    
+    def gem_root
+      File.expand_path(File.join("..","..",".."), __FILE__)
+    end
+    
+    # Loads the instrumention logic.
+    def load_instruments
+      case environment.framework
+      when :rails
+        require File.expand_path(File.join(File.dirname(__FILE__),'instruments/rails/action_controller_instruments.rb'))
+      when :rails3_or_4
+        require File.expand_path(File.join(File.dirname(__FILE__),'instruments/rails3_or_4/action_controller_instruments.rb'))
+      end
+      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/active_record_instruments.rb'))
+      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/net_http.rb'))
+      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/moped_instruments.rb'))
+      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/mongoid_instruments.rb'))
+    rescue
+      logger.warn "Exception loading instruments:"
+      logger.warn $!.message
+      logger.warn $!.backtrace
+    end
+    
+    # Injects instruments into the Ruby application.
+    def start_instruments
+      logger.debug "Installing instrumentation"
+      load_instruments
+    end
+    
+  end # class Agent
+end # module ProfileIt

data/lib/profile_it/config.rb

@@ -0,0 +1,44 @@
+module ProfileIt
+  class Config   
+    DEFAULTS =  {
+        'host' => 'https://profileit.io',
+        'log_level' => 'debug', # changed from info for dev
+        'name' => 'LOCAL APP',
+        'key' => 'DEV'
+    }
+
+    def initialize(config_path = nil)
+      @config_path = config_path
+    end
+    
+    def settings
+      return @settings if @settings
+      load_file
+    end
+    
+    def config_path
+      @config_path || File.join(ProfileIt::Agent.instance.environment.root,"config","profile_it.yml")
+    end
+    
+    def config_file
+      File.expand_path(config_path)
+    end
+    
+    def load_file
+      begin
+        if !File.exist?(config_file)
+          ProfileIt::Agent.instance.logger.warn "No config file found at [#{config_file}]."
+          @settings = {}
+        else
+          @settings = YAML.load(ERB.new(File.read(config_file)).result(binding))[ProfileIt::Agent.instance.environment.env] || {} 
+        end  
+      rescue Exception => e
+        ProfileIt::Agent.instance.logger.warn "Unable to load the config file."
+        ProfileIt::Agent.instance.logger.warn e.message
+        ProfileIt::Agent.instance.logger.warn e.backtrace
+        @settings = {}
+      end
+      @settings = DEFAULTS.merge(@settings)
+    end
+  end # Config
+end # ProfileIt

data/lib/profile_it/environment.rb

@@ -0,0 +1,135 @@
+# Used to retrieve environment information for this application.
+module ProfileIt
+  class Environment
+    def env
+      @env ||= case framework
+               when :rails then RAILS_ENV.dup
+               when :rails3_or_4 then Rails.env
+               when :sinatra
+                 ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+               end
+    end
+    
+    def framework
+      @framework ||= case
+                      when defined?(::Rails) && defined?(ActionController)
+                        if Rails::VERSION::MAJOR < 3
+                          :rails
+                        else
+                          :rails3_or_4
+                        end
+                      when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+                      else :ruby
+                      end
+    end
+    
+    def processors
+      return @processors if @processors
+      unless @processors
+        proc_file = '/proc/cpuinfo'
+        if !File.exist?(proc_file)
+          @processors = 1
+        elsif `cat #{proc_file} | grep 'model name' | wc -l` =~ /(\d+)/
+          @processors = $1.to_i
+        end
+        if @processors < 1
+          @processors = 1
+        end 
+      end
+      @processors
+    end
+    
+    def root
+      if framework == :rails
+        RAILS_ROOT.to_s
+      elsif framework == :rails3_or_4
+        Rails.root
+      elsif framework == :sinatra
+        Sinatra::Application.root
+      else
+        '.'
+      end
+    end
+    
+    # This needs to be improved. Frequently, multiple app servers gem are present and which
+    # ever is checked first becomes the designated app server. 
+    # 
+    # I've put Thin and Webrick last as they are often used in development and included in Gemfiles 
+    # but less likely used in production. 
+    #
+    # Next step: (1) list out all detected app servers (2) install hooks for those that need it (passenger, rainbows, unicorn). 
+    #
+    # Believe the biggest downside is the master process for forking app servers will get a background worker. Not sure how this will
+    # impact metrics (it shouldn't process requests). 
+    def app_server
+      @app_server ||= if passenger? then :passenger
+                    elsif rainbows? then :rainbows
+                    elsif unicorn? then :unicorn
+                    elsif thin? then :thin
+                    elsif webrick? then :webrick
+                    else nil
+                    end
+    end
+    
+    ### app server related-checks
+    
+    def thin?
+      if defined?(::Thin) && defined?(::Thin::Server)
+        # Ensure Thin is actually initialized. It could just be required and not running.
+        ObjectSpace.each_object(Thin::Server) { |x| return true }
+        false
+      end
+    end
+    
+    # Called via +#forking?+ since Passenger forks. Adds an event listener to start the worker thread
+    # inside the passenger worker process.
+    # Background: http://www.modrails.com/documentation/Users%20guide%20Nginx.html#spawning%5Fmethods%5Fexplained
+    def passenger?
+      (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::PhusionPassenger)
+    end
+    
+    def webrick?
+      defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+    end
+
+    def rainbows?
+      if defined?(::Rainbows) && defined?(::Rainbows::HttpServer)
+        ObjectSpace.each_object(::Rainbows::HttpServer) { |x| return true }
+      end
+    end
+    
+    def unicorn?
+      if defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
+        # Ensure Unicorn is actually initialized. It could just be required and not running.
+        ObjectSpace.each_object(::Unicorn::HttpServer) { |x| return true }
+      end
+    end
+    
+    # If forking, don't start worker thread in the master process. Since it's started as a Thread, it won't survive
+    # the fork. 
+    def forking?
+      passenger? or unicorn? or rainbows?
+    end
+    
+    ### ruby checks
+    
+    def rubinius?
+      RUBY_VERSION =~ /rubinius/i
+    end
+
+    def jruby?
+      defined?(JRuby)
+    end
+    
+    def ruby_19?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION.match(/^1\.9/)
+    end
+    
+    ### framework checks
+
+    def sinatra?
+      defined?(Sinatra::Application)
+    end
+
+  end # class Environemnt
+end

data/lib/profile_it/instruments/active_record_instruments.rb

@@ -0,0 +1,85 @@
+module ProfileIt::Instruments
+  # Contains ActiveRecord instrument, aliasing +ActiveRecord::ConnectionAdapters::AbstractAdapter#log+ calls
+  # to trace calls to the database. 
+  module ActiveRecordInstruments
+    def self.included(instrumented_class)
+      ProfileIt::Agent.instance.logger.debug "Instrumenting #{instrumented_class.inspect}"
+      instrumented_class.class_eval do
+        unless instrumented_class.method_defined?(:log_without_profile_it_instruments)
+          alias_method :log_without_profile_it_instruments, :log
+          alias_method :log, :log_with_profile_it_instruments
+          protected :log
+        end
+      end
+    end # self.included
+    
+    def log_with_profile_it_instruments(*args, &block)
+      sql, name = args
+      self.class.profile_it_instrument(profile_it_ar_metric_name(sql,name), :desc => profile_it_sanitize_sql(sql)) do
+        log_without_profile_it_instruments(sql, name, &block)
+      end
+    end
+    
+    def profile_it_ar_metric_name(sql,name)
+      # sql: SELECT "places".* FROM "places"  ORDER BY "places"."position" ASC
+      # name: Place Load
+      if name && (parts = name.split " ") && parts.size == 2
+        model = parts.first
+        operation = parts.last.downcase
+        metric_name = case operation
+                      when 'load' then 'find'
+                      when 'indexes', 'columns' then nil # not under developer control
+                      when 'destroy', 'find', 'save', 'create', 'exists' then operation
+                      when 'update' then 'save'
+                      else
+                        if model == 'Join'
+                          operation
+                        end
+                      end
+        metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+        metric = "ActiveRecord/SQL/other" if metric.nil?
+      else
+        metric = "ActiveRecord/SQL/Unknown"
+      end
+      metric
+    end
+    
+    # Removes actual values from SQL. Used to both obfuscate the SQL and group 
+    # similar queries in the UI.
+    def profile_it_sanitize_sql(sql)
+      return nil if sql.length > 1000 # safeguard - don't sanitize large SQL statements
+      sql = sql.dup
+      sql.gsub!(/\\"/, '') # removing escaping double quotes
+      sql.gsub!(/\\'/, '') # removing escaping single quotes
+      sql.gsub!(/'(?:[^']|'')*'/, '?') # removing strings (single quote)
+      sql.gsub!(/"(?:[^"]|"")*"/, '?') # removing strings (double quote)
+      sql.gsub!(/\b\d+\b/, '?') # removing integers
+      sql.gsub!(/\?(,\?)+/,'?') # replace multiple ? w/a single ?
+      sql
+    end
+    
+  end # module ActiveRecordInstruments
+end # module Instruments
+
+def add_instruments
+  if defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::ProfileIt::Instruments::ActiveRecordInstruments
+      include ::ProfileIt::Tracer
+    end
+    ActiveRecord::Base.class_eval do
+       include ::ProfileIt::Tracer
+    end
+  end
+rescue
+  ProfileIt::Agent.instance.logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
+end
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  Rails.configuration.after_initialize do
+    ProfileIt::Agent.instance.logger.debug "Adding ActiveRecord instrumentation to a Rails 3 app"
+    add_instruments
+  end
+else
+  add_instruments
+end

data/lib/profile_it/instruments/mongoid_instruments.rb

@@ -0,0 +1,10 @@
+# Mongoid versions that use Moped should instrument Moped.
+if defined?(::Mongoid) and !defined?(::Moped)
+  ProfileIt::Agent.instance.logger.debug "Instrumenting Mongoid"
+  Mongoid::Collection.class_eval do
+    include ProfileIt::Tracer
+    (Mongoid::Collections::Operations::ALL - [:<<, :[]]).each do |method|
+      profile_it_instrument_method method, :metric_name => "MongoDB/\#{@klass}/#{method}"
+    end
+  end
+end

data/lib/profile_it/instruments/moped_instruments.rb

@@ -0,0 +1,24 @@
+if defined?(::Moped)
+  ProfileIt::Agent.instance.logger.debug "Instrumenting Moped"
+  Moped::Node.class_eval do
+    include ProfileIt::Tracer
+    def process_with_profile_it_instruments(operation, &callback)
+      if operation.respond_to?(:collection)
+        collection = operation.collection
+        self.class.instrument("MongoDB/Process/#{collection}/#{operation.class.to_s.split('::').last}", :desc => profile_it_sanitize_log(operation.log_inspect)) do
+          process_without_profile_it_instruments(operation, &callback)
+        end
+      end
+    end
+    alias_method :process_without_profile_it_instruments, :process
+    alias_method :process, :process_with_profile_it_instruments
+    
+    # replaces values w/ ?
+    def profile_it_sanitize_log(log)
+      return nil if log.length > 1000 # safeguard - don't sanitize large SQL statements
+      log.gsub(/(=>")((?:[^"]|"")*)"/) do 
+        $1 + '?' + '"'
+      end
+    end
+  end
+end

data/lib/profile_it/instruments/net_http.rb

@@ -0,0 +1,14 @@
+if defined?(::Net) && defined?(Net::HTTP)
+  ProfileIt::Agent.instance.logger.debug "Instrumenting Net::HTTP"
+  Net::HTTP.class_eval do
+    include ProfileIt::Tracer
+    
+    def request_with_profile_it_instruments(*args,&block)
+      self.class.profile_it_instrument("HTTP/request", :desc => "#{(@address+args.first.path.split('?').first)[0..99]}") do
+        request_without_profile_it_instruments(*args,&block)
+      end
+    end
+    alias request_without_profile_it_instruments request
+    alias request request_with_profile_it_instruments
+  end
+end

data/lib/profile_it/instruments/rails/action_controller_instruments.rb

@@ -0,0 +1,41 @@
+module ProfileIt::Instruments
+  module ActionControllerInstruments
+    def self.included(instrumented_class)
+      ProfileIt::Agent.instance.logger.debug "Instrumenting #{instrumented_class.inspect}"
+      instrumented_class.class_eval do
+        unless instrumented_class.method_defined?(:perform_action_without_profile_it_instruments)
+          alias_method :perform_action_without_profile_it_instruments, :perform_action
+          alias_method :perform_action, :perform_action_with_profile_it_instruments
+          private :perform_action
+        end
+      end
+    end # self.included
+
+    # In addition to instrumenting actions, this also sets the scope to the controller action name. The scope is later
+    # applied to metrics recorded during this profile. This lets us associate ActiveRecord calls with 
+    # specific controller actions.
+    def perform_action_with_profile_it_instruments(*args, &block)
+      key_from_headers = request.headers['x-profileit-key']
+      if !key_from_headers.blank? && key_from_headers == ProfileIt::Agent.instance.config.settings['key']
+        profile_it_controller_action = "Controller/#{controller_path}/#{action_name}"
+        self.class.profile_request(profile_it_controller_action, :uri => request.request_uri) do
+          perform_action_without_profile_it_instruments(*args, &block)
+        end
+      else
+        perform_action_without_profile_it_instruments(*args, &block)
+      end
+    end
+  end
+end
+
+if defined?(ActionController) && defined?(ActionController::Base)
+  ActionController::Base.class_eval do
+    include ProfileIt::Tracer
+    include ::ProfileIt::Instruments::ActionControllerInstruments
+  end
+  ProfileIt::Agent.instance.logger.debug "Instrumenting ActionView::Template"
+  ActionView::Template.class_eval do
+    include ::ProfileIt::Tracer
+    profile_it_instrument_method :render, :metric_name => 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering', :scope => true
+  end
+end

data/lib/profile_it/instruments/rails3_or_4/action_controller_instruments.rb

@@ -0,0 +1,45 @@
+# Rails 3/4
+module ProfileIt::Instruments
+  module ActionControllerInstruments
+    # Instruments the action and tracks errors.
+    def process_action(*args)
+      key_from_headers = request.headers['x-profileit-key']
+      # ProfileIt::Agent.instance.logger.debug "in perform_action_with_profile_it_instruments request key = #{key_from_headers}. config key = #{ProfileIt::Agent.instance.config.settings['key']}. "
+      if !key_from_headers.blank? && key_from_headers == ProfileIt::Agent.instance.config.settings['key']
+        profile_it_controller_action = "Controller/#{controller_path}/#{action_name}"
+        self.class.profile_request(profile_it_controller_action, :uri => request.fullpath, :request_id => request.env["action_dispatch.request_id"]) do
+          Thread::current[:profile_it_extension_fingerprint]=request.headers['x-profileit-extension-fingerprint']
+          Thread::current[:profile_it_extension_version]=request.headers['x-profileit-extension-version']
+          Thread::current[:profile_it_user_id]=request.headers['x-profileit-user-id']
+          begin
+            super
+          rescue Exception => e
+            raise
+          ensure
+            Thread::current[:profile_it_scope_name] = nil
+          end
+        end
+      else
+        super
+      end
+    end
+  end
+end
+
+# ActionController::Base is a subclass of ActionController::Metal, so this instruments both
+# standard Rails requests + Metal.
+if defined?(ActionController) && defined?(ActionController::Metal)
+  ProfileIt::Agent.instance.logger.debug "Instrumenting ActionController::Metal"
+  ActionController::Metal.class_eval do
+    include ProfileIt::Tracer
+    include ::ProfileIt::Instruments::ActionControllerInstruments
+  end
+end
+
+if defined?(ActionView) && defined?(ActionView::PartialRenderer)
+  ProfileIt::Agent.instance.logger.debug "Instrumenting ActionView::PartialRenderer"
+  ActionView::PartialRenderer.class_eval do
+    include ProfileIt::Tracer
+    profile_it_instrument_method :render_partial, :metric_name => 'View/#{@template.virtual_path}/Rendering', :scope => true
+  end
+end

data/lib/profile_it/metric_meta.rb

@@ -0,0 +1,34 @@
+# Contains the meta information associated with a metric. Used to lookup Metrics in to Store's metric_hash.
+class ProfileIt::MetricMeta
+  def initialize(metric_name, options = {})
+    @metric_name = metric_name
+    @metric_id = nil
+    @scope = Thread::current[:profile_it_sub_scope] || Thread::current[:profile_it_scope_name]
+    @desc = options[:desc]
+    @extra = {}
+  end
+  attr_accessor :metric_id, :metric_name
+  attr_accessor :scope
+  attr_accessor :client_id
+  attr_accessor :desc, :extra
+  
+  # To avoid conflicts with different JSON libaries. THIS ISN'T USED ANYMORE. STILL A CONFLICT ISSUE?
+  def to_json(*a)
+     %Q[{"metric_id":#{metric_id || 'null'},"metric_name":#{metric_name.to_json},"scope":#{scope.to_json || 'null'}}]
+  end
+  
+  def ==(o)
+    self.eql?(o)
+  end
+  
+  def hash
+     h = metric_name.downcase.hash
+     h ^= scope.downcase.hash unless scope.nil?
+     h ^= desc.downcase.hash unless desc.nil?
+     h
+   end
+
+  def eql?(o)
+   self.class == o.class && metric_name.downcase.eql?(o.metric_name.downcase) && scope == o.scope && client_id == o.client_id && desc == o.desc
+  end
+end # class MetricMeta