ddtrace 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eadd5e3cd8cb0144883eb120e8aee9289d06acfc2e8c5b4b6d863f524be26e7
-  data.tar.gz: 6d0005127cfe83c0332275215a850a33d13e7670ae74982286e9fe77ac7214b9
+  metadata.gz: d512b6ba74cbbe3c0b879a8efd29a513680dfd1ce9864c785887717ababf7880
+  data.tar.gz: 637d702bc35996f24d28904f20d77e4c6dece600c98eec6bbc47ba72ba7a96e2
 SHA512:
-  metadata.gz: 58e0edde95e595e435e6fad3ee078fe6bb6cf70301b6802b3b527b2804af259276752f3820901962ff94729149d60f4c81be7d3fe5c1c81b5b2119db89a9d3fa
-  data.tar.gz: baf7561a9b11f8a80fd8f36fe331c8dbdb7a7271db4cfe69f78e50b26a5946c426d0cba38b032eea964e619c3f67fcecb8b0350e72e73b7c02c53af84dbd8ecd
+  metadata.gz: bee0a447195f79d8a551f1c5076f283601c4ea14ec049f6dc077213ae578d0bdd5a0456f5b6d741a719d7543cc161b3da79970a5d696d0e2cd1e068166d9954d
+  data.tar.gz: da1801a3e6cdf5b559bca925126e68add53293b0a581666302020fdeb6dea3a27e7a4d70ead568f24a9158184f957cd25e6c3ae3b3c267b4d467ff96114e3c8a

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [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 +2382,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 +2921,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 +2933,19 @@ 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
+[#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
+[#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
+[#2201]: https://github.com/DataDog/dd-trace-rb/issues/2201
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -2996,6 +3038,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 +3071,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 +3086,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
-[@zachmccormick]: https://github.com/zachmccormick
+[@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/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,10 +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) {
+static VALUE _native_initialize(DDTRACE_UNUSED VALUE _self, VALUE collector_instance, VALUE recorder_instance, VALUE max_frames) {
   enforce_recorder_instance(recorder_instance);
 
   struct cpu_and_wall_time_collector_state *state;
@@ -153,35 +171,60 @@ static VALUE _native_initialize(VALUE self, VALUE collector_instance, VALUE reco
 
 // 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.
+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,65 @@ 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;
+}
+
+void enforce_cpu_and_wall_time_collector_instance(VALUE object) {
+  Check_TypedStruct(object, &cpu_and_wall_time_collector_typed_data);
+}

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);
+void enforce_cpu_and_wall_time_collector_instance(VALUE object);

data/ext/ddtrace_profiling_native_extension/collectors_stack.c

@@ -1,7 +1,9 @@
 #include <ruby.h>
 #include <ruby/debug.h>
 #include "extconf.h"
-#include "libddprof_helpers.h"
+#include "helpers.h"
+#include "libdatadog_helpers.h"
+#include "ruby_helpers.h"
 #include "private_vm_api_access.h"
 #include "stack_recorder.h"
 #include "collectors_stack.h"
@@ -31,8 +33,10 @@ static void record_placeholder_stack_in_native_code(VALUE recorder_instance, ddp
 void collectors_stack_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
   VALUE collectors_stack_class = rb_define_class_under(collectors_module, "Stack", rb_cObject);
+  // Hosts methods used for testing the native code using RSpec
+  VALUE testing_module = rb_define_module_under(collectors_stack_class, "Testing");
 
-  rb_define_singleton_method(collectors_stack_class, "_native_sample", _native_sample, 5);
+  rb_define_singleton_method(testing_module, "_native_sample", _native_sample, 5);
 
   missing_string = rb_str_new2("");
   rb_global_variable(&missing_string);
@@ -40,9 +44,9 @@ void collectors_stack_init(VALUE profiling_module) {
 
 // This method exists only to enable testing Datadog::Profiling::Collectors::Stack behavior using RSpec.
 // It SHOULD NOT be used for other purposes.
-static VALUE _native_sample(VALUE self, VALUE thread, VALUE recorder_instance, VALUE metric_values_hash, VALUE labels_array, VALUE max_frames) {
-  Check_Type(metric_values_hash, T_HASH);
-  Check_Type(labels_array, T_ARRAY);
+static VALUE _native_sample(DDTRACE_UNUSED VALUE _self, VALUE thread, VALUE recorder_instance, VALUE metric_values_hash, VALUE labels_array, VALUE max_frames) {
+  ENFORCE_TYPE(metric_values_hash, T_HASH);
+  ENFORCE_TYPE(labels_array, T_ARRAY);
 
   if (RHASH_SIZE(metric_values_hash) != ENABLED_VALUE_TYPES_COUNT) {
     rb_raise(
@@ -137,8 +141,8 @@ void sample_thread(VALUE thread, sampling_buffer* buffer, VALUE recorder_instanc
       // **IMPORTANT**: Be very careful when calling any `rb_profile_frame_...` API with a non-Ruby frame, as legacy
       // Rubies may assume that what's in a buffer will lead to a Ruby frame.
       //
-      // In particular for Ruby 2.2 and below the buffer contains a Ruby string (see the notes on our custom
-      // rb_profile_frames for Ruby 2.2 and below) and CALLING **ANY** OF THOSE APIs ON IT WILL CAUSE INSTANT VM CRASHES
+      // In particular for Ruby 2.2 the buffer contains a Ruby string (see the notes on our custom
+      // rb_profile_frames for Ruby 2.2) and CALLING **ANY** OF THOSE APIs ON IT WILL CAUSE INSTANT VM CRASHES
 
 #ifndef USE_LEGACY_RB_PROFILE_FRAMES // Modern Rubies
       name = ddtrace_rb_profile_frame_method_name(buffer->stack_buffer[i]);