contrast-agent 5.3.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfca6df4def9f2366f7a92651aa9cd2fc40f3ced6784228844d8025cee5a4850
-  data.tar.gz: b66b10e1d892adee985f070963e08945fd9dd4faf641f4f06a8372683129facd
+  metadata.gz: 47aa135a205e4a74d64b778ae543f892213ca70e47be654032147a8bfe16dc82
+  data.tar.gz: 60f0de0e2675578bfb735c4f90303748bdc5e2053f2722dac4907bf84364d2f9
 SHA512:
-  metadata.gz: '08a6989482a82249d3fb906b2f79788e03d5c5ffa03973beabe591292fa780cd2bd3a6f459e8b7eedf58181a729720da0e95b1afa069e8869511b6ff4338625d'
-  data.tar.gz: b460cad0b10b3355bfafa3be8c49ba41d0174e5a5d0524bbab273cf51c3d9fed6348027b9658dd3dadddcace9012f0ce119566f46899ee71f8712aebf56a98bf
+  metadata.gz: fdd2d1209de7366f810cb1d7355700a54cd7d7749d94736213cf96c47b8e5cedad449ec0dc2ab09753c0ecc3d064498d18d1d001edc5d998c6c615c4cd05b571
+  data.tar.gz: 888016b33c67e7f2f77f320affcd1e945a7cc6e1c01c87d559d231cbed3309bbd4fff74833a5296f21680492955977d042594a39d807d4cb91eecd6adc4b4636

data/ext/cs__assess_array/cs__assess_array.c

@@ -22,7 +22,9 @@ static VALUE contrast_assess_array_join(const int argc, const VALUE *argv,
     }
     /* Finally, default to empty String. Implicit since nil.to_s is ''*/
 
+    /* call the Array.join but patched one */
     result = rb_funcall2(ary, rb_sym_assess_array_join, argc, argv);
+    /* call the Contrast::Extensions::Assess::ArrayPropagator#cs__track_join */
     result = rb_funcall(array_propagator, rb_sym_assess_track_array_join, 3,
                         ary, sep, result);
 
@@ -33,6 +35,11 @@ void Init_cs__assess_array(void) {
     array_propagator =
         rb_define_class_under(core_assess, "ArrayPropagator", rb_cObject);
     rb_sym_assess_track_array_join = rb_intern("cs__track_join");
+    /*
+     * Here we need to check before using the alias or prepend spec
+     * This patch is happening here, we register the cs__track_join
+     * method of the Array propagator, and call it here from Ruby.
+     */
     rb_sym_assess_array_join =
         contrast_register_patch("Array", "join", contrast_assess_array_join);
 }

data/ext/cs__assess_basic_object/cs__assess_basic_object.c

@@ -3,8 +3,20 @@
 
 #include "cs__assess_basic_object.h"
 #include "../cs__common/cs__common.h"
+#include "../cs__scope/cs__scope.h"
 #include <ruby.h>
 
+/*
+ * Source code of instance_eval:
+ *
+ *                static VALUE
+ *  rb_obj_instance_eval_internal(int argc, const VALUE *argv, VALUE self)
+ *  {
+ *      VALUE klass = singleton_class_for_eval(self);
+ *      return specific_eval(argc, argv, klass, self, RB_PASS_CALLED_KEYWORDS);
+ *  }
+ */
+
 void contrast_assess_instance_eval_trigger_check(VALUE self, VALUE source,
                                                  VALUE ret) {
     rb_funcall(basic_eval_trigger, instance_trigger_check_method, 3, self,
@@ -19,19 +31,21 @@ contrast_assess_basic_object_instance_eval(const int argc, const VALUE *argv,
         return rb_obj_instance_eval(argc, argv, self);
     }
 
-    int nested_scope =
-        RTEST(rb_funcall(contrast_patcher(), rb_sym_in_scope, 0));
+    VALUE nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
 
-    rb_funcall(contrast_patcher(), rb_sym_enter_scope, 0);
+    /* Enter scope */
+    inst_methods_enter_cntr_scope(contrast_patcher(), 0);
 
+    /* Call the source: */
     VALUE ret = rb_obj_instance_eval(argc, argv, self);
 
-    if (!nested_scope && argc > 0) {
+    if (nested_scope == Qfalse && argc > 0) {
         VALUE data = argv[0];
         contrast_assess_instance_eval_trigger_check(self, data, ret);
     }
 
-    rb_funcall(contrast_patcher(), rb_sym_exit_scope, 0);
+    /* Exit scope */
+    inst_methods_exit_cntr_scope(contrast_patcher(), 0);
 
     return ret;
 }

data/ext/cs__assess_fiber_track/cs__assess_fiber_track.c

@@ -30,7 +30,7 @@ VALUE rb_fiber_new_hook(VALUE (*func)(ANYARGS), VALUE obj) {
             ID meth;
         };
 
-        /* underlying object is first entry in Enumerator struct def.
+        /*  underlying object is first entry in Enumerator struct def.
          *  that's all statically defined w/in enumerator.c, so we can't
          *  reference the data types and be safe about it.  (yippee.)
          *  we cut out the TypedData_Get_Struct middleman & just go for it.

data/ext/cs__assess_hash/cs__assess_hash.c

@@ -17,7 +17,6 @@ static VALUE contrast_assess_hash_bracket_constructor(const int argc,
                                                       const VALUE hash) {
     VALUE result;
 
-
     /* Array of Arrays: Hash[ [ [key, value], ... ] ]   -> new_hash */
     if (RB_TYPE_P(argv[0], T_ARRAY)) {
         int i;
@@ -34,13 +33,13 @@ static VALUE contrast_assess_hash_bracket_constructor(const int argc,
         }
     }
 
-    const VALUE * argv_final = argv;
+    const VALUE *argv_final = argv;
     /* unhandled case - shouldn't need it since issue is only unfrozen
      * String keys
      * # Hash[ object ]                  -> new_hash
      */
-    result =
-        rb_funcall2(hash, rb_sym_assess_hash_bracket_constructor, argc, argv_final);
+    result = rb_funcall2(hash, rb_sym_assess_hash_bracket_constructor, argc,
+                         argv_final);
 
     return result;
 }

data/ext/cs__assess_kernel/cs__assess_kernel.c

@@ -9,8 +9,7 @@
 VALUE
 contrast_patched_kernel_exec(const int argc, const VALUE *argv,
                              const VALUE self) {
-    int nested_scope =
-        inst_methods_in_cntr_scope(contrast_patcher(), 0);
+    VALUE nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
 
     if (nested_scope == Qfalse && argc > 0) {
         /* enter scope */

data/ext/cs__assess_marshal_module/cs__assess_marshal_module.c

@@ -5,36 +5,50 @@
 #include "../cs__common/cs__common.h"
 #include <ruby.h>
 
-static VALUE contrast_marshal_module_load(const int argc,
-                                                 const VALUE *argv) {
+/*
+ * Marshal#load source:
+ * static VALUE
+ * marshal_load(int argc, VALUE *argv)
+ *  {
+ *     VALUE port, proc;
+ *
+ *     rb_check_arity(argc, 1, 2);
+ *     port = argv[0];
+ *     proc = argc > 1 ? argv[1] : Qnil;
+ *     return rb_marshal_load_with_proc(port, proc);
+ * }
+ */
+static VALUE contrast_marshal_module_load(const int argc, const VALUE *argv) {
     VALUE result;
     VALUE source_string;
 
-    // Our patches only need only apply in the case where there was valid input.
+    /* Our patches need to apply only in the case where there was valid input.
+     */
     if (argc >= 1) {
         source_string = argv[0];
     } else {
         source_string = Qnil;
     }
 
-    // Run our protect code ahead of the original method
+    /* Run our protect code ahead of the original method */
     if (source_string != Qnil) {
-        rb_funcall(marshal_propagator, rb_sym_protect_marshal_load, 1, source_string);
+        rb_funcall(marshal_propagator, rb_sym_protect_marshal_load, 1,
+                   source_string);
     }
 
-    // Invoke the original method
+    /* Invoke the original method */
     result = rb_call_super(argc, argv);
 
-    // Run our assess code after the original method
+    /* Run our assess code after the original method */
     if (source_string != Qnil) {
         VALUE tracked =
             rb_funcall(properties_hash, rb_sym_hash_tracked, 1, source_string);
 
-        // Assuming the source is tracked and needs assess checks
+        /* Assuming the source is tracked and needs assess checks */
         if (tracked == Qtrue) {
             VALUE skip =
                 rb_funcall(contrast_patcher(), rb_sym_skip_assess_analysis, 0);
-            // And Assess is enabled and applies to this request
+            /* And Assess is enabled and applies to this request */
             if (skip == Qfalse) {
                 rb_funcall(marshal_propagator, rb_sym_assess_marshal_load, 2,
                            source_string, result);
@@ -45,7 +59,7 @@ static VALUE contrast_marshal_module_load(const int argc,
 }
 
 void Init_cs__assess_marshal_module(void) {
-    // Contrast::Agent::Assess::Tracker::PROPERTIES_HASH
+    /* Contrast::Agent::Assess::Tracker::PROPERTIES_HASH */
     VALUE tracker = rb_define_class_under(assess, "Tracker", rb_cObject);
     properties_hash = rb_const_get(tracker, rb_intern("PROPERTIES_HASH"));
     marshal_propagator =
@@ -53,6 +67,6 @@ void Init_cs__assess_marshal_module(void) {
     rb_sym_assess_marshal_load = rb_intern("cs__load_assess");
     rb_sym_protect_marshal_load = rb_intern("cs__load_protect");
 
-    contrast_register_singleton_prepend_patch(
-        "Marshal", "load", &contrast_marshal_module_load);
+    contrast_register_singleton_prepend_patch("Marshal", "load",
+                                              &contrast_marshal_module_load);
 }

data/ext/cs__assess_module/cs__assess_module.c

@@ -13,7 +13,7 @@ void contrast_assess_eval_trigger_check(VALUE module, VALUE source, VALUE ret) {
     }
 
     int nested_scope = inst_methods_in_cntr_scope(contrast_patcher(), 0);
-     /* enter scope */
+    /* enter scope */
     inst_methods_enter_cntr_scope(contrast_patcher(), 0);
 
     if (nested_scope == Qfalse) {

data/ext/cs__assess_string/cs__assess_string.c

@@ -5,6 +5,18 @@
 #include "../cs__common/cs__common.h"
 #include <ruby.h>
 
+/*
+ * The -@ method source:
+ *
+ *                static VALUE
+ * str_uminus(VALUE str)
+ * {
+ *     if (!BARE_STRING_P(str) && !rb_obj_frozen_p(str)) {
+ *         str = rb_str_dup(str);
+ *     }
+ *     return rb_fstring(str);
+ * }
+ */
 static VALUE contrast_assess_string_freeze(const int argc, VALUE *argv,
                                            const VALUE obj) {
     if (!OBJ_FROZEN(obj)) {
@@ -39,7 +51,7 @@ void Init_cs__assess_string(void) {
     rb_sym_dup = rb_intern("dup");
     rb_sym_freeze = rb_intern("freeze");
     rb_sym_pre_freeze = rb_intern("pre_freeze");
-    // Contrast::Agent::Assess::Tracker::PROPERTIES_HASH
+    /* Contrast::Agent::Assess::Tracker::PROPERTIES_HASH */
     VALUE tracker = rb_define_class_under(assess, "Tracker", rb_cObject);
     properties_hash = rb_const_get(tracker, rb_intern("PROPERTIES_HASH"));
 

data/ext/cs__common/cs__common.c

@@ -60,8 +60,7 @@ VALUE contrast_patcher() {
 }
 
 VALUE contrast_register_patch(const char *module_name, const char *method_name,
-                              VALUE(c_fn)(const int, VALUE *,
-                                          const VALUE)) {
+                              VALUE(c_fn)(const int, VALUE *, const VALUE)) {
     return _contrast_register_patch(module_name, method_name, c_fn,
                                     IMPL_ALIAS_INSTANCE);
 }
@@ -75,17 +74,17 @@ VALUE contrast_register_singleton_patch(const char *module_name,
 }
 
 VALUE contrast_register_prepend_patch(const char *module_name,
-                              const char *method_name,
-                              VALUE(c_fn)(const int, VALUE *,
-                                          const VALUE)) {
+                                      const char *method_name,
+                                      VALUE(c_fn)(const int, VALUE *,
+                                                  const VALUE)) {
     return _contrast_register_patch(module_name, method_name, c_fn,
                                     IMPL_PREPEND_INSTANCE);
 }
 
 VALUE contrast_register_singleton_prepend_patch(const char *module_name,
-                              const char *method_name,
-                              VALUE(c_fn)(const int, VALUE *,
-                                          const VALUE)) {
+                                                const char *method_name,
+                                                VALUE(c_fn)(const int, VALUE *,
+                                                            const VALUE)) {
     return _contrast_register_patch(module_name, method_name, c_fn,
                                     IMPL_PREPEND_SINGLETON);
 }
@@ -135,7 +134,7 @@ _contrast_register_patch(const char *module_name, const char *method_name,
     case IMPL_PREPEND_INSTANCE:
         impl = ID2SYM(rb_sym_prepend_instance);
     case IMPL_PREPEND_SINGLETON:
-         impl = ID2SYM(rb_sym_prepend_singleton);
+        impl = ID2SYM(rb_sym_prepend_singleton);
         break;
     }
 
@@ -146,8 +145,10 @@ _contrast_register_patch(const char *module_name, const char *method_name,
 }
 
 int rb_ver_below_three() {
-  int ruby_version = FIX2INT(rb_funcall(rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")), rb_intern("to_i"), 0));
-  return ruby_version < 3;
+    int ruby_version =
+        FIX2INT(rb_funcall(rb_const_get(rb_cObject, rb_intern("RUBY_VERSION")),
+                           rb_intern("to_i"), 0));
+    return ruby_version < 3;
 }
 
 void Init_cs__common(void) {

data/ext/cs__contrast_patch/cs__contrast_patch.c

@@ -35,25 +35,29 @@ VALUE contrast_patch_call_original(const VALUE *args) {
     method = args[3];
     method_id = SYM2ID(method);
 
-    /* It looks like we can find the last Ruby block given so long as we don't
-     * change Ruby method scope (always call this function from C, not Ruby),
-     * which is the point of this C call.
-     */
-    /* Ruby >= 2.7 */
-    #ifdef RB_PASS_CALLED_KEYWORDS
-        if (rb_block_given_p()) {
-            return rb_funcall_with_block_kw(object, method_id, argc, params, rb_block_proc(), RB_PASS_CALLED_KEYWORDS);
-        } else {
-            return rb_funcallv_kw(object, method_id, argc, params, RB_PASS_CALLED_KEYWORDS);
-        }
-    /* Ruby < 2.7 */
-    #else
-        if (rb_block_given_p()) {
-            return rb_funcall_with_block(object, method_id, argc, params, rb_block_proc());
-        } else {
-            return rb_funcall2(object, method_id, argc, params);
-        }
-    #endif
+/* It looks like we can find the last Ruby block given so long as we don't
+ * change Ruby method scope (always call this function from C, not Ruby),
+ * which is the point of this C call.
+ */
+/* Ruby >= 2.7 */
+#ifdef RB_PASS_CALLED_KEYWORDS
+    if (rb_block_given_p()) {
+        return rb_funcall_with_block_kw(object, method_id, argc, params,
+                                        rb_block_proc(),
+                                        RB_PASS_CALLED_KEYWORDS);
+    } else {
+        return rb_funcallv_kw(object, method_id, argc, params,
+                              RB_PASS_CALLED_KEYWORDS);
+    }
+/* Ruby < 2.7 */
+#else
+    if (rb_block_given_p()) {
+        return rb_funcall_with_block(object, method_id, argc, params,
+                                     rb_block_proc());
+    } else {
+        return rb_funcall2(object, method_id, argc, params);
+    }
+#endif
 }
 
 VALUE contrast_call_pre_patch(const VALUE method_policy, const VALUE method,
@@ -94,7 +98,7 @@ VALUE rescue_func(VALUE arg1) {
     exception = rb_errinfo();
     rb_exc_raise(exception);
 
-	return Qnil;
+    return Qnil;
 }
 
 VALUE contrast_patch_call_ensure(const VALUE *args) {
@@ -121,7 +125,8 @@ VALUE ensure_wrapper(const VALUE *args) {
     original_args = (VALUE)args[1];
     ensure_args = (VALUE)args[2];
 
-	return rb_ensure(original_method, original_args, contrast_patch_call_ensure, (VALUE)ensure_args);
+    return rb_ensure(original_method, original_args, contrast_patch_call_ensure,
+                     (VALUE)ensure_args);
 }
 
 VALUE contrast_call_super(const VALUE *args) {
@@ -134,7 +139,8 @@ VALUE contrast_call_super(const VALUE *args) {
 }
 
 VALUE contrast_run_patches(const VALUE *wrapped_args) {
-    VALUE impl, method, method_policy, object, original_args, original_ret, preshift, transformed_ret;
+    VALUE impl, method, method_policy, object, original_args, original_ret,
+        preshift, transformed_ret;
     int argc;
     VALUE *argv;
     VALUE ensure_args[6];
@@ -198,12 +204,14 @@ VALUE contrast_run_patches(const VALUE *wrapped_args) {
     switch (impl) {
     case IMPL_ALIAS_INSTANCE:
     case IMPL_ALIAS_SINGLETON:
-        original_ret = rb_rescue(ensure_wrapper, rescue_wrapper_args, rescue_func, Qnil);
+        original_ret =
+            rb_rescue(ensure_wrapper, rescue_wrapper_args, rescue_func, Qnil);
         break;
     case IMPL_PREPEND_INSTANCE:
     case IMPL_PREPEND_SINGLETON:
         rescue_wrapper_args[0] = contrast_call_super;
-        original_ret = rb_rescue(ensure_wrapper, rescue_wrapper_args, rescue_func, Qnil);
+        original_ret =
+            rb_rescue(ensure_wrapper, rescue_wrapper_args, rescue_func, Qnil);
         break;
     };
 
@@ -272,9 +280,9 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
             rb_funcall(patch_status, rb_sym_info_for, 3, object, method, Qtrue);
         break;
     case IMPL_PREPEND_SINGLETON:
-       known =
-           rb_funcall(patch_status, rb_sym_info_for, 3, object, method, Qfalse);
-       break;
+        known = rb_funcall(patch_status, rb_sym_info_for, 3, object, method,
+                           Qfalse);
+        break;
     case IMPL_ALIAS_SINGLETON:
         known = rb_funcall(patch_status, rb_sym_info_for, 3, object, method,
                            Qfalse);
@@ -337,14 +345,14 @@ VALUE contrast_patch_dispatch(const int argc, const VALUE *argv,
     wrapped_args[5] = INT2NUM(argc);
     wrapped_args[6] = (VALUE)argv;
 
-    return rb_ensure(contrast_run_patches, (VALUE)wrapped_args, contrast_ensure_function, method_policy);
+    return rb_ensure(contrast_run_patches, (VALUE)wrapped_args,
+                     contrast_ensure_function, method_policy);
 
 call_original:
 
     /* exit scope */
     contrast_ensure_function(method_policy);
 
-
     switch (impl) {
     case IMPL_ALIAS_INSTANCE:
     case IMPL_ALIAS_SINGLETON:
@@ -366,19 +374,22 @@ VALUE contrast_alias_singleton_patch(const int argc, const VALUE *argv,
 }
 
 VALUE contrast_prepend_instance_patch(const int argc, const VALUE *argv,
-                             const VALUE object) {
+                                      const VALUE object) {
     return contrast_patch_dispatch(argc, argv, IMPL_PREPEND_INSTANCE, object);
 }
 
 VALUE contrast_prepend_singleton_patch(const int argc, const VALUE *argv,
-                             const VALUE object) {
+                                       const VALUE object) {
     return contrast_patch_dispatch(argc, argv, IMPL_PREPEND_SINGLETON, object);
 }
 
-VALUE contrast_patch_define_method(const VALUE self, const VALUE clazz, const VALUE method_policy,
+VALUE contrast_patch_define_method(const VALUE self, const VALUE clazz,
+                                   const VALUE method_policy,
                                    const VALUE cs_method) {
-    const VALUE original_method_name = rb_funcall(method_policy, rb_sym_method_name, 0);
-    const VALUE is_instance_method = rb_funcall(method_policy, rb_sym_instance_method, 0);
+    const VALUE original_method_name =
+        rb_funcall(method_policy, rb_sym_method_name, 0);
+    const VALUE is_instance_method =
+        rb_funcall(method_policy, rb_sym_instance_method, 0);
     char *cStr;
     VALUE str;
     rb_funcall(patch_status, rb_sym_set_info_for, 5, clazz,
@@ -444,8 +455,8 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
     const VALUE is_instance_method =
         rb_funcall(method_policy, rb_sym_instance_method, 0);
 
-// Set the value for instance or singleton method
-    if (RTEST(is_instance_method)){
+    // Set the value for instance or singleton method
+    if (RTEST(is_instance_method)) {
         rb_funcall(patch_status, rb_sym_set_info_for, 5, originalModule,
                    original_method_name, method_policy, instance, Qnil);
 
@@ -462,17 +473,19 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
             rb_define_private_method(module, cMethodName,
                                      contrast_prepend_instance_patch, -1);
         } else {
-            rb_define_method(module, cMethodName, contrast_prepend_instance_patch, -1);
+            rb_define_method(module, cMethodName,
+                             contrast_prepend_instance_patch, -1);
         }
     } else {
-        rb_define_singleton_method(module, cMethodName, contrast_prepend_singleton_patch,
-                                   -1);
+        rb_define_singleton_method(module, cMethodName,
+                                   contrast_prepend_singleton_patch, -1);
     }
     rb_prepend_module(originalModule, module);
 
     if (rb_ver_below_three()) {
         VALUE module_at;
-        VALUE rb_incl_in_mod_ary = rb_funcall(originalModule, rb_intern("included_in"), 0);
+        VALUE rb_incl_in_mod_ary =
+            rb_funcall(originalModule, rb_intern("included_in"), 0);
         if (RB_TYPE_P(rb_incl_in_mod_ary, T_ARRAY)) {
             int i = 0;
             int size = rb_funcall(rb_incl_in_mod_ary, rb_intern("length"), 0);
@@ -483,7 +496,7 @@ VALUE contrast_patch_prepend(const VALUE self, const VALUE originalModule,
                 }
             }
         }
-   }
+    }
     return Qtrue;
 }
 
@@ -512,7 +525,6 @@ void Init_cs__contrast_patch(void) {
     rb_sym_scopes_to_enter = rb_intern("scopes_to_enter");
     rb_sym_scopes_to_exit = rb_intern("scopes_to_exit");
 
-
     rb_define_module_function(contrast_patcher(), "contrast_define_method",
                               contrast_patch_define_method, 3);
 
@@ -524,5 +536,4 @@ void Init_cs__contrast_patch(void) {
 
     /* preshift_class = Contrast::Agent::Assess::PreShift */
     preshift_class = rb_define_class_under(assess, "PreShift", rb_cObject);
-
 }

data/ext/cs__os_information/cs__os_information.c

@@ -8,24 +8,27 @@
 
 VALUE contrast, utils, os;
 
-VALUE contrast_get_system_information()
-{
+VALUE contrast_get_system_information() {
     struct utsname uname_pointer;
 
-    uname (&uname_pointer);
+    uname(&uname_pointer);
 
     VALUE rb_data_hash = rb_hash_new();
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_type"), rb_str_new2(uname_pointer.sysname));
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_version"), rb_str_new2(uname_pointer.release));
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_complete_version"), rb_str_new2(uname_pointer.version));
-    rb_hash_aset(rb_data_hash, rb_str_new2("os_arch"), rb_str_new2(uname_pointer.machine));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_type"),
+                 rb_str_new2(uname_pointer.sysname));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_version"),
+                 rb_str_new2(uname_pointer.release));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_complete_version"),
+                 rb_str_new2(uname_pointer.version));
+    rb_hash_aset(rb_data_hash, rb_str_new2("os_arch"),
+                 rb_str_new2(uname_pointer.machine));
     return rb_data_hash;
 }
 
-void Init_cs__os_information(void)
-{
+void Init_cs__os_information(void) {
     contrast = rb_define_module("Contrast");
     utils = rb_define_module_under(contrast, "Utils");
     os = rb_define_module_under(utils, "OS");
-    rb_define_module_function(os, "get_system_information", contrast_get_system_information, 0);
+    rb_define_module_function(os, "get_system_information",
+                              contrast_get_system_information, 0);
 }