ddtrace 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eadd5e3cd8cb0144883eb120e8aee9289d06acfc2e8c5b4b6d863f524be26e7
-  data.tar.gz: 6d0005127cfe83c0332275215a850a33d13e7670ae74982286e9fe77ac7214b9
+  metadata.gz: b4e4740121e3fe300ff3f114e1ef7f968e104f46644fb0355fc1f1f3f977e725
+  data.tar.gz: 914ba68d4f3be6ad282bfe21e03bbeecd4b6a0c37fd6efb625ae4c9cfe386518
 SHA512:
-  metadata.gz: 58e0edde95e595e435e6fad3ee078fe6bb6cf70301b6802b3b527b2804af259276752f3820901962ff94729149d60f4c81be7d3fe5c1c81b5b2119db89a9d3fa
-  data.tar.gz: baf7561a9b11f8a80fd8f36fe331c8dbdb7a7271db4cfe69f78e50b26a5946c426d0cba38b032eea964e619c3f67fcecb8b0350e72e73b7c02c53af84dbd8ecd
+  metadata.gz: 26d08410fc6d1ce577df1eb6dc8df1d49aa04c3581aeae799e74c0fb682ea314e788755b910654a5a8682fbf648e68c38393baeba559470153aff6776bd6bd0c
+  data.tar.gz: ad50fc9303b945511e2f886a4bbedf7c5d813889829ddfdf9f904361ec5f36e3a02d331c224933ef7b9a9524dbfb2a889fabbc93511eb7bd099ac38928de3b2a

data/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## [Unreleased]
 
+## [1.4.0] - 2022-08-25
+
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v1.4.0
+
+Git diff: https://github.com/DataDog/dd-trace-rb/compare/v1.3.0...v1.4.0
+
+### Added
+
+* gRPC: tag `grpc.client.deadline` ([#2200][])
+* Implement telemetry, disable by default ([#2153][])
+
+### Changed
+
+* Bump `libdatadog` dependency version ([#2229][])
+
+### Fixed
+
+* Fix CI instrumentation configuration ([#2219][])
+
+## [1.3.0] - 2022-08-04
+
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v1.3.0
+
+Git diff: https://github.com/DataDog/dd-trace-rb/compare/v1.2.0...v1.3.0
+
+### Added
+
+* Top-level span being tagged to avoid duplicate computation ([#2138][])
+
+### Changed
+
+* ActiveSupport: Optionally disable tracing with Rails ([@marcotc][])
+* Rack: Resource overwritten by nested application ([#2180][])
+* Rake: Explicit task instrumentation to prevent memory bloat ([#2174][])
+* Sidekiq and DelayedJob: Add spans to improve tracing ([#2170][])
+* Drop Profiling support for Ruby 2.1 ([#2140][])
+* Migrate `libddprof` dependency to `libdatadog` ([#2061][])
+
+### Fixed
+
+* Fix OpenTracing propagation with TraceDigest ([#2201][])
+* Fix SpanFilter dropping descendant spans ([#2074][])
+* Redis: Fix Empty pipelined span being dropped ([#757][]) ([@sponomarev][])
+* Fix profiler not restarting on `Process.daemon` ([#2150][])
+* Fix setting service from Rails configuration ([#2118][]) ([@agrobbin][])
+* Some document and development improvement ([@marocchino][]) ([@yukimurasawa][])
+
 ## [1.2.0] - 2022-07-11
 
 Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v1.2.0
@@ -2354,6 +2401,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#753]: https://github.com/DataDog/dd-trace-rb/issues/753
 [#754]: https://github.com/DataDog/dd-trace-rb/issues/754
 [#756]: https://github.com/DataDog/dd-trace-rb/issues/756
+[#757]: https://github.com/DataDog/dd-trace-rb/issues/757
 [#760]: https://github.com/DataDog/dd-trace-rb/issues/760
 [#762]: https://github.com/DataDog/dd-trace-rb/issues/762
 [#765]: https://github.com/DataDog/dd-trace-rb/issues/765
@@ -2892,9 +2940,11 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2028]: https://github.com/DataDog/dd-trace-rb/issues/2028
 [#2054]: https://github.com/DataDog/dd-trace-rb/issues/2054
 [#2059]: https://github.com/DataDog/dd-trace-rb/issues/2059
+[#2061]: https://github.com/DataDog/dd-trace-rb/issues/2061
 [#2066]: https://github.com/DataDog/dd-trace-rb/issues/2066
 [#2069]: https://github.com/DataDog/dd-trace-rb/issues/2069
 [#2070]: https://github.com/DataDog/dd-trace-rb/issues/2070
+[#2074]: https://github.com/DataDog/dd-trace-rb/issues/2074
 [#2076]: https://github.com/DataDog/dd-trace-rb/issues/2076
 [#2079]: https://github.com/DataDog/dd-trace-rb/issues/2079
 [#2082]: https://github.com/DataDog/dd-trace-rb/issues/2082
@@ -2902,8 +2952,24 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2097]: https://github.com/DataDog/dd-trace-rb/issues/2097
 [#2110]: https://github.com/DataDog/dd-trace-rb/issues/2110
 [#2113]: https://github.com/DataDog/dd-trace-rb/issues/2113
+[#2118]: https://github.com/DataDog/dd-trace-rb/issues/2118
 [#2125]: https://github.com/DataDog/dd-trace-rb/issues/2125
 [#2134]: https://github.com/DataDog/dd-trace-rb/issues/2134
+[#2138]: https://github.com/DataDog/dd-trace-rb/issues/2138
+[#2140]: https://github.com/DataDog/dd-trace-rb/issues/2140
+[#2150]: https://github.com/DataDog/dd-trace-rb/issues/2150
+[#2153]: https://github.com/DataDog/dd-trace-rb/issues/2153
+[#2158]: https://github.com/DataDog/dd-trace-rb/issues/2158
+[#2162]: https://github.com/DataDog/dd-trace-rb/issues/2162
+[#2163]: https://github.com/DataDog/dd-trace-rb/issues/2163
+[#2170]: https://github.com/DataDog/dd-trace-rb/issues/2170
+[#2173]: https://github.com/DataDog/dd-trace-rb/issues/2173
+[#2174]: https://github.com/DataDog/dd-trace-rb/issues/2174
+[#2180]: https://github.com/DataDog/dd-trace-rb/issues/2180
+[#2200]: https://github.com/DataDog/dd-trace-rb/issues/2200
+[#2201]: https://github.com/DataDog/dd-trace-rb/issues/2201
+[#2219]: https://github.com/DataDog/dd-trace-rb/issues/2219
+[#2229]: https://github.com/DataDog/dd-trace-rb/issues/2229
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -2996,6 +3062,8 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@link04]: https://github.com/link04
 [@lloeki]: https://github.com/lloeki
 [@mantrala]: https://github.com/mantrala
+[@marcotc]: https://github.com/marcotc
+[@marocchino]: https://github.com/marocchino
 [@masato-hi]: https://github.com/masato-hi
 [@matchbookmac]: https://github.com/matchbookmac
 [@mberlanda]: https://github.com/mberlanda
@@ -3027,6 +3095,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@sinsoku]: https://github.com/sinsoku
 [@skcc321]: https://github.com/skcc321
 [@soulcutter]: https://github.com/soulcutter
+[@sponomarev]: https://github.com/sponomarev
 [@stefanahman]: https://github.com/stefanahman
 [@steveh]: https://github.com/steveh
 [@stormsilver]: https://github.com/stormsilver
@@ -3041,4 +3110,5 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@vramaiah]: https://github.com/vramaiah
 [@walterking]: https://github.com/walterking
 [@y-yagi]: https://github.com/y-yagi
+[@yukimurasawa]: https://github.com/yukimurasawa
 [@zachmccormick]: https://github.com/zachmccormick

data/LICENSE-3rdparty.csv

@@ -2,3 +2,5 @@ Component,Origin,License,Copyright
 lib/datadog/core/vendor/multipart-post,https://github.com/socketry/multipart-post,MIT,"Copyright (c) 2007-2013 Nick Sieger."
 lib/datadog/tracing/contrib/active_record/vendor,https://github.com/rails/rails/,MIT,"Copyright (c) 2005-2018 David Heinemeier Hansson"
 ext/ddtrace_profiling_native_extension/private_vm_api_access,https://github.com/ruby/ruby,BSD-2-Clause,"Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved."
+msgpack,https://rubygems.org/gems/msgpack,Apache-2.0,"Copyright (c) 2008-2015 Sadayuki Furuhashi"
+debase-ruby_core_source,https://rubygems.org/gems/debase-ruby_core_source,MIT for gem and BSD-2-Clause for Ruby sources,"Copyright (c) 2012 Gabriel Horner. Files from Ruby sources are Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved."

data/README.md

@@ -1,4 +1,4 @@
-***Version 1.0.0 has recently been released. Check out our [upgrade guide](https://github.com/DataDog/dd-trace-rb/blob/master/docs/UpgradeGuide.md#from-0x-to-10) for more details.***
+**We've recently released the 1.x version series. If you're upgrading from a 0.x version, check out our [upgrade guide](https://github.com/DataDog/dd-trace-rb/blob/master/docs/UpgradeGuide.md#from-0x-to-10).**
 
 # Datadog Trace Client
 

data/ext/ddtrace_profiling_loader/ddtrace_profiling_loader.c

@@ -20,7 +20,7 @@
 // This idea was shamelessly stolen from @lloeki's work in https://github.com/rubyjs/mini_racer/pull/179, big thanks!
 //
 // Extra note: Currently (May 2022), that we know of, the profiling native extension only exposes one potentially
-// problematic symbol: `rust_eh_personality` (coming from libddprof/libdatadog).
+// problematic symbol: `rust_eh_personality` (coming from libdatadog).
 // Future versions of Rust have been patched not to expose this
 // (see https://github.com/rust-lang/rust/pull/95604#issuecomment-1108563434) so we may want to revisit the need
 // for this loader in the future, and perhaps delete it if we no longer require its services :)

data/ext/ddtrace_profiling_native_extension/NativeExtensionDesign.md

@@ -2,7 +2,7 @@
 
 The profiling native extension is used to:
 1. Implement features which are expensive (in terms of resources) or otherwise impossible to implement using Ruby code.
-2. Bridge between Ruby-specific profiling features and [`libddprof`](https://github.com/DataDog/libddprof), a Rust-based
+2. Bridge between Ruby-specific profiling features and [`libdatadog`](https://github.com/DataDog/libdatadog), a Rust-based
 library with common profiling functionality.
 
 Due to (1), this extension is quite coupled with MRI Ruby ("C Ruby") internals, and is not intended to support other rubies such as
@@ -18,6 +18,11 @@ the gem. Setting `DD_PROFILING_NO_EXTENSION` at installation time skips compilat
 In past releases, it was possible for the profiler to run without the native extension, but that's no longer the case,
 and disabling the extension will disable profiling.
 
+## Who is this page for?
+
+This documentation is intended to be used by dd-trace-rb developers. Please see the `docs/` folder for user-level
+documentation.
+
 ## Must not block or break users that cannot use it
 
 The profiling native extension is (and must always be) designed to **not cause failures** during gem installation, even
@@ -49,7 +54,7 @@ We avoid issues using a combination of:
 
 Non-exhaustive list of APIs that cause exceptions to be raised:
 
-* `Check_TypedStruct`, `Check_Type`
+* `Check_TypedStruct`, `Check_Type`, `ENFORCE_TYPE`
 * `rb_funcall`
 * `rb_thread_call_without_gvl`, `rb_thread_call_without_gvl2`
 * [Numeric conversion APIs, e.g. `NUM2LONG`, `NUM2INT`, etc.](https://silverhammermba.github.io/emberb/c/?#translation)
@@ -67,6 +72,8 @@ Because these private header files are not included in regular Ruby installation
 
 Functions which make use of these headers are defined in the <private_vm_api_acccess.c> file.
 
+There is currently no way for disabling usage of the private MJIT header for Ruby 2.6+.
+
 **Important Note**: Our medium/long-term plan is to stop relying on all private Ruby headers, and instead request and
 contribute upstream changes so that they become official public VM APIs.
 

data/ext/ddtrace_profiling_native_extension/clock_id.h

@@ -1,4 +1,24 @@
 #pragma once
 
+#include <stdbool.h>
+#include <time.h>
+
+// Contains the operating-system specific identifier needed to fetch CPU-time, and a flag to indicate if we failed to fetch it
+typedef struct thread_cpu_time_id {
+  bool valid;
+  clockid_t clock_id;
+} thread_cpu_time_id;
+
+// Contains the current cpu time, and a flag to indicate if we failed to fetch it
+typedef struct thread_cpu_time {
+  bool valid;
+  long result_ns;
+} thread_cpu_time;
+
 void self_test_clock_id(void);
+
+// TODO: Remove this after the OldStack profiler gets removed
 VALUE clock_id_for(VALUE self, VALUE thread);
+
+thread_cpu_time_id thread_cpu_time_id_for(VALUE thread);
+thread_cpu_time thread_cpu_time_for(thread_cpu_time_id time_id);

data/ext/ddtrace_profiling_native_extension/clock_id_from_pthread.c

@@ -9,6 +9,7 @@
 #include <errno.h>
 
 #include <ruby.h>
+#include "helpers.h"
 #include "private_vm_api_access.h"
 #include "clock_id.h"
 
@@ -20,7 +21,8 @@ void self_test_clock_id(void) {
   if (expected_pthread_id != actual_pthread_id) rb_raise(rb_eRuntimeError, "pthread_id_for() self-test failed");
 }
 
-VALUE clock_id_for(VALUE self, VALUE thread) {
+// TODO: Remove this after the OldStack profiler gets removed
+VALUE clock_id_for(DDTRACE_UNUSED VALUE _self, VALUE thread) {
   rb_nativethread_id_t thread_id = pthread_id_for(thread);
 
   clockid_t clock_id;
@@ -41,4 +43,31 @@ VALUE clock_id_for(VALUE self, VALUE thread) {
   }
 }
 
+thread_cpu_time_id thread_cpu_time_id_for(VALUE thread) {
+  rb_nativethread_id_t thread_id = pthread_id_for(thread);
+  clockid_t clock_id;
+
+  int error = pthread_getcpuclockid(thread_id, &clock_id);
+
+  if (error == 0) {
+    return (thread_cpu_time_id) {.valid = true, .clock_id = clock_id};
+  } else {
+    // TODO: Include the error code in some way in the output?
+    return (thread_cpu_time_id) {.valid = false};
+  }
+}
+
+thread_cpu_time thread_cpu_time_for(thread_cpu_time_id time_id) {
+  thread_cpu_time error = (thread_cpu_time) {.valid = false};
+
+  if (!time_id.valid) { return error; }
+
+  struct timespec current_cpu;
+
+  // TODO: Include the error code in some way in the output?
+  if (clock_gettime(time_id.clock_id, &current_cpu) != 0) return error;
+
+  return (thread_cpu_time) {.valid = true, .result_ns = current_cpu.tv_nsec + (current_cpu.tv_sec * 1000 * 1000 * 1000)};
+}
+
 #endif

data/ext/ddtrace_profiling_native_extension/clock_id_noop.c

@@ -7,8 +7,17 @@
 #include <ruby.h>
 
 #include "clock_id.h"
+#include "helpers.h"
 
 void self_test_clock_id(void) { } // Nothing to check
-VALUE clock_id_for(VALUE self, VALUE thread) { return Qnil; } // Nothing to return
+VALUE clock_id_for(DDTRACE_UNUSED VALUE _self, DDTRACE_UNUSED VALUE _thread) { return Qnil; } // Nothing to return
+
+thread_cpu_time_id thread_cpu_time_id_for(DDTRACE_UNUSED VALUE _thread) {
+  return (thread_cpu_time_id) {.valid = false};
+}
+
+thread_cpu_time thread_cpu_time_for(DDTRACE_UNUSED thread_cpu_time_id _time_id) {
+  return (thread_cpu_time) {.valid = false};
+}
 
 #endif

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time.c

@@ -1,12 +1,20 @@
 #include <ruby.h>
+#include "helpers.h"
+#include "clock_id.h"
 #include "collectors_stack.h"
-#include "stack_recorder.h"
+#include "libdatadog_helpers.h"
 #include "private_vm_api_access.h"
+#include "stack_recorder.h"
+#include "collectors_cpu_and_wall_time.h"
 
-// Used to periodically (time-based) sample threads, recording elapsed CPU-time and Wall-time between samples.
+// Used to periodically sample threads, recording elapsed CPU-time and Wall-time between samples.
+//
 // This file implements the native bits of the Datadog::Profiling::Collectors::CpuAndWallTime class
+//
+// Triggering of this component (e.g. deciding when to take a sample) is implemented in Collectors::CpuAndWallTimeWorker.
 
-static VALUE collectors_cpu_and_wall_time_class = Qnil;
+#define INVALID_TIME -1
+#define THREAD_ID_LIMIT_CHARS 20
 
 // Contains state for a single CpuAndWallTime instance
 struct cpu_and_wall_time_collector_state {
@@ -25,7 +33,11 @@ struct cpu_and_wall_time_collector_state {
 
 // Tracks per-thread state
 struct per_thread_context {
-  int dummy_placeholder_will_be_removed_in_next_pr;
+  char thread_id[THREAD_ID_LIMIT_CHARS];
+  ddprof_ffi_CharSlice thread_id_char_slice;
+  thread_cpu_time_id thread_cpu_time_id;
+  long cpu_time_at_previous_sample_ns;  // Can be INVALID_TIME until initialized or if getting it fails for another reason
+  long wall_time_at_previous_sample_ns; // Can be INVALID_TIME until initialized
 };
 
 static void cpu_and_wall_time_collector_typed_data_mark(void *state_ptr);
@@ -35,19 +47,25 @@ static int hash_map_per_thread_context_free_values(st_data_t _thread, st_data_t
 static VALUE _native_new(VALUE klass);
 static VALUE _native_initialize(VALUE self, VALUE collector_instance, VALUE recorder_instance, VALUE max_frames);
 static VALUE _native_sample(VALUE self, VALUE collector_instance);
-static void sample(VALUE collector_instance);
 static VALUE _native_thread_list(VALUE self);
 static struct per_thread_context *get_or_create_context_for(VALUE thread, struct cpu_and_wall_time_collector_state *state);
+static void initialize_context(VALUE thread, struct per_thread_context *thread_context);
 static VALUE _native_inspect(VALUE self, VALUE collector_instance);
 static VALUE per_thread_context_st_table_as_ruby_hash(struct cpu_and_wall_time_collector_state *state);
 static int per_thread_context_as_ruby_hash(st_data_t key_thread, st_data_t value_context, st_data_t result_hash);
 static void remove_context_for_dead_threads(struct cpu_and_wall_time_collector_state *state);
 static int remove_if_dead_thread(st_data_t key_thread, st_data_t value_context, st_data_t _argument);
 static VALUE _native_per_thread_context(VALUE self, VALUE collector_instance);
+static long update_time_since_previous_sample(long *time_at_previous_sample_ns, long current_time_ns);
+static long cpu_time_now_ns(struct per_thread_context *thread_context);
+static long wall_time_now_ns();
+static long thread_id_for(VALUE thread);
 
 void collectors_cpu_and_wall_time_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
-  collectors_cpu_and_wall_time_class = rb_define_class_under(collectors_module, "CpuAndWallTime", rb_cObject);
+  VALUE collectors_cpu_and_wall_time_class = rb_define_class_under(collectors_module, "CpuAndWallTime", rb_cObject);
+  // Hosts methods used for testing the native code using RSpec
+  VALUE testing_module = rb_define_module_under(collectors_cpu_and_wall_time_class, "Testing");
 
   // Instances of the CpuAndWallTime class are "TypedData" objects.
   // "TypedData" objects are special objects in the Ruby VM that can wrap C structs.
@@ -60,10 +78,10 @@ void collectors_cpu_and_wall_time_init(VALUE profiling_module) {
   rb_define_alloc_func(collectors_cpu_and_wall_time_class, _native_new);
 
   rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_initialize", _native_initialize, 3);
-  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_sample", _native_sample, 1);
-  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_thread_list", _native_thread_list, 0);
   rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_inspect", _native_inspect, 1);
-  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_per_thread_context", _native_per_thread_context, 1);
+  rb_define_singleton_method(testing_module, "_native_sample", _native_sample, 1);
+  rb_define_singleton_method(testing_module, "_native_thread_list", _native_thread_list, 0);
+  rb_define_singleton_method(testing_module, "_native_per_thread_context", _native_per_thread_context, 1);
 }
 
 // This structure is used to define a Ruby object that stores a pointer to a struct cpu_and_wall_time_collector_state
@@ -107,14 +125,14 @@ static void cpu_and_wall_time_collector_typed_data_free(void *state_ptr) {
 }
 
 // Mark Ruby thread references we keep as keys in hash_map_per_thread_context
-static int hash_map_per_thread_context_mark(st_data_t key_thread, st_data_t _value, st_data_t _argument) {
+static int hash_map_per_thread_context_mark(st_data_t key_thread, DDTRACE_UNUSED st_data_t _value, DDTRACE_UNUSED st_data_t _argument) {
   VALUE thread = (VALUE) key_thread;
   rb_gc_mark(thread);
   return ST_CONTINUE;
 }
 
 // Used to clear each of the per_thread_contexts inside the hash_map_per_thread_context
-static int hash_map_per_thread_context_free_values(st_data_t _thread, st_data_t value_per_thread_context, st_data_t _argument) {
+static int hash_map_per_thread_context_free_values(DDTRACE_UNUSED st_data_t _thread, st_data_t value_per_thread_context, DDTRACE_UNUSED st_data_t _argument) {
   struct per_thread_context *per_thread_context = (struct per_thread_context*) value_per_thread_context;
   ruby_xfree(per_thread_context);
   return ST_CONTINUE;
@@ -131,12 +149,10 @@ static VALUE _native_new(VALUE klass) {
   state->recorder_instance = Qnil;
   state->sample_count = 0;
 
-  return TypedData_Wrap_Struct(collectors_cpu_and_wall_time_class, &cpu_and_wall_time_collector_typed_data, state);
+  return TypedData_Wrap_Struct(klass, &cpu_and_wall_time_collector_typed_data, state);
 }
 
-static VALUE _native_initialize(VALUE self, VALUE collector_instance, VALUE recorder_instance, VALUE max_frames) {
-  enforce_recorder_instance(recorder_instance);
-
+static VALUE _native_initialize(DDTRACE_UNUSED VALUE _self, VALUE collector_instance, VALUE recorder_instance, VALUE max_frames) {
   struct cpu_and_wall_time_collector_state *state;
   TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
 
@@ -146,42 +162,69 @@ static VALUE _native_initialize(VALUE self, VALUE collector_instance, VALUE reco
   // Update this when modifying state struct
   state->sampling_buffer = sampling_buffer_new(max_frames_requested);
   // hash_map_per_thread_context is already initialized, nothing to do here
-  state->recorder_instance = recorder_instance;
+  state->recorder_instance = enforce_recorder_instance(recorder_instance);
 
   return Qtrue;
 }
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTime behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
-static VALUE _native_sample(VALUE self, VALUE collector_instance) {
-  sample(collector_instance);
+static VALUE _native_sample(DDTRACE_UNUSED VALUE _self, VALUE collector_instance) {
+  cpu_and_wall_time_collector_sample(collector_instance);
   return Qtrue;
 }
 
-static void sample(VALUE collector_instance) {
+// This function gets called from the Collectors::CpuAndWallTimeWorker to trigger the actual sampling.
+//
+// Assumption 1: This function is called in a thread that is holding the Global VM Lock. Caller is responsible for enforcing this.
+// Assumption 2: This function is allowed to raise exceptions. Caller is responsible for handling them, if needed.
+// Assumption 3: This function IS NOT called from a signal handler. This function is not async-signal-safe.
+// Assumption 4: This function IS NOT called in a reentrant way.
+VALUE cpu_and_wall_time_collector_sample(VALUE self_instance) {
   struct cpu_and_wall_time_collector_state *state;
-  TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
+  TypedData_Get_Struct(self_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
 
   VALUE threads = ddtrace_thread_list();
+  long current_wall_time_ns = wall_time_now_ns();
 
   const long thread_count = RARRAY_LEN(threads);
   for (long i = 0; i < thread_count; i++) {
     VALUE thread = RARRAY_AREF(threads, i);
     struct per_thread_context *thread_context = get_or_create_context_for(thread, state);
 
+    long current_cpu_time_ns = cpu_time_now_ns(thread_context);
+
+    long cpu_time_elapsed_ns =
+      update_time_since_previous_sample(&thread_context->cpu_time_at_previous_sample_ns, current_cpu_time_ns);
+    long wall_time_elapsed_ns =
+      update_time_since_previous_sample(&thread_context->wall_time_at_previous_sample_ns, current_wall_time_ns);
+
     int64_t metric_values[ENABLED_VALUE_TYPES_COUNT] = {0};
 
-    // FIXME: TODO These are just dummy values for now
-    metric_values[CPU_TIME_VALUE_POS] = 12;
-    metric_values[CPU_SAMPLES_VALUE_POS] = 34;
-    metric_values[WALL_TIME_VALUE_POS] = 56;
+    metric_values[CPU_TIME_VALUE_POS] = cpu_time_elapsed_ns;
+    metric_values[CPU_SAMPLES_VALUE_POS] = 1;
+    metric_values[WALL_TIME_VALUE_POS] = wall_time_elapsed_ns;
+
+    VALUE thread_name = thread_name_for(thread);
+    bool have_thread_name = thread_name != Qnil;
+
+    int label_count = 1 + (have_thread_name ? 1 : 0);
+    ddprof_ffi_Label labels[label_count];
+
+    labels[0] = (ddprof_ffi_Label) {.key = DDPROF_FFI_CHARSLICE_C("thread id"), .str = thread_context->thread_id_char_slice};
+    if (have_thread_name) {
+      labels[1] = (ddprof_ffi_Label) {
+        .key = DDPROF_FFI_CHARSLICE_C("thread name"),
+        .str = char_slice_from_ruby_string(thread_name)
+      };
+    }
 
     sample_thread(
       thread,
       state->sampling_buffer,
       state->recorder_instance,
       (ddprof_ffi_Slice_i64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
-      (ddprof_ffi_Slice_label) {.ptr = NULL, .len = 0} // FIXME: TODO we need to gather the expected labels
+      (ddprof_ffi_Slice_label) {.ptr = labels, .len = label_count}
     );
   }
 
@@ -190,11 +233,14 @@ static void sample(VALUE collector_instance) {
   // TODO: This seems somewhat overkill and inefficient to do often; right now we just doing every few samples
   // but there's probably a better way to do this if we actually track when threads finish
   if (state->sample_count % 100 == 0) remove_context_for_dead_threads(state);
+
+  // Return a VALUE to make it easier to call this function from Ruby APIs that expect a return value (such as rb_rescue2)
+  return Qnil;
 }
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTime behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
-static VALUE _native_thread_list(VALUE self) {
+static VALUE _native_thread_list(DDTRACE_UNUSED VALUE _self) {
   return ddtrace_thread_list();
 }
 
@@ -206,13 +252,25 @@ static struct per_thread_context *get_or_create_context_for(VALUE thread, struct
     thread_context = (struct per_thread_context*) value_context;
   } else {
     thread_context = ruby_xcalloc(1, sizeof(struct per_thread_context));
+    initialize_context(thread, thread_context);
     st_insert(state->hash_map_per_thread_context, (st_data_t) thread, (st_data_t) thread_context);
   }
 
   return thread_context;
 }
 
-static VALUE _native_inspect(VALUE self, VALUE collector_instance) {
+static void initialize_context(VALUE thread, struct per_thread_context *thread_context) {
+  snprintf(thread_context->thread_id, THREAD_ID_LIMIT_CHARS, "%ld", thread_id_for(thread));
+  thread_context->thread_id_char_slice = (ddprof_ffi_CharSlice) {.ptr = thread_context->thread_id, .len = strlen(thread_context->thread_id)};
+
+  thread_context->thread_cpu_time_id = thread_cpu_time_id_for(thread);
+
+  // These will get initialized during actual sampling
+  thread_context->cpu_time_at_previous_sample_ns = INVALID_TIME;
+  thread_context->wall_time_at_previous_sample_ns = INVALID_TIME;
+}
+
+static VALUE _native_inspect(DDTRACE_UNUSED VALUE _self, VALUE collector_instance) {
   struct cpu_and_wall_time_collector_state *state;
   TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
 
@@ -236,11 +294,18 @@ static VALUE per_thread_context_st_table_as_ruby_hash(struct cpu_and_wall_time_c
 
 static int per_thread_context_as_ruby_hash(st_data_t key_thread, st_data_t value_context, st_data_t result_hash) {
   VALUE thread = (VALUE) key_thread;
+  struct per_thread_context *thread_context = (struct per_thread_context*) value_context;
   VALUE result = (VALUE) result_hash;
   VALUE context_as_hash = rb_hash_new();
   rb_hash_aset(result, thread, context_as_hash);
 
-  VALUE arguments[] = {};
+  VALUE arguments[] = {
+    ID2SYM(rb_intern("thread_id")),                       /* => */ rb_str_new2(thread_context->thread_id),
+    ID2SYM(rb_intern("thread_cpu_time_id_valid?")),       /* => */ thread_context->thread_cpu_time_id.valid ? Qtrue : Qfalse,
+    ID2SYM(rb_intern("thread_cpu_time_id")),              /* => */ CLOCKID2NUM(thread_context->thread_cpu_time_id.clock_id),
+    ID2SYM(rb_intern("cpu_time_at_previous_sample_ns")),  /* => */ LONG2NUM(thread_context->cpu_time_at_previous_sample_ns),
+    ID2SYM(rb_intern("wall_time_at_previous_sample_ns")), /* => */ LONG2NUM(thread_context->wall_time_at_previous_sample_ns)
+  };
   for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(context_as_hash, arguments[i], arguments[i+1]);
 
   return ST_CONTINUE;
@@ -250,7 +315,7 @@ static void remove_context_for_dead_threads(struct cpu_and_wall_time_collector_s
   st_foreach(state->hash_map_per_thread_context, remove_if_dead_thread, 0 /* unused */);
 }
 
-static int remove_if_dead_thread(st_data_t key_thread, st_data_t value_context, st_data_t _argument) {
+static int remove_if_dead_thread(st_data_t key_thread, st_data_t value_context, DDTRACE_UNUSED st_data_t _argument) {
   VALUE thread = (VALUE) key_thread;
   struct per_thread_context* thread_context = (struct per_thread_context*) value_context;
 
@@ -260,10 +325,66 @@ static int remove_if_dead_thread(st_data_t key_thread, st_data_t value_context,
   return ST_DELETE;
 }
 
-// Returns the whole contents of the per_thread_context structs being tracked, for debugging/testing
-static VALUE _native_per_thread_context(VALUE self, VALUE collector_instance) {
+// This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTime behavior using RSpec.
+// It SHOULD NOT be used for other purposes.
+//
+// Returns the whole contents of the per_thread_context structs being tracked.
+static VALUE _native_per_thread_context(DDTRACE_UNUSED VALUE _self, VALUE collector_instance) {
   struct cpu_and_wall_time_collector_state *state;
   TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
 
   return per_thread_context_st_table_as_ruby_hash(state);
 }
+
+static long update_time_since_previous_sample(long *time_at_previous_sample_ns, long current_time_ns) {
+  // If we didn't have a time for the previous sample, we use the current one
+  if (*time_at_previous_sample_ns == INVALID_TIME) *time_at_previous_sample_ns = current_time_ns;
+
+  long elapsed_time_ns = current_time_ns - *time_at_previous_sample_ns;
+  *time_at_previous_sample_ns = current_time_ns;
+
+  return elapsed_time_ns >= 0 ? elapsed_time_ns : 0 /* In case something really weird happened */;
+}
+
+static long wall_time_now_ns() {
+  struct timespec current_monotonic;
+
+  if (clock_gettime(CLOCK_MONOTONIC, &current_monotonic) != 0) rb_sys_fail("Failed to read CLOCK_MONOTONIC");
+
+  return current_monotonic.tv_nsec + (current_monotonic.tv_sec * 1000 * 1000 * 1000);
+}
+
+static long cpu_time_now_ns(struct per_thread_context *thread_context) {
+  thread_cpu_time cpu_time = thread_cpu_time_for(thread_context->thread_cpu_time_id);
+
+  if (!cpu_time.valid) {
+    // Invalidate previous state of the counter (if any), it's no longer accurate. We need to get two good reads
+    // in a row to have an accurate delta.
+    thread_context->cpu_time_at_previous_sample_ns = INVALID_TIME;
+    return 0;
+  }
+
+  return cpu_time.result_ns;
+}
+
+static long thread_id_for(VALUE thread) {
+  VALUE object_id = rb_obj_id(thread);
+
+  // The API docs for Ruby state that `rb_obj_id` COULD be a BIGNUM and that if you want to be really sure you don't
+  // get a BIGNUM, then you should use `rb_memory_id`. But `rb_memory_id` is less interesting because it's less visible
+  // at the user level than the result of calling `#object_id`.
+  //
+  // It also seems uncommon to me that we'd ever get a BIGNUM; on old Ruby versions (pre-GC compaction), the object id
+  // was the pointer to the object, so that's not going to be a BIGNUM; on modern Ruby versions, Ruby keeps
+  // a counter, and only increments it for objects for which `#object_id`/`rb_obj_id` is called (e.g. most objects
+  // won't actually have an object id allocated).
+  //
+  // So, for now, let's simplify: we only support FIXNUMs, and we won't break if we get a BIGNUM; we just won't
+  // record the thread_id (but samples will still be collected).
+  return FIXNUM_P(object_id) ? FIX2LONG(object_id) : -1;
+}
+
+VALUE enforce_cpu_and_wall_time_collector_instance(VALUE object) {
+  Check_TypedStruct(object, &cpu_and_wall_time_collector_typed_data);
+  return object;
+}

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <ruby.h>
+
+VALUE cpu_and_wall_time_collector_sample(VALUE self_instance);
+VALUE enforce_cpu_and_wall_time_collector_instance(VALUE object);