Emit parser metrics for HTTP parsed languages

Porting similar logic to https://github.com/codeclimate/codeclimate-structure/pull/289
into duplication.

Author: wfleming

lib/cc/engine/analyzers/analyzer_base.rb

@@ -28,8 +28,9 @@ class Base
 
         MAJOR_SEVERITY_THRESHOLD = 120 * POINTS_PER_MINUTE
 
-        def initialize(engine_config:)
+        def initialize(engine_config:, parse_metrics:)
           @engine_config = engine_config
+          @parse_metrics = parse_metrics
         end
 
         def run(file)
@@ -97,7 +98,7 @@ def use_sexp_lines?
 
         private
 
-        attr_reader :engine_config
+        attr_reader :engine_config, :parse_metrics
 
         def base_points
           self.class::BASE_POINTS
@@ -131,6 +132,7 @@ def skip?(_path)
 
         def parse(file, request_path)
           processed_source = ProcessedSource.new(file, request_path)
+          parse_metrics.incr(:succeeded)
           SexpBuilder.new(processed_source.ast, file).build
         rescue => ex
           handle_exception(processed_source, ex)
@@ -144,11 +146,14 @@ def handle_exception(processed_source, ex)
             CC.logger.warn("Skipping #{processed_source.path} due to #{ex.class}")
             CC.logger.warn("Response status: #{ex.response_status}")
             CC.logger.debug { "Response:\n#{ex.response_body}" }
+            parse_metrics.incr(ex.code.to_sym)
           when ex.is_a?(CC::Parser::Client::EncodingError)
             CC.logger.warn("Skipping #{processed_source.path} due to #{ex.class}: #{ex.message}")
+            parse_metrics.incr(:encoding_error)
           when ex.is_a?(CC::Parser::Client::NestingDepthError)
             CC.logger.warn("Skipping #{processed_source.path} due to #{ex.class}")
             CC.logger.warn(ex.message)
+            parse_metrics.incr(:client_nesting_depth_error)
           else
             CC.logger.error("Error processing file: #{processed_source.path}")
             CC.logger.error(ex.message)

lib/cc/engine/duplication.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
+require "cc/engine/parse_metrics"
 require "cc/engine/analyzers/ruby/main"
 require "cc/engine/analyzers/java/main"
 require "cc/engine/analyzers/javascript/main"
@@ -34,9 +35,17 @@ def run
 
         Dir.chdir(directory) do
           languages_to_analyze.each do |language|
-            engine = LANGUAGES[language].new(engine_config: engine_config)
+            parse_metrics = ParseMetrics.new(
+              language: language,
+              io: io,
+            )
+            engine = LANGUAGES[language].new(
+              engine_config: engine_config,
+              parse_metrics: parse_metrics,
+            )
             reporter = CC::Engine::Analyzers::Reporter.new(engine_config, engine, io)
             reporter.run
+            parse_metrics.report
           end
         end
       end

lib/cc/engine/parse_metrics.rb

@@ -0,0 +1,35 @@
+module CC
+  module Engine
+    class ParseMetrics
+      def initialize(language:, io:)
+        @language = language
+        @io = io
+        @counts = Hash.new(0)
+      end
+
+      def incr(result_type)
+        counts[result_type] += 1
+      end
+
+      def report
+        counts.each do |result_type, count|
+          doc = metric_doc(result_type, count)
+          # puts allows a race between content newline, use print
+          io.print("#{JSON.generate(doc)}\0\n")
+        end
+      end
+
+      private
+
+      attr_reader :counts, :io, :language
+
+      def metric_doc(result_type, count)
+        {
+          name: "#{language}.parse.#{result_type}",
+          type: "measurement",
+          value: count,
+        }
+      end
+    end
+  end
+end

spec/cc/engine/analyzers/analyzer_base_spec.rb

@@ -15,7 +15,15 @@ class DummyAnalyzer < Base
     include AnalyzerSpecHelpers
 
     let(:engine_config) { EngineConfig.new({}) }
-    let(:analyzer) { DummyAnalyzer.new(engine_config: engine_config) }
+    let(:analyzer) do
+      DummyAnalyzer.new(
+        engine_config: engine_config,
+        parse_metrics: CC::Engine::ParseMetrics.new(
+          language: "dummy",
+          io: StringIO.new,
+        ),
+      )
+    end
 
     before(:each) do
       create_source_file("foo.a", "")

spec/cc/engine/analyzers/ruby/main_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
-require 'cc/engine/analyzers/ruby/main'
 require 'cc/engine/analyzers/engine_config'
+require 'cc/engine/analyzers/ruby/main'
+require 'cc/engine/parse_metrics'
 
 module CC::Engine::Analyzers
   RSpec.describe Ruby::Main, in_tmpdir: true do
@@ -228,7 +229,7 @@ def identical
     end
 
     describe "#calculate_points" do
-      let(:analyzer) { Ruby::Main.new(engine_config: engine_conf) }
+      let(:analyzer) { new_analyzer }
       let(:base_points) { Ruby::Main::BASE_POINTS }
       let(:points_per) { Ruby::Main::POINTS_PER_OVERAGE }
       let(:threshold) { Ruby::Main::DEFAULT_MASS_THRESHOLD }
@@ -274,7 +275,7 @@ def identical
     end
 
     describe "#calculate_severity(points)" do
-      let(:analyzer) { Ruby::Main.new(engine_config: engine_conf) }
+      let(:analyzer) { new_analyzer }
       let(:base_points) { Ruby::Main::BASE_POINTS }
       let(:points_per) { Ruby::Main::POINTS_PER_OVERAGE }
       let(:threshold) { Ruby::Main::DEFAULT_MASS_THRESHOLD }
@@ -307,6 +308,16 @@ def identical
       end
     end
 
+    def new_analyzer
+      Ruby::Main.new(
+        engine_config: engine_conf,
+        parse_metrics: CC::Engine::ParseMetrics.new(
+          language: "ruby",
+          io: StringIO.new,
+        ),
+      )
+    end
+
     def engine_conf
       EngineConfig.new({})
     end

spec/cc/engine/duplication_spec.rb

@@ -2,6 +2,8 @@
 require "cc/engine/duplication"
 
 RSpec.describe(CC::Engine::Duplication) do
+  include AnalyzerSpecHelpers
+
   describe "#run" do
     it "skips analysis when all duplication checks are disabled" do
       dir = "foo"
@@ -24,5 +26,25 @@
         directory: dir, engine_config: config, io: double,
       ).run
     end
+
+    it "emits parse metrics for HTTP parsed languages", in_tmpdir: true do
+      create_source_file("foo.js", <<-EOJS)
+        console.log("hello JS!");
+      EOJS
+
+      stdout = StringIO.new
+
+      CC::Engine::Duplication.new(
+        directory: @code, engine_config: {}, io: stdout,
+      ).run
+
+      expect(stdout.string).not_to be_empty
+      measurement = JSON.parse(stdout.string.strip)
+      expect(measurement).to eq(
+        "name" => "javascript.parse.succeeded",
+        "type" => "measurement",
+        "value" => 1,
+      )
+    end
   end
 end

spec/cc/engine/parse_metrics_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+require "cc/engine/parse_metrics"
+
+RSpec.describe CC::Engine::ParseMetrics do
+    it "sends issues to stdout" do
+      stdout = StringIO.new
+      metrics = CC::Engine::ParseMetrics.new(
+        language: "intercal",
+        io: stdout,
+      )
+
+      metrics.incr(:source_minified)
+      metrics.incr(:parse_error)
+      metrics.incr(:source_minified)
+
+      metrics.report
+
+      out_pieces = stdout.string.split("\0\n").map(&:strip)
+      expect(out_pieces.count).to eq(2)
+
+      expect(JSON.parse(out_pieces[0])).to eq({
+          "name" => "intercal.parse.source_minified",
+          "type" => "measurement",
+          "value" => 2,
+      })
+
+      expect(JSON.parse(out_pieces[1])).to eq({
+          "name" => "intercal.parse.parse_error",
+          "type" => "measurement",
+          "value" => 1,
+      })
+    end
+end

spec/support/helpers/analyzer_spec_helpers.rb

@@ -1,3 +1,5 @@
+require 'cc/engine/parse_metrics'
+
 module AnalyzerSpecHelpers
   def create_source_file(path, content)
     raise "Must use in_tmpdir tag" unless @code
@@ -11,7 +13,13 @@ def fixture_path(fixture_name)
   def run_engine(config = nil)
     io = StringIO.new
 
-    engine = described_class.new(engine_config: config)
+    engine = described_class.new(
+      engine_config: config,
+      parse_metrics: CC::Engine::ParseMetrics.new(
+        language: described_class::LANGUAGE,
+        io: StringIO.new,
+      ),
+    )
     reporter = ::CC::Engine::Analyzers::Reporter.new(config, engine, io)
 
     reporter.run