oneapm_rpm 1.1.0

data/lib/one_apm/logger/agent_logger.rb

@@ -0,0 +1,206 @@
+# encoding: utf-8
+
+require 'logger'
+require 'singleton'
+require 'one_apm/support/hostname'
+
+module OneApm
+  module Agent
+    class AgentLogger
+
+      attr_reader :already_logged
+
+      def initialize(root = "", override_logger=nil)
+        clear_already_logged
+        create_log(root, override_logger)
+        set_log_level!
+        set_log_format!
+
+        gather_startup_logs
+      end
+
+      def fatal(*msgs, &blk)
+        format_and_send(:fatal, msgs, &blk)
+      end
+
+      def error(*msgs, &blk)
+        format_and_send(:error, msgs, &blk)
+      end
+
+      def warn(*msgs, &blk)
+        format_and_send(:warn, msgs, &blk)
+      end
+
+      def info(*msgs, &blk)
+        format_and_send(:info, msgs, &blk)
+      end
+
+      def debug(*msgs, &blk)
+        format_and_send(:debug, msgs, &blk)
+      end
+
+      NUM_LOG_ONCE_KEYS = 1000
+
+      def log_once(level, key, *msgs)
+        # Since `already_logged` might change between calls, just grab it once
+        # and use it throughout this method.
+        logged = already_logged
+
+        return if logged.include?(key)
+
+        if logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
+          # The reason for preventing too many keys in `logged` is for
+          # memory concerns.
+          # The reason for checking the type of the key is that we always want
+          # to allow symbols to log, since there are very few of them.
+          # The assumption here is that you would NEVER pass dynamically-created
+          # symbols, because you would never create symbols dynamically in the
+          # first place, as that would already be a memory leak in most Rubies,
+          # even if we didn't hang on to them all here.
+          return
+        end
+
+        logged[key] = true
+        self.send(level, *msgs)
+      end
+
+      def is_startup_logger?
+        @log.is_a?(NullLogger)
+      end
+
+      # Use this when you want to log an exception with explicit control over
+      # the log level that the backtrace is logged at. If you just want the
+      # default behavior of backtraces logged at debug, use one of the methods
+      # above and pass an Exception as one of the args.
+      def log_exception(level, e, backtrace_level=level)
+        @log.send(level, "%p: %s" % [ e.class, e.message ])
+        @log.send(backtrace_level) do
+          backtrace = backtrace_from_exception(e)
+          if backtrace
+            "Debugging backtrace:\n" + backtrace.join("\n  ")
+          else
+            "No backtrace available."
+          end
+        end
+      end
+
+      def backtrace_from_exception(e)
+        # We've seen that often the backtrace on a SystemStackError is bunk
+        # so massage the caller instead at a known depth.
+        #
+        # Tests keep us honest about minmum method depth our log calls add.
+        return caller.drop(5) if e.is_a?(SystemStackError)
+
+        e.backtrace
+      end
+
+      # Allows for passing exceptions in explicitly, which format with backtrace
+      def format_and_send(level, *msgs, &block)
+        if block
+          if @log.send("#{level}?")
+            msgs = Array(block.call)
+          else
+            msgs = []
+          end
+        end
+
+        msgs.flatten.each do |item|
+          case item
+          when Exception then log_exception(level, item, :debug)
+          else @log.send(level, item)
+          end
+        end
+      end
+
+      def create_log(root, override_logger)
+        if !override_logger.nil?
+          @log = override_logger
+        elsif ::OneApm::Agent.config[:agent_enabled] == false
+          create_null_logger
+        else
+          if wants_stdout?
+            @log = ::Logger.new(STDOUT)
+          else
+            create_log_to_file(root)
+          end
+        end
+      end
+
+      def create_log_to_file(root)
+        path = find_or_create_file_path(::OneApm::Agent.config[:log_file_path], root)
+        if path.nil?
+          @log = ::Logger.new(STDOUT)
+          warn("Error creating log directory #{::OneApm::Agent.config[:log_file_path]}, using standard out for logging.")
+        else
+          file_path = "#{path}/#{::OneApm::Agent.config[:log_file_name]}"
+          begin
+            @log = ::Logger.new(file_path)
+          rescue => e
+            @log = ::Logger.new(STDOUT)
+            warn("Failed creating logger for file #{file_path}, using standard out for logging.", e)
+          end
+        end
+      end
+
+      def create_null_logger
+        @log = ::OneApm::Agent::NullLogger.new
+      end
+
+      def clear_already_logged
+        @already_logged = {}
+      end
+
+      def wants_stdout?
+        ::OneApm::Agent.config[:log_file_path].upcase == "STDOUT"
+      end
+
+      def find_or_create_file_path(path_setting, root)
+        for abs_path in [ File.expand_path(path_setting),
+                          File.expand_path(File.join(root, path_setting)) ] do
+          if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
+            return abs_path[%r{^(.*?)/?$}]
+          end
+        end
+        nil
+      end
+
+      def set_log_level!
+        @log.level = AgentLogger.log_level_for(::OneApm::Agent.config[:log_level])
+      end
+
+      LOG_LEVELS = {
+        "debug" => ::Logger::DEBUG,
+        "info"  => ::Logger::INFO,
+        "warn"  => ::Logger::WARN,
+        "error" => ::Logger::ERROR,
+        "fatal" => ::Logger::FATAL,
+      }
+
+      def self.log_level_for(level)
+        LOG_LEVELS.fetch(level.to_s.downcase, ::Logger::INFO)
+      end
+
+      def set_log_format!
+        @hostname = OneApm::Agent::Hostname.get
+        @prefix = wants_stdout? ? '** [OneApm]' : ''
+        @log.formatter = Proc.new do |severity, timestamp, progname, msg|
+          "#{@prefix}[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
+        end
+      end
+
+      def gather_startup_logs
+        StartupLogger.instance.dump(self)
+      end
+
+      def log_formatter=(formatter)
+        @log.formatter = formatter
+      end
+    end
+
+    # In an effort to not lose messages during startup, we trap them in memory
+    # The real logger will then dump its contents out when it arrives.
+    class StartupLogger < MemoryLogger
+      include Singleton
+    end
+  end
+end

data/lib/one_apm/logger/audit_logger.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'logger'
+require 'fileutils'
+require 'one_apm/support/hostname'
+
+module OneApm
+  module Agent
+    class AuditLogger
+      def initialize
+        @enabled = OneApm::Agent.config[:'audit_log.enabled']
+        @encoder = OneApm::Support::Encoders::Identity
+      end
+
+      attr_writer :enabled
+
+      def enabled?
+        @enabled
+      end
+
+      def setup?
+        !@log.nil?
+      end
+
+      def log_request(uri, data, marshaller)
+        if enabled?
+          setup_logger unless setup?
+          request_body = if marshaller.class.human_readable?
+            marshaller.dump(data, :encoder => @encoder)
+          else
+            marshaller.prepare(data, :encoder => @encoder).inspect
+          end
+          @log.info("REQUEST: #{uri}")
+          @log.info("REQUEST BODY: #{request_body}")
+        end
+      rescue StandardError, SystemStackError, SystemCallError => e
+        ::OneApm::Agent.logger.warn("Failed writing to audit log", e)
+      rescue Exception => e
+        ::OneApm::Agent.logger.warn("Failed writing to audit log with exception. Re-raising in case of interupt.", e)
+        raise
+      end
+
+      def setup_logger
+        path = ensure_log_path
+        if path
+          @log = ::Logger.new(path)
+          @log.formatter = create_log_formatter
+          ::OneApm::Agent.logger.info("Audit log enabled at '#{path}'")
+        else
+          @log = OneApm::Agent::NullLogger.new
+        end
+      end
+
+      def ensure_log_path
+        path = File.expand_path(OneApm::Agent.config[:'audit_log.path'])
+        log_dir = File.dirname(path)
+
+        begin
+          FileUtils.mkdir_p(log_dir)
+          FileUtils.touch(path)
+        rescue SystemCallError => e
+          msg = "Audit log disabled, failed opening log at '#{path}': #{e}"
+          ::OneApm::Agent.logger.warn(msg)
+          path = nil
+        end
+
+        path
+      end
+
+      def create_log_formatter
+        @hostname = OneApm::Agent::Hostname.get
+        Proc.new do |severity, time, progname, msg|
+          "[#{time} #{@hostname} (#{$$})] : #{msg}\n"
+        end
+      end
+    end
+  end
+end

data/lib/one_apm/logger/memory_logger.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+# Base class for startup logging and testing in multiverse
+
+module OneApm
+  module Agent
+    class MemoryLogger
+      def initialize
+        @messages = []
+      end
+
+      def is_startup_logger?
+        true
+      end
+
+      attr_accessor :messages, :level
+
+      def fatal(*msgs, &blk)
+        messages << [:fatal, msgs, blk]
+      end
+
+      def error(*msgs, &blk)
+        messages << [:error, msgs, blk]
+      end
+
+      def warn(*msgs, &blk)
+        messages << [:warn, msgs, blk]
+      end
+
+      def info(*msgs, &blk)
+        messages << [:info, msgs, blk]
+      end
+
+      def debug(*msgs, &blk)
+        messages << [:debug, msgs, blk]
+      end
+
+      def log_exception(level, e, backtrace_level=level)
+        messages << [:log_exception, [level, e, backtrace_level]]
+      end
+
+      def dump(logger)
+        messages.each do |(method, args, blk)|
+          logger.send(method, *args, &blk)
+        end
+        messages.clear
+      end
+    end
+  end
+end

data/lib/one_apm/logger/null_logger.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+# A stub object that we can use in place of a real Logger instance when
+# the agent is disabled.
+module OneApm
+  module Agent
+    class NullLogger
+      def fatal(*args); end
+      def error(*args); end
+      def warn(*args);  end
+      def info(*args);  end
+      def debug(*args); end
+
+      def method_missing(method, *args, &blk)
+        nil
+      end
+    end
+  end
+end

data/lib/one_apm/metrics/metric_data.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'one_apm/support/coerce'
+
+module OneApm
+  class MetricData
+    # nil, or a OneApm::MetricSpec object if we have no cached ID
+    attr_accessor :metric_spec
+    # nil or a cached integer ID for the metric from the collector.
+    attr_accessor :metric_id
+    # the actual statistics object
+    attr_accessor :stats
+
+    def initialize(metric_spec, stats, metric_id)
+      @metric_spec = metric_spec
+      self.stats = stats
+      self.metric_id = metric_id
+    end
+
+    def eql?(o)
+     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+    end
+
+    def original_spec
+      @original_spec || @metric_spec
+    end
+
+    # assigns a new metric spec, and retains the old metric spec as
+    # @original_spec if it exists currently
+    def metric_spec= new_spec
+      @original_spec = @metric_spec if @metric_spec
+      @metric_spec = new_spec
+    end
+
+    def hash
+      metric_spec.hash ^ stats.hash
+    end
+
+    # Serialize with all attributes, but if the metric id is not nil, then don't send the metric spec
+    def to_json(*a)
+       %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
+    end
+
+    def to_s
+      if metric_spec
+        "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
+      else
+        "#{metric_id}: #{stats}"
+      end
+    end
+
+    def inspect
+      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
+    end
+
+    include OneApm::Coerce
+
+    def to_collector_array(encoder=nil)
+      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
+      [ stat_key,
+        [
+          int(stats.call_count, stat_key),
+          float(stats.total_call_time, stat_key),
+          float(stats.total_exclusive_time, stat_key),
+          float(stats.min_call_time, stat_key),
+          float(stats.max_call_time, stat_key),
+          float(stats.sum_of_squares, stat_key)
+        ]
+      ]
+    end
+  end
+end

data/lib/one_apm/metrics/metric_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+# this struct uniquely defines a metric, optionally inside
+# the call scope of another metric
+# the call scope of another metric
+module OneApm
+  class MetricSpec
+    attr_reader   :name, :scope
+
+    # the maximum length of a metric name or metric scope
+    MAX_LENGTH = 255
+    LENGTH_RANGE = (0...MAX_LENGTH)
+    EMPTY_SCOPE = ''.freeze
+
+    def initialize(metric_name='', metric_scope=nil)
+      if metric_name.to_s.length > MAX_LENGTH
+        @name = metric_name.to_s[LENGTH_RANGE]
+      else
+        @name = metric_name.to_s
+      end
+
+      if metric_scope
+        if metric_scope.to_s.length > MAX_LENGTH
+          @scope = metric_scope.to_s[LENGTH_RANGE]
+        else
+          @scope = metric_scope.to_s
+        end
+      else
+        @scope = EMPTY_SCOPE
+      end
+    end
+
+    def ==(o)
+      self.eql?(o)
+    end
+
+    def eql? o
+      @name == o.name && @scope == o.scope
+    end
+
+    def hash
+      @name.hash ^ @scope.hash
+    end
+
+    # return a new metric spec if the given regex
+    # matches the name or scope.
+    def sub(pattern, replacement, apply_to_scope = true)
+      ::OneApm::Agent.logger.warn("The sub method on metric specs is deprecated") rescue nil
+      return nil if name !~ pattern &&
+       (!apply_to_scope || scope.nil? || scope !~ pattern)
+      new_name = name.sub(pattern, replacement)[LENGTH_RANGE]
+
+      if apply_to_scope
+        new_scope = (scope && scope.sub(pattern, replacement)[LENGTH_RANGE])
+      else
+        new_scope = scope
+      end
+
+      self.class.new new_name, new_scope
+    end
+
+    def to_s
+      return name if scope.empty?
+      "#{name}:#{scope}"
+    end
+
+    def inspect
+      "#<OneApm::MetricSpec '#{name}':'#{scope}'>"
+    end
+
+    def to_json(*a)
+      {'name' => name,
+      'scope' => scope}.to_json(*a)
+    end
+
+    def <=>(o)
+      namecmp = self.name <=> o.name
+      return namecmp if namecmp != 0
+      return (self.scope || '') <=> (o.scope || '')
+    end
+  end
+end