scout_apm 2.3.5 → 2.4.0.pre

data/lib/scout_apm/agent/logging.rb

@@ -1,74 +0,0 @@
-# Contains methods specific to logging (initializing the log file, applying the log level, applying the log format, etc.)
-module ScoutApm
-  class Agent
-    module Logging
-      def default_log_path
-        "#{environment.root}/log"
-      end
-
-      def init_logger(opts={})
-        if opts[:force]
-          @log_file = nil
-          @logger = nil
-        end
-
-        begin
-          @log_file ||= determine_log_destination
-        rescue => e
-        end
-
-        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 open log file for writing: #{e.message}. Falling back to STDOUT"
-        end
-        @logger
-      end
-
-      def apply_log_format
-        def logger.format_message(severity, timestamp, progname, msg)
-          # since STDOUT isn't exclusive like the scout_apm.log file, apply a prefix.
-          prefix = @logdev.dev == STDOUT ? "[Scout] " : ''
-          prefix + "[#{Utils::Time.to_s(timestamp)} #{ScoutApm::Agent.instance.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
-        end
-      end
-
-      def log_level
-        case config.value('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
-
-      def determine_log_destination
-        case true
-        when wants_stdout? then STDOUT
-        when wants_stderr? then STDERR
-        else "#{log_file_path}/scout_apm.log"
-        end
-      end
-
-      def wants_stdout?
-        config.value('log_file_path').to_s.upcase == 'STDOUT' || environment.platform_integration.log_to_stdout?
-      end
-
-      def wants_stderr?
-        config.value('log_file_path').to_s.upcase == 'STDERR'
-      end
-
-      def log_file_path
-        config.value('log_file_path') || default_log_path
-      end
-    end
-    include Logging
-  end
-end
-

data/lib/scout_apm/agent/reporting.rb

@@ -1,129 +0,0 @@
-# Methods related to sending metrics to scoutapp.com.
-module ScoutApm
-  class Agent
-    module Reporting
-      def reporter
-        @reporter ||= ScoutApm::Reporter.new(:checkin, config, logger)
-      end
-
-      # The data moves through a treadmill of reporting, coordinating several Rails processes by using an external file.
-      # * During the minute it is being recorded by the instruments, it gets
-      #   recorded into the ram of each process (in the Store class).
-      # * The minute after, each process writes its own metrics to a shared LayawayFile
-      # * The minute after that, the first process to wake up pushes the combined
-      #   data to the server, and wipes it. Next processes don't have anything to do.
-      #
-      # At any given point, there is data in each of those steps, moving its way through the process
-      def process_metrics
-        # Write the previous minute's data to the shared-across-process layaway file.
-        store.write_to_layaway(layaway)
-
-        # Attempt to send 2 minutes ago's data up to the server.  This
-        # only acctually occurs if this process is the first to wake up this
-        # minute.
-        report_to_server
-      end
-
-      # In a running app, one process will get the period ready for delivery, the others will see 0.
-      def report_to_server
-        period_to_report = ScoutApm::StoreReportingPeriodTimestamp.minutes_ago(2)
-
-        logger.debug("Attempting to claim #{period_to_report.to_s}")
-
-        did_write = layaway.with_claim(period_to_report) do |rps|
-          logger.debug("Succeeded claiming #{period_to_report.to_s}")
-
-          begin
-            merged = rps.inject { |memo, rp| memo.merge(rp) }
-            logger.debug("Merged #{rps.length} reporting periods, delivering")
-            deliver_period(merged)
-            true
-          rescue => e
-            logger.debug("Error merging reporting periods #{e.message}")
-            logger.debug("Error merging reporting periods #{e.backtrace}")
-            false
-          end
-
-        end
-
-        if !did_write
-          logger.debug("Failed to obtain claim for #{period_to_report.to_s}")
-        end
-
-      end
-
-
-      def deliver_period(reporting_period)
-        metrics = reporting_period.metrics_payload
-        slow_transactions = reporting_period.slow_transactions_payload
-        jobs = reporting_period.jobs
-        slow_jobs = reporting_period.slow_jobs_payload
-        histograms = reporting_period.histograms
-        db_query_metrics = reporting_period.db_query_metrics_payload
-
-        metadata = {
-          :app_root      => ScoutApm::Environment.instance.root.to_s,
-          :unique_id     => ScoutApm::Utils::UniqueId.simple,
-          :agent_version => ScoutApm::VERSION,
-          :agent_time    => reporting_period.timestamp.to_s,
-          :agent_pid     => Process.pid,
-          :platform      => "ruby",
-        }
-
-        log_deliver(metrics, slow_transactions, metadata, slow_jobs, histograms)
-
-        payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs, histograms, db_query_metrics)
-        logger.debug("Sending payload w/ Headers: #{headers.inspect}")
-
-        reporter.report(payload, headers)
-      rescue => e
-        logger.warn "Error on checkin"
-        logger.info e.message
-        logger.debug e.backtrace
-      end
-
-      def log_deliver(metrics, slow_transactions, metadata, jobs_traces, histograms)
-        total_request_count = metrics.
-          select { |meta,stats| meta.metric_name =~ /\AController/ }.
-          inject(0) {|sum, (_, stat)| sum + stat.call_count }
-
-        memory = metrics.
-          find {|meta,stats| meta.metric_name =~ /\AMemory/ }
-        process_log_str = if memory
-                            "Recorded from #{memory.last.call_count} processes"
-                          else
-                            "Recorded across (unknown) processes"
-                          end
-
-        time_clause       = "[#{Time.parse(metadata[:agent_time]).strftime("%H:%M")}]"
-        metrics_clause    = "#{metrics.length} Metrics for #{total_request_count} requests"
-        slow_trans_clause = "#{slow_transactions.length} Slow Transaction Traces"
-        job_clause        = "#{jobs_traces.length} Job Traces"
-        histogram_clause  = "#{histograms.length} Histograms"
-
-        logger.info "#{time_clause} Delivering #{metrics_clause} and #{slow_trans_clause} and #{job_clause}, #{process_log_str}."
-        logger.debug("\n\nMetrics: #{metrics.pretty_inspect}\nSlowTrans: #{slow_transactions.pretty_inspect}\nMetadata: #{metadata.inspect.pretty_inspect}\n\n")
-      end
-
-      # TODO: Move this into PayloadSerializer?
-      def headers
-        if ScoutApm::Agent.instance.config.value("report_format") == 'json'
-          headers = {'Content-Type' => 'application/json'}
-        else
-          headers = {}
-        end
-      end
-
-      # Before reporting, lookup metric_id for each MetricMeta. This speeds up
-      # reporting on the server-side.
-      def add_metric_ids(metrics)
-        metrics.each do |meta,stats|
-          if metric_id = metric_lookup[meta]
-            meta.metric_id = metric_id
-          end
-        end
-      end
-    end
-    include Reporting
-  end
-end

data/lib/scout_apm/utils/null_logger.rb

@@ -1,13 +0,0 @@
-require 'logger'
-
-module ScoutApm
-  module Utils
-    class NullLogger < Logger
-      def initialize(*args)
-      end
-
-      def add(*args, &block)
-      end
-    end
-  end
-end