cmetrics 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 361bb2d812b12da260716172fe76c863c219262c499eedbbeba103b0c06f96df
-  data.tar.gz: 037562a3edf92bb19db31b2642bc8907d6e99dd21cd61a812c754508f8dd21cd
+  metadata.gz: 6ab76eb9253339b05455e7424e0f440bec6a9dd612ef61224066650151755683
+  data.tar.gz: '056618e48e0bb0d6c50a325797096824d8c970b48f26d24c9f224608f48f513d'
 SHA512:
-  metadata.gz: d2ac8990af70be9e24984402b5bda5e3ac34a84075fd9051564b5e79d35e24c678c1f413f6064f9df9c5c08df2bf62c8c9d1ab1197abd84d072aaae24d99290c
-  data.tar.gz: 94dd6beaf0ef980bca11ec2b076582f14843560e8f737ee72cdda85de550d8bdf6506dde3d7a11768dac29fbcebc8a2c6a5ade527c03fe12c904a90af8b2b345
+  metadata.gz: 157c179195aa7273939807fa10ac06b2b660cd52ef459ffe733dafe11109eccc8b9c48d4f2cb384ecd250909fe4327321ab3382b83ff77e4432ca76641178059
+  data.tar.gz: 6937cbb0e2ab74b51683d3d3ad5d440b9bd571663a4cae06dd0385b7b3f74bb223c6bf3e4fb9a04e29e13ed480daa928e059323d28eecefe4cdb8af9d086ee70

data/README.md

@@ -30,13 +30,13 @@ Or install it yourself as:
 
 ## Usage
 
+### Counter
+
 `CMetrics::Counter` is a cumulative metric that can only increase monotonically and reset to zero at restart.
 This class should be used for counting the total amount of record size or something like monotonic increasing values.
 
 ref: [Metric Types -- Counter | Prometheus documentation](https://prometheus.io/docs/concepts/metric_types/#counter)
 
-### Counter
-
 ```ruby
 require 'cmetrics'
 
@@ -94,6 +94,35 @@ require 'cmetrics'
 @gauge.val(["localhost", "test"]) #=> 7.5
 ```
 
+### Untyped
+
+`CMetrics::Untyped` is a metric that can only set a value via `#set` and reset to zero at restart.
+This class should be used for storing the increasing but discontinuous values.
+
+```ruby
+require 'cmetrics'
+
+@untyped = CMetrics::Untyped.new
+@untyped.create("kubernetes", "network", "load", "Network load", ["hostname", "app"])
+
+@untyped.val #=> nil
+
+@untyped.set 3.0 #=> true
+@untyped.val #=> 3.0
+
+# Multiple labels
+@untyped.set(1.0, ["localhost", "cmetrics"]) #=> true
+@untyped.val(["localhost", "cmetrics"]) #=> 1.0
+
+@untyped.set(10.55, ["localhost", "test"]) #=> true
+@untyped.val(["localhost", "test"]) #=> 10.55
+
+#CMetrics::Untyped can set greater value than stored.
+@untyped.set(12.15, ["localhost", "test"]) #=> true
+#CMetrics::Untyped cannot set smaller value than stored.
+@untyped.set(1, ["localhost", "test"]) #=> false
+```
+
 ### Serde
 
 `CMetrics::Serde` is for a decoding (and encoding to some format stuffs) from msgpacked buffers that are created by `CMetrics::Counter#to_msgpack` or `CMetrics::Gauge#to_msgpack`.

data/ext/cmetrics/cmetrics.c

@@ -36,4 +36,5 @@ void Init_cmetrics(void)
     Init_cmetrics_counter(rb_mCMetrics);
     Init_cmetrics_gauge(rb_mCMetrics);
     Init_cmetrics_serde(rb_mCMetrics);
+    Init_cmetrics_untyped(rb_mCMetrics);
 }

data/ext/cmetrics/cmetrics_c.h

@@ -34,6 +34,7 @@
 #include <cmetrics/cmetrics.h>
 #include <cmetrics/cmt_counter.h>
 #include <cmetrics/cmt_gauge.h>
+#include <cmetrics/cmt_untyped.h>
 #include <cmetrics/cmt_encode_influx.h>
 #include <cmetrics/cmt_encode_prometheus.h>
 #include <cmetrics/cmt_encode_msgpack.h>
@@ -55,8 +56,14 @@ struct CMetricsSerde {
     size_t unpack_msgpack_offset;
 };
 
+struct CMetricsUntyped {
+    struct cmt *instance;
+    struct cmt_untyped *untyped;
+};
+
 void Init_cmetrics_counter(VALUE rb_mCMetrics);
 void Init_cmetrics_gauge(VALUE rb_mCMetrics);
 void Init_cmetrics_serde(VALUE rb_mCMetrics);
+void Init_cmetrics_untyped(VALUE rb_mCMetrics);
 
 #endif // _CMETRICS_C_H

data/ext/cmetrics/cmetrics_counter.c

@@ -40,12 +40,12 @@ counter_free(void* ptr)
     struct CMetricsCounter* cmetricsCounter = (struct CMetricsCounter*)ptr;
 
     if (!cmetricsCounter) {
-        if (!cmetricsCounter->instance) {
-            cmt_destroy(cmetricsCounter->instance);
-        }
         if (!cmetricsCounter->counter) {
             cmt_counter_destroy(cmetricsCounter->counter);
         }
+        if (!cmetricsCounter->instance) {
+            cmt_destroy(cmetricsCounter->instance);
+        }
     }
 
     xfree(ptr);

data/ext/cmetrics/cmetrics_gauge.c

@@ -40,12 +40,12 @@ gauge_free(void* ptr)
     struct CMetricsGauge* cmetricsGauge = (struct CMetricsGauge*)ptr;
 
     if (!cmetricsGauge) {
-        if (!cmetricsGauge->instance) {
-            cmt_destroy(cmetricsGauge->instance);
-        }
         if (!cmetricsGauge->gauge) {
             cmt_gauge_destroy(cmetricsGauge->gauge);
         }
+        if (!cmetricsGauge->instance) {
+            cmt_destroy(cmetricsGauge->instance);
+        }
     }
 
     xfree(ptr);

data/ext/cmetrics/cmetrics_untyped.c

@@ -0,0 +1,488 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  CMetrics-Ruby
+ *  =============
+ *  Copyright 2021 Hiroshi Hatake <hatake@calyptia.com>
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "cmetrics_c.h"
+
+VALUE rb_cUntyped;
+
+static void untyped_free(void* ptr);
+
+static const rb_data_type_t rb_cmetrics_untyped_type = { "cmetrics/untyped",
+                                                         {
+                                                             0,
+                                                             untyped_free,
+                                                             0,
+                                                         },
+                                                         NULL,
+                                                         NULL,
+                                                         RUBY_TYPED_FREE_IMMEDIATELY };
+
+
+static void
+untyped_free(void* ptr)
+{
+    struct CMetricsUntyped* cmetricsUntyped = (struct CMetricsUntyped*)ptr;
+
+    if (!cmetricsUntyped) {
+        if (!cmetricsUntyped->untyped) {
+            cmt_untyped_destroy(cmetricsUntyped->untyped);
+        }
+        if (!cmetricsUntyped->instance) {
+            cmt_destroy(cmetricsUntyped->instance);
+        }
+    }
+
+    xfree(ptr);
+}
+
+static VALUE
+rb_cmetrics_untyped_alloc(VALUE klass)
+{
+    VALUE obj;
+    struct CMetricsUntyped* cmetricsUntyped;
+    obj = TypedData_Make_Struct(
+            klass, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+    return obj;
+}
+
+/*
+ * Initailize Untyped class.
+ *
+ * @return [Untyped]
+ *
+ */
+static VALUE
+rb_cmetrics_untyped_initialize(VALUE self)
+{
+    struct CMetricsUntyped* cmetricsUntyped;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    cmt_initialize();
+
+    cmetricsUntyped->instance = cmt_create();
+    cmetricsUntyped->untyped = NULL;
+
+    return Qnil;
+}
+
+/*
+ * Create untyped.
+ *
+ */
+static VALUE
+rb_cmetrics_untyped_create(int argc, VALUE* argv, VALUE self)
+{
+    VALUE rb_namespace, rb_subsystem, rb_name, rb_help, rb_labels;
+    struct CMetricsUntyped* cmetricsUntyped;
+    char **labels = NULL;
+    int labels_count = 0;
+    VALUE tmp_label;
+    long i;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    rb_scan_args(argc, argv, "41", &rb_namespace, &rb_subsystem, &rb_name, &rb_help, &rb_labels);
+
+    Check_Type(rb_namespace, T_STRING);
+    Check_Type(rb_subsystem, T_STRING);
+    Check_Type(rb_name, T_STRING);
+    Check_Type(rb_help, T_STRING);
+
+    if (!NIL_P(rb_labels)) {
+        switch(TYPE(rb_labels)) {
+        case T_STRING:
+            labels = (char *[]) { StringValuePtr(rb_labels) };
+            labels_count = 1;
+            cmetricsUntyped->untyped = cmt_untyped_create(cmetricsUntyped->instance,
+                                                          StringValuePtr(rb_namespace),
+                                                          StringValuePtr(rb_subsystem),
+                                                          StringValuePtr(rb_name),
+                                                          StringValuePtr(rb_help),
+                                                          labels_count, labels);
+            break;
+        case T_SYMBOL:
+            labels = (char *[]) { RSTRING_PTR(rb_sym2str(rb_labels)) };
+            labels_count = 1;
+            cmetricsUntyped->untyped = cmt_untyped_create(cmetricsUntyped->instance,
+                                                          StringValuePtr(rb_namespace),
+                                                          StringValuePtr(rb_subsystem),
+                                                          StringValuePtr(rb_name),
+                                                          StringValuePtr(rb_help),
+                                                          labels_count, labels);
+            break;
+        case T_ARRAY:
+            labels_count = (int)RARRAY_LEN(rb_labels);
+            labels = ALLOCV_N(char *, tmp_label, labels_count);
+            for (i = 0; i < labels_count; i++) {
+                VALUE item = RARRAY_AREF(rb_labels, i);
+                switch(TYPE(item)) {
+                case T_SYMBOL:
+                    labels[i] = RSTRING_PTR(rb_sym2str(item));
+                    break;
+                case T_STRING:
+                    labels[i] = StringValuePtr(item);
+                    break;
+                default:
+                    rb_raise(rb_eArgError, "labels must be Symbol/String");
+                }
+            }
+            cmetricsUntyped->untyped = cmt_untyped_create(cmetricsUntyped->instance,
+                                                          StringValuePtr(rb_namespace),
+                                                          StringValuePtr(rb_subsystem),
+                                                          StringValuePtr(rb_name),
+                                                          StringValuePtr(rb_help),
+                                                          labels_count, labels);
+
+            ALLOCV_END(tmp_label);
+            break;
+        default:
+            rb_raise(rb_eArgError, "labels should be String, Symbol or Array class instance.");
+        }
+    } else {
+        cmetricsUntyped->untyped = cmt_untyped_create(cmetricsUntyped->instance,
+                                                      StringValuePtr(rb_namespace),
+                                                      StringValuePtr(rb_subsystem),
+                                                      StringValuePtr(rb_name),
+                                                      StringValuePtr(rb_help),
+                                                      labels_count, labels);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_cmetrics_untyped_get_value(int argc, VALUE* argv, VALUE self)
+{
+    VALUE rb_labels;
+    struct CMetricsUntyped* cmetricsUntyped;
+    int ret = 0;
+    double value = 0;
+    char **labels = NULL;
+    int labels_count = 0;
+    VALUE tmp_label;
+    long i;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    if (!cmetricsUntyped->untyped) {
+        rb_raise(rb_eRuntimeError, "Create untyped with CMetrics::Untyped#create first.");
+    }
+
+    rb_scan_args(argc, argv, "01", &rb_labels);
+
+    if (!NIL_P(rb_labels)) {
+        switch(TYPE(rb_labels)) {
+        case T_STRING:
+            labels = (char *[]) { StringValuePtr(rb_labels) };
+            labels_count = 1;
+
+            ret = cmt_untyped_get_val(cmetricsUntyped->untyped,
+                                      labels_count, labels, &value);
+            break;
+        case T_SYMBOL:
+            labels = (char *[]) { RSTRING_PTR(rb_sym2str(rb_labels)) };
+            labels_count = 1;
+
+            ret = cmt_untyped_get_val(cmetricsUntyped->untyped,
+                                      labels_count, labels, &value);
+            break;
+        case T_ARRAY:
+            labels_count = (int)RARRAY_LEN(rb_labels);
+            labels = ALLOCV_N(char *, tmp_label, labels_count);
+            for (i = 0; i < labels_count; i++) {
+                VALUE item = RARRAY_AREF(rb_labels, i);
+                switch(TYPE(item)) {
+                case T_SYMBOL:
+                    labels[i] = RSTRING_PTR(rb_sym2str(item));
+                    break;
+                case T_STRING:
+                    labels[i] = StringValuePtr(item);
+                    break;
+                default:
+                    rb_raise(rb_eArgError, "labels must be Symbol/String");
+                }
+            }
+
+            ret = cmt_untyped_get_val(cmetricsUntyped->untyped,
+                                      labels_count, labels, &value);
+
+            ALLOCV_END(tmp_label);
+
+            break;
+        default:
+            rb_raise(rb_eArgError, "labels should be String, Symbol or Array class instance.");
+        }
+    } else {
+        ret = cmt_untyped_get_val(cmetricsUntyped->untyped,
+                                  labels_count, labels, &value);
+    }
+
+    if (ret == 0) {
+        return DBL2NUM(value);
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * Set value into untyped.
+ *
+ * @return [Boolean]
+ *
+ */
+static VALUE
+rb_cmetrics_untyped_set(int argc, VALUE* argv, VALUE self)
+{
+    VALUE rb_labels, rb_num;
+    struct CMetricsUntyped* cmetricsUntyped;
+    uint64_t ts;
+    int ret = 0;
+    double value = 0;
+    char **labels = NULL;
+    int labels_count = 0;
+    VALUE tmp_label;
+    long i;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    if (!cmetricsUntyped->untyped) {
+        rb_raise(rb_eRuntimeError, "Create untyped with CMetrics::Untyped#create first.");
+    }
+
+    rb_scan_args(argc, argv, "11", &rb_num, &rb_labels);
+
+    switch(TYPE(rb_num)) {
+    case T_FLOAT:
+    case T_FIXNUM:
+    case T_BIGNUM:
+    case T_RATIONAL:
+        value = NUM2DBL(rb_num);
+        break;
+    default:
+        rb_raise(rb_eArgError, "CMetrics::Untyped#set can handle numerics values only.");
+    }
+
+    ts = cmt_time_now();
+    if (!NIL_P(rb_labels)) {
+        switch(TYPE(rb_labels)) {
+        case T_STRING:
+            labels = (char *[]) { StringValuePtr(rb_labels) };
+            labels_count = 1;
+            ret = cmt_untyped_set(cmetricsUntyped->untyped, ts, value,
+                                  labels_count, labels);
+            break;
+        case T_SYMBOL:
+            labels = (char *[]) { RSTRING_PTR(rb_sym2str(rb_labels)) };
+            labels_count = 1;
+            ret = cmt_untyped_set(cmetricsUntyped->untyped, ts, value,
+                                  labels_count, labels);
+            break;
+        case T_ARRAY:
+            labels_count = (int)RARRAY_LEN(rb_labels);
+            labels = ALLOCV_N(char *, tmp_label, labels_count);
+            for (i = 0; i < labels_count; i++) {
+                VALUE item = RARRAY_AREF(rb_labels, i);
+                switch(TYPE(item)) {
+                case T_SYMBOL:
+                    labels[i] = RSTRING_PTR(rb_sym2str(item));
+                    break;
+                case T_STRING:
+                    labels[i] = StringValuePtr(item);
+                    break;
+                default:
+                    rb_raise(rb_eArgError, "labels must be Symbol/String");
+                }
+            }
+
+            ret = cmt_untyped_set(cmetricsUntyped->untyped, ts, value,
+                                  labels_count, labels);
+
+            ALLOCV_END(tmp_label);
+
+            break;
+        default:
+            rb_raise(rb_eArgError, "labels should be String, Symbol or Array class instance.");
+        }
+    } else {
+        ret = cmt_untyped_set(cmetricsUntyped->untyped, ts, value,
+                              labels_count, labels);
+    }
+
+    if (ret == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/*
+ * Set label into untyped.
+ *
+ * @return [Boolean]
+ */
+
+static VALUE
+rb_cmetrics_untyped_add_label(VALUE self, VALUE rb_key, VALUE rb_value)
+{
+    struct CMetricsUntyped* cmetricsUntyped;
+    char *key, *value;
+    int ret = 0;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    if (!cmetricsUntyped->untyped) {
+        rb_raise(rb_eRuntimeError, "Create untyped with CMetrics::Untyped#create first.");
+    }
+
+    switch(TYPE(rb_key)) {
+    case T_STRING:
+        key = StringValuePtr(rb_key);
+        break;
+    case T_SYMBOL:
+        key = RSTRING_PTR(rb_sym2str(rb_key));
+        break;
+    default:
+        rb_raise(rb_eArgError, "key should be String or Symbol class instance.");
+    }
+
+    switch(TYPE(rb_value)) {
+    case T_STRING:
+        value = StringValuePtr(rb_value);
+        break;
+    case T_SYMBOL:
+        value = RSTRING_PTR(rb_sym2str(rb_value));
+        break;
+    default:
+        rb_raise(rb_eArgError, "value should be String or Symbol class instance.");
+    }
+    ret = cmt_label_add(cmetricsUntyped->instance, key, value);
+
+    if (ret == 0) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE
+rb_cmetrics_untyped_to_prometheus(VALUE self)
+{
+    struct CMetricsUntyped* cmetricsUntyped;
+    cmt_sds_t prom;
+    VALUE str;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    prom = cmt_encode_prometheus_create(cmetricsUntyped->instance, CMT_TRUE);
+
+    str = rb_str_new2(prom);
+
+    cmt_encode_prometheus_destroy(prom);
+
+    return str;
+}
+
+static VALUE
+rb_cmetrics_untyped_to_influx(VALUE self)
+{
+    struct CMetricsUntyped* cmetricsUntyped;
+    cmt_sds_t prom;
+    VALUE str;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    prom = cmt_encode_influx_create(cmetricsUntyped->instance);
+
+    str = rb_str_new2(prom);
+
+    cmt_encode_influx_destroy(prom);
+
+    return str;
+}
+
+static VALUE
+rb_cmetrics_untyped_to_msgpack(VALUE self)
+{
+    struct CMetricsUntyped* cmetricsUntyped;
+    char *buffer;
+    size_t buffer_size;
+    int ret = 0;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    ret = cmt_encode_msgpack_create(cmetricsUntyped->instance, &buffer, &buffer_size);
+
+    if (ret == 0) {
+        return rb_str_new(buffer, buffer_size);
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE
+rb_cmetrics_untyped_to_text(VALUE self)
+{
+    struct CMetricsUntyped* cmetricsUntyped;
+    cmt_sds_t buffer;
+    VALUE text;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    buffer = cmt_encode_text_create(cmetricsUntyped->instance);
+    if (buffer == NULL) {
+        return Qnil;
+    }
+
+    text = rb_str_new2(buffer);
+
+    cmt_sds_destroy(buffer);
+
+    return text;
+}
+
+void Init_cmetrics_untyped(VALUE rb_mCMetrics)
+{
+    rb_cUntyped = rb_define_class_under(rb_mCMetrics, "Untyped", rb_cObject);
+
+    rb_define_alloc_func(rb_cUntyped, rb_cmetrics_untyped_alloc);
+
+    rb_define_method(rb_cUntyped, "initialize", rb_cmetrics_untyped_initialize, 0);
+    rb_define_method(rb_cUntyped, "create", rb_cmetrics_untyped_create, -1);
+    rb_define_method(rb_cUntyped, "get_value", rb_cmetrics_untyped_get_value, -1);
+    rb_define_method(rb_cUntyped, "value", rb_cmetrics_untyped_get_value, -1);
+    rb_define_method(rb_cUntyped, "val", rb_cmetrics_untyped_get_value, -1);
+    rb_define_method(rb_cUntyped, "set", rb_cmetrics_untyped_set, -1);
+    rb_define_method(rb_cUntyped, "val=", rb_cmetrics_untyped_set, -1);
+    rb_define_method(rb_cUntyped, "value=", rb_cmetrics_untyped_set, -1);
+    rb_define_method(rb_cUntyped, "add_label", rb_cmetrics_untyped_add_label, 2);
+    rb_define_method(rb_cUntyped, "to_influx", rb_cmetrics_untyped_to_influx, 0);
+    rb_define_method(rb_cUntyped, "to_prometheus", rb_cmetrics_untyped_to_prometheus, 0);
+    rb_define_method(rb_cUntyped, "to_msgpack", rb_cmetrics_untyped_to_msgpack, 0);
+    rb_define_method(rb_cUntyped, "to_s", rb_cmetrics_untyped_to_text, 0);
+}

data/ext/cmetrics/extconf.rb

@@ -28,7 +28,7 @@ class BuildCMetrics
     @recipe.target = File.join(ROOT, "ports")
     @recipe.files << {
       url: "file://#{ROOT}/ext/#{@recipe.name}-#{@recipe.version}.tar.gz",
-      sha256sum: "34df0842ee23e4c9440e787722fb79cf7204ebb3fed2dc3fb5e02f4c9c4807dc",
+      sha256sum: "5ba909df989bf7f3404000d9e04702eaa47cbfd51bb8ec161ca19011f95bc360",
     }
   end
 

data/lib/cmetrics/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CMetrics
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cmetrics
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Hiroshi Hatake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-08 00:00:00.000000000 Z
+date: 2021-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,6 +105,7 @@ files:
 - ext/cmetrics/cmetrics_counter.c
 - ext/cmetrics/cmetrics_gauge.c
 - ext/cmetrics/cmetrics_serde.c
+- ext/cmetrics/cmetrics_untyped.c
 - ext/cmetrics/extconf.rb
 - lib/cmetrics.rb
 - lib/cmetrics/version.rb