Implement telemetry log

lib/datadog/core/telemetry/component.rb

@@ -111,6 +111,12 @@ def integrations_change!
           @worker.enqueue(Event::AppIntegrationsChange.new)
         end
 
+        def log!(event)
+          return unless @enabled || forked?
+
+          @worker.enqueue(event)
+        end
+
         # Report configuration changes caused by Remote Configuration.
         def client_configuration_change!(changes)
           return if !@enabled || forked?

lib/datadog/core/telemetry/event.rb

@@ -334,6 +334,33 @@ def payload
           end
         end
 
+        # Telemetry class for the 'logs' event
+        class Log < Base
+          LEVELS = {
+            error: 'ERROR',
+            debug: 'DEBUG',
+            warn: 'WARN',
+          }.freeze
+
+          def type
+            'logs'
+          end
+
+          def initialize(message:, level:)
+            super()
+            @message = message
+            @level = LEVELS.fetch(level) { |k| raise ArgumentError, "Invalid log level :#{k}"}
+          end
+
+          def payload
+            {
+              message: @message,
+              level: @level,
+              # More optional fields to be added here...
+            }
+          end
+        end
+
         # Telemetry class for the 'distributions' event
         class Distributions < GenerateMetrics
           def type

lib/datadog/core/telemetry/logging.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+
+module Datadog
+  module Core
+    module Telemetry
+      # Logging interface for sending telemetry logs.
+      #
+      # Reporting internal error so that we can fix them.
+      # IMPORTANT: Make sure to not log any sensitive information.
+      module Logging
+        module_function
+
+        def report(exception, level:)
+          # Annoymous exceptions to be logged as <Class:0x00007f8b1c0b3b40>
+          message = exception.class.name || exception.class.inspect
+
+          event = Event::Log.new(
+            message: message,
+            level: level
+          )
+
+          if (telemetry = Datadog.send(:components).telemetry)
+            telemetry.log!(event)
+          else
+            Datadog.logger.debug do
+              "Attempting to send telemetry log when telemetry component is not ready: #{message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

sig/datadog/core/telemetry/component.rbs

@@ -25,6 +25,8 @@ module Datadog
 
         def integrations_change!: () -> void
 
+        def log!: (Datadog::Core::Telemetry::Event::Log) -> void
+
         def inc: (String namespace, String metric_name, Datadog::Core::Telemetry::Metric::input_value value, ?tags: Datadog::Core::Telemetry::Metric::tags_input, ?common: bool) -> void
 
         def dec: (String namespace, String metric_name, Datadog::Core::Telemetry::Metric::input_value value, ?tags: Datadog::Core::Telemetry::Metric::tags_input, ?common: bool) -> void

sig/datadog/core/telemetry/event.rbs

@@ -67,6 +67,17 @@ module Datadog
           def initialize: (String namespace, Enumerable[Datadog::Core::Telemetry::Metric::Base] metric_series) -> void
         end
 
+        class Log < Base
+          LEVELS: Hash[Symbol, String]
+
+          @message: String
+          @level: "ERROR" | "DEBUG" | "WARN"
+
+          def initialize: (message: String, level: Symbol) -> void
+
+          def payload: () -> { message: String, level: String }
+        end
+
         class Distributions < GenerateMetrics
         end
 

sig/datadog/core/telemetry/logging.rbs

@@ -0,0 +1,9 @@
+module Datadog
+  module Core
+    module Telemetry
+      module Logging
+        def report: (Exception exception, level: Symbol) -> void
+      end
+    end
+  end
+end

spec/datadog/core/telemetry/component_spec.rb

@@ -219,6 +219,55 @@
     end
   end
 
+  describe '#log!' do
+    after do
+      telemetry.stop!
+    end
+
+    describe 'when enabled' do
+      let(:enabled) { true }
+      it do
+        event = double('event')
+        telemetry.log!(event)
+
+        expect(worker).to have_received(:enqueue).with(event)
+      end
+
+      context 'when in fork', skip: !Process.respond_to?(:fork) do
+        it do
+          expect_in_fork do
+            event = double('event')
+            telemetry.log!(event)
+
+            expect(worker).to have_received(:enqueue).with(event)
+          end
+        end
+      end
+    end
+
+    describe 'when disabled' do
+      let(:enabled) { false }
+
+      it do
+        event = double('event')
+        telemetry.log!(event)
+
+        expect(worker).not_to have_received(:enqueue)
+      end
+
+      context 'when in fork', skip: !Process.respond_to?(:fork) do
+        it do
+          expect_in_fork do
+            event = double('event')
+            telemetry.log!(event)
+
+            expect(worker).not_to have_received(:enqueue)
+          end
+        end
+      end
+    end
+  end
+
   context 'metrics support' do
     let(:metrics_manager) { spy(:metrics_manager) }
     let(:namespace) { double('namespace') }

spec/datadog/core/telemetry/event_spec.rb

@@ -213,6 +213,41 @@ def contain_configuration(*array)
     end
   end
 
+  context 'Logs' do
+    it do
+      event = Datadog::Core::Telemetry::Event::Log.new(message: 'Hi', level: :error)
+      expect(event.type).to eq('logs')
+      expect(event.payload).to eq(
+        message: 'Hi',
+        level: 'ERROR'
+      )
+    end
+
+    it do
+      event = Datadog::Core::Telemetry::Event::Log.new(message: 'Hi', level: :debug)
+      expect(event.type).to eq('logs')
+      expect(event.payload).to eq(
+        message: 'Hi',
+        level: 'DEBUG'
+      )
+    end
+
+    it do
+      event = Datadog::Core::Telemetry::Event::Log.new(message: 'Hi', level: :warn)
+      expect(event.type).to eq('logs')
+      expect(event.payload).to eq(
+        message: 'Hi',
+        level: 'WARN'
+      )
+    end
+
+    it do
+      expect do
+        Datadog::Core::Telemetry::Event::Log.new(message: 'Hi', level: :unknown)
+      end.to raise_error(ArgumentError, /Invalid log level/)
+    end
+  end
+
   context 'GenerateMetrics' do
     let(:event) { described_class::GenerateMetrics.new(namespace, metrics) }
 

spec/datadog/core/telemetry/logging_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+require 'datadog/core/telemetry/logging'
+
+RSpec.describe Datadog::Core::Telemetry::Logging do
+  describe '.report' do
+    context 'with named exception' do
+      it 'sends a log event to via telemetry' do
+        telemetry = double('telemetry')
+        allow(Datadog.send(:components)).to receive(:telemetry).and_return(telemetry)
+        expect(telemetry).to receive(:log!).with(instance_of(Datadog::Core::Telemetry::Event::Log)) do |event|
+          expect(event.payload).to include(message: 'RuntimeError', level: 'ERROR')
+        end
+
+        begin
+          raise 'Invalid token: p@ssw0rd'
+        rescue StandardError => e
+          described_class.report(e, level: :error)
+        end
+      end
+    end
+
+    context 'with anonymous exception' do
+      it 'sends a log event to via telemetry' do
+        telemetry = double('telemetry')
+        allow(Datadog.send(:components)).to receive(:telemetry).and_return(telemetry)
+        expect(telemetry).to receive(:log!).with(instance_of(Datadog::Core::Telemetry::Event::Log)) do |event|
+          expect(event.payload).to include(message: /#<Class:/, level: 'ERROR')
+        end
+
+        customer_exception = Class.new(StandardError)
+
+        begin
+          raise customer_exception, 'Invalid token: p@ssw0rd'
+        rescue StandardError => e
+          described_class.report(e, level: :error)
+        end
+      end
+    end
+
+    context 'when telemetry component is not available' do
+      it 'does not sends a log event to via telemetry' do
+        logger = Logger.new($stdout)
+        expect(Datadog.send(:components)).to receive(:telemetry).and_return(nil)
+        expect(Datadog).to receive(:logger).and_return(logger)
+        expect(logger).to receive(:debug).with(no_args) do |&block|
+          expect(block.call).to match /Attempting to send telemetry log when telemetry component is not ready/
+        end
+
+        begin
+          raise 'Invalid token: p@ssw0rd'
+        rescue StandardError => e
+          described_class.report(e, level: :error)
+        end
+      end
+    end
+  end
+end