scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/agent/logging.rb

@@ -0,0 +1,69 @@
+# 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
+        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

@@ -0,0 +1,126 @@
+# 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 one 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
+
+        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)
+
+        payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs)
+        # logger.debug("Payload: #{payload}")
+
+        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)
+        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"
+
+        logger.info "#{time_clause} Delivering #{metrics_clause} and #{slow_trans_clause} and #{job_clause}, #{process_log_str}."
+        # logger.debug("Metrics: #{metrics.pretty_inspect}\nSlowTrans: #{slow_transactions.pretty_inspect}\nMetadata: #{metadata.inspect.pretty_inspect}")
+      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