Add Sentry error capturing for logs controller

app/controllers/metrics/v2/logs_controller.rb

@@ -5,10 +5,21 @@ class Metrics::V2::LogsController < ApplicationController
 
   def create
     metric = Metric.create_metric_from_rest(self, allowed_params, current_user)
-
     failed_metric_info = metric&.errors.inspect || allowed_params[:message]
     Rails.logger.info("Failed to create metric #{failed_metric_info}") unless metric&.valid?
 
+    if (metric.metric_type === 'error')
+      error_info = {
+        name: metric.metric_name,
+        class: metric.metric_class,
+        attrs: metric.metric_attributes,
+        created_at: metric.created_at,
+        uuid: metric.uuid,
+      }
+      error = StandardError.new(error_info)
+      Raven.capture_exception(error)
+    end
+
     head :ok
   end
 

spec/controllers/metrics/v2/logs_controller_spec.rb

@@ -1,40 +1,44 @@
 # frozen_string_literal: true
 
 describe Metrics::V2::LogsController, type: :controller do
-
-  let(:request_params_javascript) do
+  let(:current_user) { create(:user) }
+  let(:request_params) do
     {
       metric: {
+        uuid: SecureRandom.uuid,
         method: "123456789",
-        uuid: "PAT123456^CFL200^A",
-        url: '',
-        message: '',
-        isError: false,
-        isPerformance: false,
-        source: 'javascript'
-      }
+        name: 'log',
+        group: 'service',
+        message: 'This is a test',
+        type: 'performance',
+        product: 'reader',
+       }
     }
   end
 
-  let(:request_params_min) do
-    {
-      metric: {
-        message: 'min'
-      }
-    }
+  before do
+    @raven_called = false
   end
-
+  before { User.authenticate!(user: current_user) }
 
   context "with good request" do
-    it "returns 200 for javascript source" do
-      expect(Metric).to receive(:create_javascript_metric).and_return(nil)
-      post :create, params: request_params_javascript
+    it "returns 200 for request params" do
+      post :create, params: request_params
+      expect(@raven_called).to eq(false)
       expect(response.status).to eq(200)
     end
+  end
 
-    it "returns 200 for min params" do
-      post :create, params: request_params_min
-      expect(response.status).to eq(200)
+  context "With error type record to sentry" do
+    it "Records to Sentry" do
+      capture_raven_log
+      request_params[:metric][:type] = 'error'
+      post :create, params: request_params
+      expect(@raven_called).to eq(true)
     end
   end
+
+  def capture_raven_log
+    allow(Raven).to receive(:capture_exception) { @raven_called = true }
+  end
 end

spec/models/metric_spec.rb

@@ -3,46 +3,46 @@
 describe Metric do
   let(:user) { create(:user) }
 
-  describe "create_javascript_metric" do
+  before { User.authenticate!(user: user) }
+
+  describe "create_metric" do
     let!(:params) do
        {
+        uuid: SecureRandom.uuid,
         method: "123456789",
-        uuid: "PAT123456^CFL200^A",
-        url: '',
-        message: '',
-        isError: false,
-        isPerformance: false,
-        source: 'javascript'
+        name: 'log',
+        group: 'service',
+        message: 'This is a test',
+        type: 'performance',
+        product: 'reader',
        }
     end
 
-    it "creates a javascript metric for log" do
-      options = {is_error: false, performance: false}
-      metric = Metric.create_javascript_metric(params, user, options)
+    it "creates a javascript metric for performance" do
+      metric = Metric.create_metric(self, params, user)
 
       expect(metric.valid?).to be true
-      expect(metric.metric_type).to eq(Metric::METRIC_TYPES[:log])
+      expect(metric.metric_type).to eq(Metric::METRIC_TYPES[:performance])
     end
 
-    it "creates a javascript metric for error" do
-      options = {is_error: true, performance: false}
-      metric = Metric.create_javascript_metric(params, user, options)
+    it "creates a javascript metric for log" do
+      params[:type] = 'log'
+      metric = Metric.create_metric(self, params, user)
 
       expect(metric.valid?).to be true
-      expect(metric.metric_type).to eq(Metric::METRIC_TYPES[:error])
+      expect(metric.metric_type).to eq(Metric::METRIC_TYPES[:log])
     end
 
-    it "creates a javascript metric for performance" do
-      options = {is_error: false, performance: true}
-      metric = Metric.create_javascript_metric(params, user, options)
+    it "creates a javascript metric for error" do
+      params[:type]  = 'error'
+      metric = Metric.create_metric(self, params, user)
 
       expect(metric.valid?).to be true
-      expect(metric.metric_type).to eq(Metric::METRIC_TYPES[:performance])
+      expect(metric.metric_type).to eq(Metric::METRIC_TYPES[:error])
     end
 
     it "creates a javascript metric with invalid sent_to" do
-      options = {is_error: false, performance: false}
-      metric = Metric.create_javascript_metric(params.merge({sent_to: 'fake'}), user, options)
+      metric = Metric.create_metric(self, params.merge({sent_to: 'fake'}), user)
 
       expect(metric.valid?).to be false
     end