Revert line wrapping and whitespace changes in libdatadog_api files

marcotc · marcotc · commit b7edd9689f8a · 2025-11-20T17:10:02.000-08:00
These files had extensive line wrapping/reformatting that has been reverted.
Content changes (include reordering and commented rb_raise calls) have been preserved.
diff --git a/ext/libdatadog_api/crashtracker.c b/ext/libdatadog_api/crashtracker.c
@@ -1,10 +1,9 @@
-#include <datadog/crashtracker.h>
 #include <ruby.h>
+#include <datadog/crashtracker.h>
 
 #include "datadog_ruby_common.h"
 
-static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv,
-                                             DDTRACE_UNUSED VALUE _self);
+static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self);
 
 static bool first_init = true;
@@ -13,36 +12,24 @@ static bool first_init = true;
 // Once initialized, segfaults will be reported automatically using libdatadog.
 
 void crashtracker_init(VALUE core_module) {
-  VALUE crashtracking_module =
-      rb_define_module_under(core_module, "Crashtracking");
-  VALUE crashtracker_class =
-      rb_define_class_under(crashtracking_module, "Component", rb_cObject);
-
-  rb_define_singleton_method(crashtracker_class,
-                             "_native_start_or_update_on_fork",
-                             _native_start_or_update_on_fork, -1);
-  rb_define_singleton_method(crashtracker_class, "_native_stop", _native_stop,
-                             0);
+  VALUE crashtracking_module = rb_define_module_under(core_module, "Crashtracking");
+  VALUE crashtracker_class = rb_define_class_under(crashtracking_module, "Component", rb_cObject);
+
+  rb_define_singleton_method(crashtracker_class, "_native_start_or_update_on_fork", _native_start_or_update_on_fork, -1);
+  rb_define_singleton_method(crashtracker_class, "_native_stop", _native_stop, 0);
 }
 
-static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv,
-                                             DDTRACE_UNUSED VALUE _self) {
+static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
   VALUE options;
   rb_scan_args(argc, argv, "0:", &options);
-  if (options == Qnil)
-    options = rb_hash_new();
-
-  VALUE agent_base_url =
-      rb_hash_fetch(options, ID2SYM(rb_intern("agent_base_url")));
-  VALUE path_to_crashtracking_receiver_binary = rb_hash_fetch(
-      options, ID2SYM(rb_intern("path_to_crashtracking_receiver_binary")));
-  VALUE ld_library_path =
-      rb_hash_fetch(options, ID2SYM(rb_intern("ld_library_path")));
-  VALUE tags_as_array =
-      rb_hash_fetch(options, ID2SYM(rb_intern("tags_as_array")));
+  if (options == Qnil) options = rb_hash_new();
+
+  VALUE agent_base_url = rb_hash_fetch(options, ID2SYM(rb_intern("agent_base_url")));
+  VALUE path_to_crashtracking_receiver_binary = rb_hash_fetch(options, ID2SYM(rb_intern("path_to_crashtracking_receiver_binary")));
+  VALUE ld_library_path = rb_hash_fetch(options, ID2SYM(rb_intern("ld_library_path")));
+  VALUE tags_as_array = rb_hash_fetch(options, ID2SYM(rb_intern("tags_as_array")));
   VALUE action = rb_hash_fetch(options, ID2SYM(rb_intern("action")));
-  VALUE upload_timeout_seconds =
-      rb_hash_fetch(options, ID2SYM(rb_intern("upload_timeout_seconds")));
+  VALUE upload_timeout_seconds = rb_hash_fetch(options, ID2SYM(rb_intern("upload_timeout_seconds")));
 
   VALUE start_action = ID2SYM(rb_intern("start"));
   VALUE update_on_fork_action = ID2SYM(rb_intern("update_on_fork"));
@@ -54,75 +41,64 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv,
   ENFORCE_TYPE(action, T_SYMBOL);
   ENFORCE_TYPE(upload_timeout_seconds, T_FIXNUM);
 
-  // if (action != start_action && action != update_on_fork_action)
-  //   raise_error(eNativeArgumentError, "Unexpected action: %+" PRIsVALUE,
-  //               action);
+  // if (action != start_action && action != update_on_fork_action) raise_error(eNativeArgumentError, "Unexpected action: %+"PRIsVALUE, action);
 
   VALUE version = datadog_gem_version();
 
-  // Tags and endpoint are heap-allocated, so after here we can't raise
-  // exceptions otherwise we'll leak this memory Start of exception-free zone to
-  // prevent leaks {{
-  ddog_Endpoint *endpoint =
-      ddog_endpoint_from_url(char_slice_from_ruby_string(agent_base_url));
+  // Tags and endpoint are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
+  // Start of exception-free zone to prevent leaks {{
+  ddog_Endpoint *endpoint = ddog_endpoint_from_url(char_slice_from_ruby_string(agent_base_url));
   // if (endpoint == NULL) {
-  //   raise_error(eNativeRuntimeError,
-  //               "Failed to create endpoint from agent_base_url: %" PRIsVALUE,
-  // //               agent_base_url);
+  //   raise_error(eNativeRuntimeError, "Failed to create endpoint from agent_base_url: %"PRIsVALUE, agent_base_url);
   // }
   ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
   ddog_crasht_Config config = {
-      .additional_files = {},
-      // @ivoanjo: The Ruby VM already uses an alt stack to detect stack
-      // overflows.
-      //
-      // In libdatadog < 14 with `create_alt_stack = true` I saw a segfault,
-      // such as Ruby 2.6's bug with "Process.detach(fork { exit!
-      // }).instance_variable_get(:@foo)" being turned into a
-      // "-e:1:in `instance_variable_get': stack level too deep
-      // (SystemStackError)" by Ruby. The Ruby crash handler also seems to get
-      // confused when this option is enabled and "Process.kill('SEGV',
-      // Process.pid)" gets run.
-      //
-      // This actually changed in libdatadog 14, so I could see no issues with
-      // `create_alt_stack = true`, but not overriding what Ruby set up seems a
-      // saner default to keep anyway.
-      .create_alt_stack = false,
-      .use_alt_stack = true,
-      .endpoint = endpoint,
-      .resolve_frames =
-          DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
-      .timeout_ms = FIX2INT(upload_timeout_seconds) * 1000,
+    .additional_files = {},
+    // @ivoanjo: The Ruby VM already uses an alt stack to detect stack overflows.
+    //
+    // In libdatadog < 14 with `create_alt_stack = true` I saw a segfault, such as Ruby 2.6's bug with
+    // "Process.detach(fork { exit! }).instance_variable_get(:@foo)" being turned into a
+    // "-e:1:in `instance_variable_get': stack level too deep (SystemStackError)" by Ruby.
+    // The Ruby crash handler also seems to get confused when this option is enabled and
+    // "Process.kill('SEGV', Process.pid)" gets run.
+    //
+    // This actually changed in libdatadog 14, so I could see no issues with `create_alt_stack = true`, but not
+    // overriding what Ruby set up seems a saner default to keep anyway.
+    .create_alt_stack = false,
+    .use_alt_stack = true,
+    .endpoint = endpoint,
+    .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
+    .timeout_ms = FIX2INT(upload_timeout_seconds) * 1000,
   };
 
   ddog_crasht_Metadata metadata = {
-      .library_name = DDOG_CHARSLICE_C("dd-trace-rb"),
-      .library_version = char_slice_from_ruby_string(version),
-      .family = DDOG_CHARSLICE_C("ruby"),
-      .tags = &tags,
+    .library_name = DDOG_CHARSLICE_C("dd-trace-rb"),
+    .library_version = char_slice_from_ruby_string(version),
+    .family = DDOG_CHARSLICE_C("ruby"),
+    .tags = &tags,
   };
 
   ddog_crasht_EnvVar ld_library_path_env = {
-      .key = DDOG_CHARSLICE_C("LD_LIBRARY_PATH"),
-      .val = char_slice_from_ruby_string(ld_library_path),
+    .key = DDOG_CHARSLICE_C("LD_LIBRARY_PATH"),
+    .val = char_slice_from_ruby_string(ld_library_path),
   };
 
   ddog_crasht_ReceiverConfig receiver_config = {
-      .args = {},
-      .env = {.ptr = &ld_library_path_env, .len = 1},
-      .path_to_receiver_binary =
-          char_slice_from_ruby_string(path_to_crashtracking_receiver_binary),
-      .optional_stderr_filename = {},
-      .optional_stdout_filename = {},
+    .args = {},
+    .env = {.ptr = &ld_library_path_env, .len = 1},
+    .path_to_receiver_binary = char_slice_from_ruby_string(path_to_crashtracking_receiver_binary),
+    .optional_stderr_filename = {},
+    .optional_stdout_filename = {},
   };
 
   ddog_VoidResult result =
-      action == start_action
-          ? (first_init
-                 ? ddog_crasht_init(config, receiver_config, metadata)
-                 : ddog_crasht_reconfigure(config, receiver_config, metadata))
-          : ddog_crasht_update_on_fork(config, receiver_config, metadata);
+    action == start_action ?
+      (first_init ?
+        ddog_crasht_init(config, receiver_config, metadata) :
+        ddog_crasht_reconfigure(config, receiver_config, metadata)
+      ) :
+      ddog_crasht_update_on_fork(config, receiver_config, metadata);
 
   first_init = false;
 
@@ -132,9 +108,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv,
   // }} End of exception-free zone to prevent leaks
 
   if (result.tag == DDOG_VOID_RESULT_ERR) {
-    // raise_error(eNativeRuntimeError,
-    //             "Failed to start/update the crash tracker: %" PRIsVALUE,
-    //             get_error_details_and_drop(&result.err));
+    // raise_error(eNativeRuntimeError, "Failed to start/update the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 
   return Qtrue;
@@ -144,9 +118,7 @@ static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
   ddog_VoidResult result = ddog_crasht_disable();
 
   if (result.tag == DDOG_VOID_RESULT_ERR) {
-    // raise_error(eNativeRuntimeError,
-    //             "Failed to stop the crash tracker: %" PRIsVALUE,
-    //             get_error_details_and_drop(&result.err));
+    // raise_error(eNativeRuntimeError, "Failed to stop the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 
   return Qtrue;
diff --git a/ext/libdatadog_api/ddsketch.c b/ext/libdatadog_api/ddsketch.c
@@ -1,5 +1,5 @@
-#include <datadog/ddsketch.h>
 #include <ruby.h>
+#include <datadog/ddsketch.h>
 
 #include "datadog_ruby_common.h"
 
@@ -9,12 +9,10 @@ static VALUE native_add(VALUE self, VALUE point);
 static VALUE native_add_with_count(VALUE self, VALUE point, VALUE count);
 static VALUE native_count(VALUE self);
 static VALUE native_encode(VALUE self);
-NORETURN(static void raise_ddsketch_error(const char *message,
-                                          ddog_VoidResult result));
+NORETURN(static void raise_ddsketch_error(const char *message, ddog_VoidResult result));
 
 void ddsketch_init(VALUE core_module) {
-  VALUE ddsketch_class =
-      rb_define_class_under(core_module, "DDSketch", rb_cObject);
+  VALUE ddsketch_class = rb_define_class_under(core_module, "DDSketch", rb_cObject);
 
   rb_define_alloc_func(ddsketch_class, _native_new);
   rb_define_method(ddsketch_class, "add", native_add, 1);
@@ -23,100 +21,85 @@ void ddsketch_init(VALUE core_module) {
   rb_define_method(ddsketch_class, "encode", native_encode, 0);
 }
 
-// This structure is used to define a Ruby object that stores a pointer to a
-// ddsketch_Handle_DDSketch See also
-// https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this
-// works
+// This structure is used to define a Ruby object that stores a pointer to a ddsketch_Handle_DDSketch
+// See also https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this works
 static const rb_data_type_t ddsketch_typed_data = {
-    .wrap_struct_name = "Datadog::DDSketch",
-    .function =
-        {
-            .dmark = NULL, // We don't store references to Ruby objects so we
-                           // don't need to mark any of them
-            .dfree = ddsketch_free,
-            .dsize = NULL, // We don't track memory usage (although it'd be cool
-                           // if we did!)
-            //.dcompact = NULL, // Not needed -- we don't store references to
-            // Ruby objects
-        },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+  .wrap_struct_name = "Datadog::DDSketch",
+  .function = {
+    .dmark = NULL, // We don't store references to Ruby objects so we don't need to mark any of them
+    .dfree = ddsketch_free,
+    .dsize = NULL, // We don't track memory usage (although it'd be cool if we did!)
+    //.dcompact = NULL, // Not needed -- we don't store references to Ruby objects
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
 
 static VALUE _native_new(VALUE klass) {
-  ddsketch_Handle_DDSketch *state =
-      ruby_xcalloc(1, sizeof(ddsketch_Handle_DDSketch));
+  ddsketch_Handle_DDSketch *state = ruby_xcalloc(1, sizeof(ddsketch_Handle_DDSketch));
 
   *state = ddog_ddsketch_new();
 
   return TypedData_Wrap_Struct(klass, &ddsketch_typed_data, state);
 }
 
 static void ddsketch_free(void *ptr) {
-  ddsketch_Handle_DDSketch *state = (ddsketch_Handle_DDSketch *)ptr;
+  ddsketch_Handle_DDSketch *state = (ddsketch_Handle_DDSketch *) ptr;
   ddog_ddsketch_drop(state);
   ruby_xfree(ptr);
 }
 
 static void raise_ddsketch_error(const char *message, ddog_VoidResult result) {
-  // raise_error(eNativeRuntimeError, "%s: %" PRIsVALUE, message,
-  //             get_error_details_and_drop(&result.err));
+  // raise_error(eNativeRuntimeError, "%s: %"PRIsVALUE, message, get_error_details_and_drop(&result.err));
 }
 
 static VALUE native_add(VALUE self, VALUE point) {
   ddsketch_Handle_DDSketch *state;
-  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data,
-                       state);
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
 
   ddog_VoidResult result = ddog_ddsketch_add(state, NUM2DBL(point));
 
-  if (result.tag == DDOG_VOID_RESULT_ERR)
-    raise_ddsketch_error("DDSketch add failed", result);
+  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch add failed", result);
 
   return self;
 }
 
 static VALUE native_add_with_count(VALUE self, VALUE point, VALUE count) {
   ddsketch_Handle_DDSketch *state;
-  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data,
-                       state);
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
 
-  ddog_VoidResult result =
-      ddog_ddsketch_add_with_count(state, NUM2DBL(point), NUM2DBL(count));
+  ddog_VoidResult result = ddog_ddsketch_add_with_count(state, NUM2DBL(point), NUM2DBL(count));
 
-  if (result.tag == DDOG_VOID_RESULT_ERR)
-    raise_ddsketch_error("DDSketch add_with_count failed", result);
+  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch add_with_count failed", result);
 
   return self;
 }
 
 static VALUE native_count(VALUE self) {
   ddsketch_Handle_DDSketch *state;
-  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data,
-                       state);
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
 
   double count_out;
   ddog_VoidResult result = ddog_ddsketch_count(state, &count_out);
 
-  if (result.tag == DDOG_VOID_RESULT_ERR)
-    raise_ddsketch_error("DDSketch count failed", result);
+  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch count failed", result);
 
   return DBL2NUM(count_out);
 }
 
 static VALUE native_encode(VALUE self) {
   ddsketch_Handle_DDSketch *state;
-  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data,
-                       state);
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
 
   ddog_Vec_U8 encoded = ddog_ddsketch_encode(state);
 
   // Copy into a Ruby string
-  VALUE bytes = rb_str_new((const char *)encoded.ptr, encoded.len);
+  VALUE bytes = rb_str_new((const char *) encoded.ptr, encoded.len);
 
   ddog_Vec_U8_drop(encoded);
 
   // The sketch is consumed by encode; to make this a bit more user-friendly for
-  // a Ruby API (since we can't "kill" the Ruby object), let's re-initialize it
-  // so it can be used again.
+  // a Ruby API (since we can't "kill" the Ruby object), let's re-initialize it so
+  // it can be used again.
   *state = ddog_ddsketch_new();
 
   return bytes;
