datadog 2.16.0 → 2.18.0

data/lib/datadog/di/instrumenter.rb

@@ -52,6 +52,17 @@ module Datadog
     # (however, Probe instances can be replaced by OpenStruct instances
     # providing the same interface with not much effort).
     #
+    # Instrumenter (this class) is responsible for building snapshots.
+    # This is because to capture values on method entry, those values need to
+    # be duplicated or serialized into immutable values to prevent their
+    # modification by the instrumented method. Therefore this class must
+    # do at least some serialization/snapshot building and to keep the code
+    # well-encapsulated, all serialization/snapshot building should thus be
+    # initiated from this class rather than downstream code.
+    #
+    # As a consequence of Instrumenter building snapshots, it should not
+    # expose TracePoint objects to any downstream code.
+    #
     # @api private
     class Instrumenter
       def initialize(settings, serializer, logger, code_tracker: nil, telemetry: nil)
@@ -111,7 +122,8 @@ module Datadog
               # Arguments may be mutated by the method, therefore
               # they need to be serialized prior to method invocation.
               entry_args = if probe.capture_snapshot?
-                serializer.serialize_args(args, kwargs,
+                instance_vars = Instrumenter.get_instance_variables(self)
+                serializer.serialize_args(args, kwargs, instance_vars,
                   depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
                   attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count)
               end
@@ -149,6 +161,7 @@ module Datadog
               # TODO capture arguments at exit
               # & is to stop steep complaints, block is always present here.
               block&.call(probe: probe, rv: rv, duration: duration, caller_locations: caller_locs,
+                instance_vars: probe.capture_snapshot? ? Instrumenter.get_instance_variables(self) : nil,
                 serialized_entry_args: entry_args)
               rv
             else
@@ -298,8 +311,20 @@ module Datadog
               probe.file == tp.path || probe.file_matches?(tp.path)
             )
               if rate_limiter.nil? || rate_limiter.allow?
+                locals = if probe.capture_snapshot?
+                  serializer.serialize_vars(Instrumenter.get_local_variables(tp),
+                    depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                    attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+                end
+                instance_vars = if probe.capture_snapshot?
+                  serializer.serialize_vars(Instrumenter.get_instance_variables(tp.self),
+                    depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                    attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+                end
                 # & is to stop steep complaints, block is always present here.
-                block&.call(probe: probe, trace_point: tp, caller_locations: caller_locations)
+                block&.call(probe: probe,
+                  locals: locals, instance_vars: instance_vars,
+                  path: tp.path, caller_locations: caller_locations)
               end
             end
           rescue => exc
@@ -371,6 +396,31 @@ module Datadog
         end
       end
 
+      class << self
+        def get_instance_variables(object)
+          {}.tap do |hash|
+            object.instance_variables.each do |var|
+              hash[var] = object.instance_variable_get(var)
+            end
+          end
+        end
+
+        def get_local_variables(trace_point)
+          # binding appears to be constructed on access, therefore
+          # 1) we should attempt to cache it and
+          # 2) we should not call +binding+ until we actually need variable values.
+          binding = trace_point.binding
+
+          # steep hack - should never happen
+          return {} unless binding
+
+          binding.local_variables.each_with_object({}) do |name, map|
+            value = binding.local_variable_get(name)
+            map[name] = value
+          end
+        end
+      end
+
       private
 
       attr_reader :lock

data/lib/datadog/di/probe_notification_builder.rb

@@ -39,39 +39,50 @@ module Datadog
       end
 
       # Duration is in seconds.
+      # path is the actual path of the instrumented file.
       def build_executed(probe,
-        trace_point: nil, rv: nil, duration: nil, caller_locations: nil,
-        args: nil, kwargs: nil, serialized_entry_args: nil)
-        snapshot = if probe.line? && probe.capture_snapshot?
-          if trace_point.nil?
-            raise "Cannot create snapshot because there is no trace point"
-          end
-          get_local_variables(trace_point)
-        end
-        # TODO check how many stack frames we should be keeping/sending,
-        # this should be all frames for enriched probes and no frames for
-        # non-enriched probes?
-        build_snapshot(probe, rv: rv, snapshot: snapshot,
+        path: nil, rv: nil, duration: nil, caller_locations: nil,
+        locals: nil, args: nil, kwargs: nil, instance_vars: nil,
+        serialized_entry_args: nil)
+        build_snapshot(probe, rv: rv, locals: locals,
           # Actual path of the instrumented file.
-          path: trace_point&.path,
-          duration: duration, caller_locations: caller_locations, args: args, kwargs: kwargs,
+          path: path,
+          duration: duration,
+          # TODO check how many stack frames we should be keeping/sending,
+          # this should be all frames for enriched probes and no frames for
+          # non-enriched probes?
+          caller_locations: caller_locations,
+          args: args, kwargs: kwargs, instance_vars: instance_vars,
           serialized_entry_args: serialized_entry_args)
       end
 
-      def build_snapshot(probe, rv: nil, snapshot: nil, path: nil,
-        duration: nil, caller_locations: nil, args: nil, kwargs: nil,
+      def build_snapshot(probe, rv: nil, locals: nil, path: nil,
+        duration: nil, caller_locations: nil,
+        args: nil, kwargs: nil, instance_vars: nil,
         serialized_entry_args: nil)
         # TODO also verify that non-capturing probe does not pass
         # snapshot or vars/args into this method
         captures = if probe.capture_snapshot?
           if probe.method?
+            return_arguments = {
+              "@return": serializer.serialize_value(rv,
+                depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count),
+            }
+            if instance_vars
+              return_arguments.update(
+                serializer.serialize_vars(instance_vars,
+                  depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+                  attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+              )
+            end
             {
               entry: {
                 # standard:disable all
                 arguments: if serialized_entry_args
                   serialized_entry_args
                 else
-                  (args || kwargs) && serializer.serialize_args(args, kwargs,
+                  (args || kwargs) && serializer.serialize_args(args, kwargs, instance_vars,
                     depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
                     attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count)
                 end,
@@ -79,20 +90,14 @@ module Datadog
                 # standard:enable all
               },
               return: {
-                arguments: {
-                  "@return": serializer.serialize_value(rv,
-                    depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-                    attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count),
-                },
+                arguments: return_arguments,
                 throwable: nil,
               },
             }
           elsif probe.line?
             {
-              lines: snapshot && {
-                probe.line_no => {locals: serializer.serialize_vars(snapshot,
-                  depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
-                  attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)},
+              lines: locals && {
+                probe.line_no => {locals: locals.merge(instance_vars || {})},
               },
             }
           end
@@ -194,21 +199,6 @@ module Datadog
         (Core::Utils::Time.now.to_f * 1000).to_i
       end
 
-      def get_local_variables(trace_point)
-        # binding appears to be constructed on access, therefore
-        # 1) we should attempt to cache it and
-        # 2) we should not call +binding+ until we actually need variable values.
-        binding = trace_point.binding
-
-        # steep hack - should never happen
-        return {} unless binding
-
-        binding.local_variables.each_with_object({}) do |name, map|
-          value = binding.local_variable_get(name)
-          map[name] = value
-        end
-      end
-
       def active_trace
         if defined?(Datadog::Tracing)
           Datadog::Tracing.active_trace

data/lib/datadog/di/probe_notifier_worker.rb

@@ -183,7 +183,15 @@ module Datadog
       end
 
       def do_send_snapshot(batch)
-        snapshot_transport.send_input(batch)
+        snapshot_transport.send_input(batch, tags)
+      end
+
+      def tags
+        # DEV: The tags could be cached but they need to be recreated
+        # when process forks (since the child receives new runtime IDs).
+        Core::TagBuilder.tags(settings).merge(
+          'debugger_version' => Core::Environment::Identity.gem_datadog_version,
+        )
       end
 
       [

data/lib/datadog/di/serializer.rb

@@ -82,7 +82,11 @@ module Datadog
       # between positional and keyword arguments. We convert positional
       # arguments to keyword arguments ("arg1", "arg2", ...) and ensure
       # the positional arguments are listed first.
-      def serialize_args(args, kwargs,
+      #
+      # Instance variables are technically a hash just like kwargs,
+      # we take them as a separate parameter to avoid a hash merge
+      # in upstream code.
+      def serialize_args(args, kwargs, instance_vars,
         depth: settings.dynamic_instrumentation.max_capture_depth,
         attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count)
         counter = 0
@@ -91,7 +95,7 @@ module Datadog
           # Conversion to symbol is needed here to put args ahead of
           # kwargs when they are merged below.
           c[:"arg#{counter}"] = value
-        end.update(kwargs)
+        end.update(kwargs).update(instance_vars)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count)
       end
 

data/lib/datadog/di/transport/http/input.rb

@@ -53,6 +53,16 @@ module Datadog
                 # Encode body & type
                 env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
                 env.body = env.request.parcel.data
+                env.query = {
+                  # DEV: In theory we could serialize the tags here
+                  # rather than requiring them to be pre-serialized.
+                  # In practice the tags should be relatively static
+                  # (they would change when process forks, and hostname
+                  # could change at any time but probably we should ignore
+                  # those changes), therefore serializing the tags
+                  # every time would be wasteful.
+                  ddtags: env.request.serialized_tags,
+                }
 
                 super
               end

data/lib/datadog/di/transport/input.rb

@@ -12,6 +12,13 @@ module Datadog
         end
 
         class Request < Datadog::Core::Transport::Request
+          attr_reader :serialized_tags
+
+          def initialize(parcel, serialized_tags)
+            super(parcel)
+
+            @serialized_tags = serialized_tags
+          end
         end
 
         class Transport
@@ -28,10 +35,11 @@ module Datadog
             @apis[HTTP::API::INPUT]
           end
 
-          def send_input(payload)
+          def send_input(payload, tags)
             json = JSON.dump(payload)
             parcel = EncodedParcel.new(json)
-            request = Request.new(parcel)
+            serialized_tags = Core::TagBuilder.serialize_tags(tags)
+            request = Request.new(parcel, serialized_tags)
 
             response = @client.send_input_payload(request)
             unless response.ok?

data/lib/datadog/error_tracking/component.rb

@@ -33,9 +33,9 @@ module Datadog
           if RUBY_ENGINE != 'ruby'
             logger.warn("error tracking: cannot enable error tracking: MRI is required, but running on #{RUBY_ENGINE}")
             false
-          elsif RUBY_VERSION < '2.6'
+          elsif RUBY_VERSION < '2.7'
             logger.warn(
-              "error tracking: cannot enable error tracking: Ruby 2.6+ is required, but running
+              "error tracking: cannot enable error tracking: Ruby 2.7+ is required, but running
               on #{RUBY_VERSION}"
             )
             false

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -14,7 +14,10 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
-        def initialize(standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"))
+        def initialize(
+          standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"),
+          ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
+        )
           @libraries_by_name = {}
           @libraries_by_path = {}
           @seen_files = Set.new
@@ -26,6 +29,7 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
+              extra_path: ruby_native_filename,
             )
           )
         end
@@ -37,12 +41,8 @@ module Datadog
           self
         end
 
-        def generate
-          seen_libraries
-        end
-
         def generate_json
-          JSON.fast_generate(v1: seen_libraries.to_a)
+          JSON.generate(v1: seen_libraries.to_a)
         end
 
         private
@@ -79,7 +79,15 @@ module Datadog
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
-            record_library(Library.new(kind: "library", name: spec.name, version: spec.version, path: spec.gem_dir))
+            record_library(
+              Library.new(
+                kind: "library",
+                name: spec.name,
+                version: spec.version,
+                path: spec.gem_dir,
+                extra_path: (spec.extension_dir if spec.extensions.any?),
+              )
+            )
             recorded_library = true
           end
 
@@ -110,11 +118,12 @@ module Datadog
         class Library
           attr_reader :kind, :name, :version
 
-          def initialize(kind:, name:, version:, path:)
+          def initialize(kind:, name:, version:, path:, extra_path: nil)
+            extra_path = nil if extra_path&.empty?
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze].freeze
+            @paths = [path.dup.freeze, extra_path.dup.freeze].compact.freeze
             freeze
           end
 

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -33,6 +33,9 @@ module Datadog
             Datadog.logger.warn(
               "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
+            )
           end
 
           self.class._native_initialize(
@@ -77,6 +80,7 @@ module Datadog
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
+              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error", pii_safe: true)
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -41,6 +41,7 @@ module Datadog
                 "IdleSamplingHelper thread error. " \
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
+              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error", pii_safe: true)
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -21,7 +21,8 @@ module Datadog
           endpoint_collection_enabled:,
           timeline_enabled:,
           waiting_for_gvl_threshold_ns:,
-          otel_context_enabled:
+          otel_context_enabled:,
+          native_filenames_enabled:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
@@ -33,6 +34,7 @@ module Datadog
             timeline_enabled: timeline_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
           )
         end
 
@@ -44,6 +46,7 @@ module Datadog
           timeline_enabled: false,
           waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
+          native_filenames_enabled: true,
           **options
         )
           new(
@@ -54,6 +57,7 @@ module Datadog
             timeline_enabled: timeline_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: native_filenames_enabled,
             **options,
           )
         end
@@ -81,6 +85,17 @@ module Datadog
           context = provider.instance_variable_get(:@context)
           context&.instance_variable_get(:@key)
         end
+
+        def validate_native_filenames(native_filenames_enabled)
+          if native_filenames_enabled && !Datadog::Profiling::Collectors::Stack._native_filenames_available?
+            Datadog.logger.debug(
+              "Native filenames are enabled, but the required dladdr API was not available. Disabling native filenames."
+            )
+            false
+          else
+            native_filenames_enabled
+          end
+        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -96,6 +96,7 @@ module Datadog
           timeline_enabled: timeline_enabled,
           waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
           otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
+          native_filenames_enabled: settings.profiling.advanced.native_filenames_enabled,
         )
       end
 
@@ -221,13 +222,14 @@ module Datadog
         end
 
         unless allocation_profiling_enabled
-          raise ArgumentError, "Heap profiling requires allocation profiling to be enabled"
+          logger.warn(
+            "Heap profiling was requested but allocation profiling is not enabled. " \
+            "Heap profiling has been disabled."
+          )
+          return false
         end
 
-        logger.warn(
-          "Enabled experimental heap profiling: heap_sample_rate=#{heap_sample_rate}. This is experimental, not " \
-          "recommended, and will increase overhead!"
-        )
+        logger.debug("Enabled heap profiling: heap_sample_rate=#{heap_sample_rate}")
 
         true
       end
@@ -237,10 +239,6 @@ module Datadog
 
         return false unless heap_profiling_enabled && heap_size_profiling_enabled
 
-        logger.warn(
-          "Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!"
-        )
-
         true
       end
 

data/lib/datadog/profiling/ext.rb

@@ -11,20 +11,7 @@ module Datadog
 
       module Transport
         module HTTP
-          FORM_FIELD_TAG_ENV = "env"
-          FORM_FIELD_TAG_HOST = "host"
-          FORM_FIELD_TAG_LANGUAGE = "language"
-          FORM_FIELD_TAG_PID = "process_id"
           FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
-          FORM_FIELD_TAG_RUNTIME = "runtime"
-          FORM_FIELD_TAG_RUNTIME_ENGINE = "runtime_engine"
-          FORM_FIELD_TAG_RUNTIME_ID = "runtime-id"
-          FORM_FIELD_TAG_RUNTIME_PLATFORM = "runtime_platform"
-          FORM_FIELD_TAG_RUNTIME_VERSION = "runtime_version"
-          FORM_FIELD_TAG_SERVICE = "service"
-          FORM_FIELD_TAG_VERSION = "version"
-          TAG_GIT_REPOSITORY_URL = "git.repository_url"
-          TAG_GIT_COMMIT_SHA = "git.commit.sha"
 
           CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end

data/lib/datadog/profiling/flush.rb

@@ -32,7 +32,7 @@ module Datadog
         @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
         @tags_as_array = tags_as_array
-        @internal_metadata_json = JSON.fast_generate(internal_metadata)
+        @internal_metadata_json = JSON.generate(internal_metadata)
         @info_json = info_json
       end
     end

data/lib/datadog/profiling/http_transport.rb

@@ -29,12 +29,7 @@ module Datadog
         status, result = self.class._native_do_export(
           exporter_configuration,
           @upload_timeout_milliseconds,
-          flush,
-          # TODO: This is going to be removed once we move to libdatadog 17
-          flush.start.tv_sec,
-          flush.start.tv_nsec,
-          flush.finish.tv_sec,
-          flush.finish.tv_nsec,
+          flush
         )
 
         if status == :ok
@@ -42,7 +37,7 @@ module Datadog
             Datadog.logger.debug("Successfully reported profiling data")
             true
           else
-            Datadog.logger.error(
+            Datadog.logger.warn(
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
@@ -52,7 +47,7 @@ module Datadog
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog.logger.warn("Failed to report profiling data (#{config_without_api_key}): #{result}")
           Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end

data/lib/datadog/profiling/profiler.rb

@@ -50,6 +50,8 @@ module Datadog
           "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
           "See previous log messages for details."
         )
+        Datadog::Core::Telemetry::Logger
+          .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
 
         # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
         # we're operating in a degraded state and crash tracking may still be helpful.

data/lib/datadog/profiling/scheduler.rb

@@ -37,6 +37,7 @@ module Datadog
         @exporter = exporter
         @transport = transport
         @profiler_failed = false
+        @stop_requested = false
 
         # Workers::Async::Thread settings
         self.fork_policy = fork_policy
@@ -67,6 +68,7 @@ module Datadog
           "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
         )
         on_failure_proc&.call
+        Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
         raise
       ensure
         Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
@@ -88,7 +90,7 @@ module Datadog
       end
 
       def work_pending?
-        !profiler_failed && exporter.can_flush?
+        !profiler_failed && exporter.can_flush? && (run_loop? || !stop_requested?)
       end
 
       def reset_after_fork
@@ -132,14 +134,20 @@ module Datadog
         begin
           transport.export(flush)
         rescue => e
-          Datadog.logger.error(
+          Datadog.logger.warn(
             "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
+        @stop_requested = !run_loop?
+
         true
       end
+
+      def stop_requested?
+        @stop_requested
+      end
     end
   end
 end

data/lib/datadog/profiling/stack_recorder.rb

@@ -23,7 +23,7 @@ module Datadog
         # This isn't something we expect to happen normally, but because it would break the assumptions of the
         # C-level mutexes (that there is a single serializer thread), we add it here as an extra safeguard against it
         # accidentally happening.
-        @no_concurrent_synchronize_mutex = Mutex.new
+        @no_concurrent_serialize_mutex = Mutex.new
 
         self.class._native_initialize(
           self_instance: self,
@@ -60,7 +60,7 @@ module Datadog
       end
 
       def serialize
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
           start, finish, encoded_profile, profile_stats = result
@@ -71,15 +71,15 @@ module Datadog
         else
           error_message = result
 
-          Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
-          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
+          Datadog.logger.warn("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data (#{error_message})")
 
           nil
         end
       end
 
       def serialize!
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
           _start, _finish, encoded_profile = result