cmetrics 0.1.4 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa39014510bd34dc658bb6e8f1fa555e792d113d0fee18024e387595a6a4b84
-  data.tar.gz: 9af18715cb13b236b05c3210bbadc211a569ad4abef8fcd923af55621a2a7e4f
+  metadata.gz: f1dbbff3db2b8ab48525d50430ae0996558ecb1ece4f939a91a22b883b37e996
+  data.tar.gz: 1b940e1b8d6b008b7eac4bedd2ea7bc0607b3d7d000e10eaddb772e69fdc4be0
 SHA512:
-  metadata.gz: c4caa6d06d460e756761607d73c23fb50a881a9522c8f9e4bebcac444ba3e432f0bf101c70098a2f3d03bf29f8dbdb355194a68422339bee9220cf976289ee88
-  data.tar.gz: 36679c7e06d428936ddfc345e7cbb1ec9a923571a19443e54df53bd2aa37467ebd21e3a5bd67c571431e6be5851dff73e05a977a2c5fa492a72527105732ad1a
+  metadata.gz: fa5335b809cd35aed0ece8c7b551b016d62ab5af6739124e4fd151dfa79ab1593326c27813311828cd92950e02cc41d4924e9f4da380459f9dc8ee828044a3fb
+  data.tar.gz: a395971b303280ca1586fab5f190f55857eaa9b1ece6650fc92c003a7231c4af926dcfab7c887e4f39241950a7163bde82ba248164340e465aeab4ccf1b4cf87

data/README.md

@@ -6,6 +6,12 @@
 
 A Ruby binding for [cmetrics](https://github.com/calyptia/cmetrics).
 
+## Prerequisites
+
+* Ruby 2.4 or later with its headers
+* CMake 3.13 or later due to different directory TARGETS for bundled cmetrics installation
+* gcc or clang or some equivalents toolchain
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,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'
 
@@ -88,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`.
@@ -151,6 +186,7 @@ require 'cmetrics'
 @wired_buffer = @gauge.to_msgpack + @counter.to_msgpack + @counter2.to_msgpack
 @serde = CMetrics::Serde.new
 
+puts "-----Decode with procedural style-----"
 # Decode for the context 1
 @serde.from_msgpack(@wired_buffer)
 puts @serde.to_prometheus
@@ -160,6 +196,12 @@ puts @serde.to_prometheus
 # Decode for the context 3
 @serde.from_msgpack(@wired_buffer)
 puts @serde.to_prometheus
+
+puts "-----Decode with streaming style-----"
+# Or, use streaming style API
+@serde.feed_each(@wired_buffer) do |serde|
+  puts serde.to_prometheus
+end
 ```
 
 ## Development

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);
@@ -548,7 +548,7 @@ rb_cmetrics_counter_add_label(VALUE self, VALUE rb_key, VALUE rb_value)
         value = RSTRING_PTR(rb_sym2str(rb_value));
         break;
     default:
-        rb_raise(rb_eArgError, "key should be String or Symbol class instance.");
+        rb_raise(rb_eArgError, "value should be String or Symbol class instance.");
     }
     ret = cmt_label_add(cmetricsCounter->instance, key, value);
 

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);
@@ -721,7 +721,7 @@ rb_cmetrics_gauge_add_label(VALUE self, VALUE rb_key, VALUE rb_value)
         value = RSTRING_PTR(rb_sym2str(rb_value));
         break;
     default:
-        rb_raise(rb_eArgError, "key should be String or Symbol class instance.");
+        rb_raise(rb_eArgError, "value should be String or Symbol class instance.");
     }
 
     ret = cmt_label_add(cmetricsGauge->instance, key, value);

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,18 +28,18 @@ class BuildCMetrics
     @recipe.target = File.join(ROOT, "ports")
     @recipe.files << {
       url: "file://#{ROOT}/ext/#{@recipe.name}-#{@recipe.version}.tar.gz",
-      sha256sum: "34df0842ee23e4c9440e787722fb79cf7204ebb3fed2dc3fb5e02f4c9c4807dc",
+      sha256sum: "3375ac1073b0bbea44ee9986601977ef04b119a74a7c663e2486a3ed31953203",
     }
   end
 
   def build
     unless File.exist?(@checkpoint)
       @recipe.cook
-      libcmetrics_path = File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/lib/libcmetrics.a")
+      libcmetrics_path = Dir.glob(File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/lib*/libcmetrics.a")).first
       FileUtils.cp(libcmetrics_path, File.join(ROOT, "ext", "cmetrics", "libcmetrics.a"))
-      libmpack_path = File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/lib/libmpack.a")
+      libmpack_path = Dir.glob(File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/lib*/libmpack.a")).first
       FileUtils.cp(libmpack_path, File.join(ROOT, "ext", "cmetrics", "libmpack.a"))
-      libxxhash_path = File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/lib/libxxhash.a")
+      libxxhash_path = Dir.glob(File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/lib*/libxxhash.a")).first
       FileUtils.cp(libxxhash_path, File.join(ROOT, "ext", "cmetrics", "libxxhash.a"))
       include_path = File.join(ROOT, "ports/#{@recipe.host}/cmetrics/#{@version}/include/")
       FileUtils.cp_r(Dir.glob(File.join(include_path, "*")), File.join(ROOT, "ext", "cmetrics"))
@@ -63,6 +63,8 @@ find_library("xxhash", nil, __dir__)
 find_library("mpack", nil, __dir__)
 find_library("cmetrics", nil, __dir__)
 
+$CFLAGS << " -std=c99 "
+
 have_func("gmtime_s", "time.h")
 
 create_makefile("cmetrics/cmetrics")

data/lib/cmetrics/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cmetrics
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.8
 platform: ruby
 authors:
 - Hiroshi Hatake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-07 00:00:00.000000000 Z
+date: 2021-07-13 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