fix profiler enablement reporting

Author: p

lib/datadog/core/telemetry/event/app_started.rb

@@ -55,7 +55,7 @@ def products(components)
                 enabled: components.settings.appsec.enabled,
               },
               profiler: {
-                enabled: !!components.profiler&.enabled?,
+                enabled: !!components.profiler,
               },
               dynamic_instrumentation: {
                 enabled: !!components.dynamic_instrumentation,

lib/datadog/profiling.rb

@@ -61,8 +61,7 @@ def self.allocation_count
     end
 
     def self.enabled?
-      profiler = Datadog.send(:components).profiler
-      !!profiler&.enabled?
+      !!Datadog.send(:components).profiler
     end
 
     def self.wait_until_running(timeout_seconds: 5)

lib/datadog/profiling/profiler.rb

@@ -17,10 +17,6 @@ def initialize(worker:, scheduler:)
         @scheduler = scheduler
       end
 
-      def enabled?
-        scheduler.running?
-      end
-
       def start
         after_fork! do
           worker.reset_after_fork

spec/datadog/core/telemetry/integration/telemetry_spec.rb

@@ -468,6 +468,61 @@
     end
   end
 
+  describe 'app-started event' do
+    context 'when profiling is enabled' do
+      http_server do |http_server|
+        http_server.mount_proc('/telemetry/proxy/api/v2/apmtelemetry', &handler_proc)
+      end
+
+      before do
+        Datadog.configure do |c|
+          c.agent.port = http_server_port
+          c.telemetry.enabled = true
+
+          c.profiling.enabled = true
+        end
+      end
+
+      after do
+        Datadog.configuration.reset!
+      end
+
+      let(:settings) do
+        Datadog.configuration
+      end
+
+      let(:component) { Datadog.send(:components).telemetry }
+
+      it 'reports profiling as being enabled' do
+        component.flush
+        expect(sent_payloads.length).to eq 3
+
+        payload = sent_payloads[0]
+        expect(payload.fetch(:payload)).to include(
+          'request_type' => 'app-started',
+        )
+        expect(payload.fetch(:payload).dig('payload', 'products')).to include(
+          'profiler' => {'enabled' => true},
+        )
+
+        # For sanity checking verify that the remaining events are as we
+        # expect them to be.
+        payload = sent_payloads[1]
+        expect(payload.fetch(:payload)).to include(
+          'request_type' => 'app-dependencies-loaded',
+        )
+
+        payload = sent_payloads[2]
+        expect(payload.fetch(:payload)).to include(
+          'request_type' => 'message-batch',
+        )
+        expect(payload.fetch(:payload).fetch('payload').first).to include(
+          'request_type' => 'app-integrations-change',
+        )
+      end
+    end
+  end
+
   context 'when process forks' do
     # The mode is irrelevant but we need settings from the context.
     include_context 'agent mode'

spec/datadog/profiling/profiler_spec.rb

@@ -13,22 +13,6 @@
   let(:worker) { instance_double(Datadog::Profiling::Collectors::CpuAndWallTimeWorker) }
   let(:scheduler) { instance_double(Datadog::Profiling::Scheduler) }
 
-  describe '.enabled?' do
-    subject(:enabled?) { profiler.enabled? }
-
-    let(:scheduler) { instance_double('Datadog::Profiling::Scheduler', running?: running) }
-
-    context 'when the profiler is running' do
-      let(:running) { true }
-      it { is_expected.to be(true) }
-    end
-
-    context 'when the profiler is not running' do
-      let(:running) { false }
-      it { is_expected.to be(false) }
-    end
-  end
-
   describe "#start" do
     subject(:start) { profiler.start }
 

spec/datadog/profiling_spec.rb

@@ -72,17 +72,9 @@
     end
 
     context 'when a profiler is available' do
-      let(:profiler) { instance_double('Datadog::Profiling::Profiler', enabled?: enabled) }
+      let(:profiler) { instance_double(Datadog::Profiling::Profiler) }
 
-      context 'when the profiler is enabled' do
-        let(:enabled) { true }
-        it { is_expected.to be(true) }
-      end
-
-      context 'when the profiler is not enabled' do
-        let(:enabled) { false }
-        it { is_expected.to be(false) }
-      end
+      it { is_expected.to be(true) }
     end
   end