cmetrics 0.1.7 → 0.2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0c8e72735e2b8d4a23cff25f45d22b8532bb9d5264011292e07a624304bbbf1
-  data.tar.gz: 55fac2f85a6729a18897abcfed5fdde9098269be899038a7b2bf1c4313988d04
+  metadata.gz: a1d2203114cf90a7d63a5fc3654f2feb4dca6f06e6a5f7bef307ac3d22b7b890
+  data.tar.gz: d06d5b84c4b6614df1e0e9a1a301ab450cc871192b89fb1cb556d54d4040d338
 SHA512:
-  metadata.gz: b6372b5e06fbba2d4c53c5e1df6250e02192a7ca645093b5682fe49ed985e50ce4fda080d0b2fe18b00d0abc8fd101bba2d33f5e5de91163f429937966d920f3
-  data.tar.gz: 4933e44b64f8e2cebf0f5534238e22cc0053cf4959070cd3f84acda7561e5cf8020e42bc510f13f468865905d90a9d8e8ed8e6ad3dca6367f085a398a64722f5
+  metadata.gz: 1808639928823b48c0e52f333a898a3816bbf3e4396a922b30a22eb062552ee28cf5c7a7fdaac91392dc23ff2747ee5d0c2e183e74591b43577b4240397c1384
+  data.tar.gz: 347c9a59d332714286996dcc0450a20f8fd7de511677e9a1768fb059f2fec73578bf2dd18d2184094c498bc6adc64d35cdb25c559c278b9e43fc3395a0812adc

data/.github/workflows/apt.yml

@@ -0,0 +1,39 @@
+name: Apt based Linux
+on:
+  push:
+  pull_request:
+jobs:
+  build:
+    name: Build
+    strategy:
+      fail-fast: false
+      matrix:
+        label:
+          - Debian GNU/Linux Bullseye amd64
+          - Debian GNU/Linux Buster amd64
+          - Ubuntu Bionic amd64
+          - Ubuntu Focal amd64
+        include:
+          - label: Debian GNU/Linux Bullseye amd64
+            test-docker-image: debian:bullseye
+            test-script: ci/apt-test.sh
+          - label: Debian GNU/Linux Buster amd64
+            test-docker-image: debian:buster
+            test-script: ci/apt-test.sh
+          - label: Ubuntu Bionic amd64
+            test-docker-image: ubuntu:bionic
+            test-script: ci/apt-test.sh
+          - label: Ubuntu Focal amd64
+            test-docker-image: ubuntu:focal
+            test-script: ci/apt-test.sh
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - name: rake compile & rake test
+        run: |
+          docker run \
+          --rm \
+          --tty \
+          --volume ${PWD}:/cmetrics-ruby \
+          ${{ matrix.test-docker-image }} \
+          /cmetrics-ruby/${{ matrix.test-script }}

data/.github/workflows/linux.yml

@@ -10,9 +10,9 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0.1
+        ruby-version: '3.0'
     - name: Run the default task
       run: |
-        gem install bundler -v 2.2.15
+        gem install bundler -v 2.2.26
         bundle install
         bundle exec rake

data/.github/workflows/macos.yml

@@ -10,9 +10,9 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0.1
+        ruby-version: '3.0'
     - name: Run the default task
       run: |
-        gem install bundler -v 2.2.15
+        gem install bundler -v 2.2.26
         bundle install
         bundle exec rake

data/.github/workflows/windows.yml

@@ -10,9 +10,9 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0.1
+        ruby-version: '3.0'
     - name: Run the default task
       run: |
-        gem install bundler -v 2.2.15
+        gem install bundler -v 2.2.26
         ridk exec bundle install
         ridk exec bundle exec rake

data/.github/workflows/yum.yml

@@ -0,0 +1,39 @@
+name: Yum based Linux
+on:
+  push:
+  pull_request:
+jobs:
+  build:
+    name: Build
+    strategy:
+      fail-fast: false
+      matrix:
+        label:
+          - CentOS 7 x86_64
+          - CentOS 8 x86_64
+          - Fedora 34 x86_64
+          - AmazonLinux 2 x86_64
+        include:
+          - label: CentOS 7 x86_64
+            test-docker-image: centos:7
+            test-script: ci/yum-test.sh
+          - label: CentOS 8 x86_64
+            test-docker-image: centos:8
+            test-script: ci/yum-test.sh
+          - label: Fedora 34 x86_64
+            test-docker-image: fedora:34
+            test-script: ci/yum-test.sh
+          - label: AmazonLinux 2 x86_64
+            test-docker-image: amazonlinux:2
+            test-script: ci/yum-test.sh
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - name: rake compile & rake test
+        run: |
+          docker run \
+          --rm \
+          --tty \
+          --volume ${PWD}:/cmetrics-ruby \
+          ${{ matrix.test-docker-image }} \
+          /cmetrics-ruby/${{ matrix.test-script }}

data/Gemfile

@@ -7,4 +7,10 @@ gemspec
 
 gem "rake", "~> 13.0"
 
-gem "test-unit", "~> 3.0"
+gem "test-unit", "~> 3.4"
+
+local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
+if File.exist?(local_gemfile)
+  puts "Loading Gemfile.local ..." if $DEBUG # `ruby -d` or `bundle -v`
+  instance_eval File.read(local_gemfile)
+end

data/ci/apt-test.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+set -exu
+
+export DEBIAN_FRONTEND=noninteractive
+
+if [ -f /etc/lsb-release ]; then
+    . /etc/lsb-release
+    distribution=$DISTRIB_ID
+    version=${DISTRIB_RELEASE%%.*}
+    codename=${DISTRIB_CODENAME%%.*}
+else
+    distribution="Debian"
+    version=$(cat /etc/debian_version | cut -d'.' -f1)
+fi
+
+apt update
+
+case "$distribution" in
+    "Ubuntu")
+        case "$codename" in
+            "bionic")
+                apt install -V -y wget gpg
+                wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | tee /usr/share/keyrings/kitware-archive-keyring.gpg >/dev/null && \
+                echo 'deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ bionic main' | tee /etc/apt/sources.list.d/kitware.list >/dev/null && \
+                apt update
+                ;;
+            *)
+                ;;
+        esac
+        ;;
+esac
+
+apt install -V -y lsb-release
+
+apt install -V -y ruby-dev git build-essential pkg-config cmake
+cd /cmetrics-ruby && \
+    gem install bundler --no-document && \
+    bundle install && \
+    bundle exec rake

data/ci/yum-test.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+
+set -exu
+
+USE_SCL=0
+USE_AMZN_EXT=0
+
+distribution=$(cat /etc/system-release-cpe | awk '{print substr($0, index($1, "o"))}' | cut -d: -f2)
+version=$(cat /etc/system-release-cpe | awk '{print substr($0, index($1, "o"))}' | cut -d: -f4)
+USE_SCL=0
+USE_AMZN_EXT=0
+
+case ${distribution} in
+  amazon)
+    case ${version} in
+      2)
+        DNF=yum
+        USE_AMZN_EXT=1
+        ;;
+    esac
+    ;;
+  centos)
+    case ${version} in
+      7)
+        DNF=yum
+        USE_SCL=1
+        ;;
+      *)
+        DNF="dnf --enablerepo=powertools"
+        ;;
+    esac
+    ;;
+  fedoraproject)
+    case ${version} in
+      33|34)
+        DNF=yum
+        ;;
+    esac
+    ;;
+esac
+
+${DNF} groupinstall -y "Development Tools"
+
+if [ $USE_SCL -eq 1 ]; then
+    ${DNF} install -y centos-release-scl && \
+    ${DNF} install -y epel-release && \
+    ${DNF} install -y \
+    rh-ruby26-ruby-devel \
+    rh-ruby26-rubygems \
+    rh-ruby26-rubygem-rake \
+    rpm-build \
+    cmake3
+elif [ $USE_AMZN_EXT -eq 1 ]; then
+    yum update -y && \
+    yum install -y yum-utils && \
+    yum-config-manager --enable epel && \
+    amazon-linux-extras install -y ruby2.6 && \
+    ${DNF} install -y ruby-devel \
+           cmake3
+else
+    ${DNF} install -y ruby-devel \
+           rubygems \
+           rpm-build \
+           cmake \
+           libarchive
+fi
+
+if [ $USE_SCL -eq 1 ]; then
+    # For unbound variable error
+    export MANPATH=
+    cd /cmetrics-ruby && source /opt/rh/rh-ruby26/enable && gem install bundler --no-document && bundle install && bundle exec rake
+else
+    if [ $USE_AMZN_EXT -eq 1 ]; then
+        echo 'gem "io-console"' > /cmetrics-ruby/Gemfile.local
+    fi
+    cd /cmetrics-ruby && gem install bundler --no-document && bundle install && bundle exec rake
+fi

data/cmetrics-ruby.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", ">= 0"
   spec.add_development_dependency "rake-compiler", "~> 1.0"
   spec.add_development_dependency "rake-compiler-dock", "~> 1.0"
+  spec.add_development_dependency "msgpack", "~> 1.4.2"
 
-  spec.add_dependency 'mini_portile2', '~> 2.1'
+  spec.add_dependency 'mini_portile2', '~> 2.6'
 end

data/ext/cmetrics/cmetrics_c.h

@@ -65,5 +65,8 @@ 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);
+const struct CMetricsCounter *cmetrics_counter_get_ptr(VALUE rb_mCMetrics);
+const struct CMetricsGauge *cmetrics_gauge_get_ptr(VALUE rb_mCMetrics);
+const struct CMetricsUntyped *cmetrics_untyped_get_ptr(VALUE rb_mCMetrics);
 
 #endif // _CMETRICS_C_H

data/ext/cmetrics/cmetrics_counter.c

@@ -34,16 +34,32 @@ static const rb_data_type_t rb_cmetrics_counter_type = { "cmetrics/counter",
                                                          RUBY_TYPED_FREE_IMMEDIATELY };
 
 
+const struct CMetricsCounter *cmetrics_counter_get_ptr(VALUE self)
+{
+    struct CMetricsCounter *cmetricsCounter = NULL;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsCounter, &rb_cmetrics_counter_type, cmetricsCounter);
+
+    if (NIL_P(self)) {
+        rb_raise(rb_eRuntimeError, "Given CMetrics argument must not be nil");
+    }
+    if (!cmetricsCounter->counter) {
+        rb_raise(rb_eRuntimeError, "Create counter with CMetrics::Counter#create first.");
+    }
+    return cmetricsCounter;
+}
+
 static void
 counter_free(void* ptr)
 {
     struct CMetricsCounter* cmetricsCounter = (struct CMetricsCounter*)ptr;
 
-    if (!cmetricsCounter) {
-        if (!cmetricsCounter->counter) {
+    if (cmetricsCounter) {
+        if (cmetricsCounter->counter) {
             cmt_counter_destroy(cmetricsCounter->counter);
         }
-        if (!cmetricsCounter->instance) {
+        if (cmetricsCounter->instance) {
             cmt_destroy(cmetricsCounter->instance);
         }
     }

data/ext/cmetrics/cmetrics_gauge.c

@@ -34,16 +34,32 @@ static const rb_data_type_t rb_cmetrics_gauge_type = { "cmetrics/gauge",
                                                        RUBY_TYPED_FREE_IMMEDIATELY };
 
 
+const struct CMetricsGauge *cmetrics_gauge_get_ptr(VALUE self)
+{
+    struct CMetricsGauge *cmetricsGauge = NULL;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsGauge, &rb_cmetrics_gauge_type, cmetricsGauge);
+
+    if (NIL_P(self)) {
+        rb_raise(rb_eRuntimeError, "Given CMetrics argument must not be nil");
+    }
+    if (!cmetricsGauge->gauge) {
+        rb_raise(rb_eRuntimeError, "Create gauge with CMetrics::Gauge#create first.");
+    }
+    return cmetricsGauge;
+}
+
 static void
 gauge_free(void* ptr)
 {
     struct CMetricsGauge* cmetricsGauge = (struct CMetricsGauge*)ptr;
 
-    if (!cmetricsGauge) {
-        if (!cmetricsGauge->gauge) {
+    if (cmetricsGauge) {
+        if (cmetricsGauge->gauge) {
             cmt_gauge_destroy(cmetricsGauge->gauge);
         }
-        if (!cmetricsGauge->instance) {
+        if (cmetricsGauge->instance) {
             cmt_destroy(cmetricsGauge->instance);
         }
     }

data/ext/cmetrics/cmetrics_serde.c

@@ -18,9 +18,16 @@
  */
 
 #include "cmetrics_c.h"
+#include <cmetrics/cmt_map.h>
+#include <cmetrics/cmt_metric.h>
+#include <cmetrics/cmt_cat.h>
 
 VALUE rb_cSerde;
 
+extern VALUE rb_cCounter;
+extern VALUE rb_cGauge;
+extern VALUE rb_cUntyped;
+
 static void serde_free(void* ptr);
 
 static const rb_data_type_t rb_cmetrics_serde_type = { "cmetrics/serde",
@@ -39,8 +46,8 @@ serde_free(void* ptr)
 {
     struct CMetricsSerde* cmetricsSerde = (struct CMetricsSerde*)ptr;
 
-    if (!cmetricsSerde) {
-        if (!cmetricsSerde->instance) {
+    if (cmetricsSerde) {
+        if (cmetricsSerde->instance) {
             cmt_destroy(cmetricsSerde->instance);
         }
     }
@@ -111,7 +118,11 @@ rb_cmetrics_serde_from_msgpack(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eRuntimeError, "offset should be smaller than msgpack buffer size.");
     }
 
-    ret = cmt_decode_msgpack_create(&cmt, StringValuePtr(rb_msgpack_buffer), msgpack_length, &offset);
+    if (!NIL_P(rb_msgpack_buffer)) {
+        ret = cmt_decode_msgpack_create(&cmt, StringValuePtr(rb_msgpack_buffer), msgpack_length, &offset);
+    } else {
+        rb_raise(rb_eArgError, "nil is not valid value for buffer");
+    }
 
     if (ret == 0) {
         cmetricsSerde->instance = cmt;
@@ -129,13 +140,14 @@ rb_cmetrics_serde_from_msgpack_feed_each_impl(VALUE self, VALUE rb_msgpack_buffe
     struct CMetricsSerde* cmetricsSerde;
     struct cmt *cmt = NULL;
     int ret = 0;
+    size_t offset = 0;
 
     RETURN_ENUMERATOR(self, 0, 0);
 
     TypedData_Get_Struct(
             self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
 
-    for (size_t offset = 0; offset <= msgpack_length; ) {
+    for (offset = 0; offset <= msgpack_length; ) {
         ret = cmt_decode_msgpack_create(&cmt, StringValuePtr(rb_msgpack_buffer), msgpack_length, &offset);
         if (ret == 0) {
             cmetricsSerde->instance = cmt;
@@ -154,8 +166,46 @@ static VALUE
 rb_cmetrics_serde_from_msgpack_feed_each(VALUE self, VALUE rb_data)
 {
     RETURN_ENUMERATOR(self, 0, 0);
+    if (!NIL_P(rb_data)) {
+        return rb_cmetrics_serde_from_msgpack_feed_each_impl(self, rb_data, RSTRING_LEN(rb_data));
+    } else {
+        rb_raise(rb_eArgError, "nil is not valid value for buffer");
+    }
+}
+
+static VALUE
+rb_cmetrics_serde_concat_metric(VALUE self, VALUE rb_data)
+{
+    struct CMetricsSerde* cmetricsSerde = NULL;
+    struct CMetricsCounter* cmetricsCounter = NULL;
+    struct CMetricsGauge* cmetricsGauge = NULL;
+    struct CMetricsUntyped* cmetricsUntyped = NULL;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
+
+    if (!NIL_P(rb_data)) {
+        if (cmetricsSerde->instance == NULL) {
+            cmetricsSerde->instance = cmt_create();
+        }
+
+        if (rb_obj_is_kind_of(rb_data, rb_cCounter)) {
+            cmetricsCounter = (struct CMetricsCounter *)cmetrics_counter_get_ptr(rb_data);
+            cmt_cat(cmetricsSerde->instance, cmetricsCounter->instance);
+        } else if (rb_obj_is_kind_of(rb_data, rb_cGauge)) {
+            cmetricsGauge = (struct CMetricsGauge *)cmetrics_gauge_get_ptr(rb_data);
+            cmt_cat(cmetricsSerde->instance, cmetricsGauge->instance);
+        } else if (rb_obj_is_kind_of(rb_data, rb_cUntyped)) {
+            cmetricsUntyped = (struct CMetricsUntyped *)cmetrics_untyped_get_ptr(rb_data);
+            cmt_cat(cmetricsSerde->instance, cmetricsUntyped->instance);
+        } else {
+            rb_raise(rb_eArgError, "specified type of instance is not supported.");
+        }
+    } else {
+        rb_raise(rb_eArgError, "nil is not valid value for concatenating");
+    }
 
-    return rb_cmetrics_serde_from_msgpack_feed_each_impl(self, rb_data, RSTRING_LEN(rb_data));
+    return Qnil;
 }
 
 static VALUE
@@ -168,6 +218,10 @@ rb_cmetrics_serde_to_prometheus(VALUE self)
     TypedData_Get_Struct(
             self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
 
+    if (cmetricsSerde->instance == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid cmt context");
+    }
+
     prom = cmt_encode_prometheus_create(cmetricsSerde->instance, CMT_TRUE);
 
     str = rb_str_new2(prom);
@@ -187,6 +241,10 @@ rb_cmetrics_serde_to_influx(VALUE self)
     TypedData_Get_Struct(
             self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
 
+    if (cmetricsSerde->instance == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid cmt context");
+    }
+
     prom = cmt_encode_influx_create(cmetricsSerde->instance);
 
     str = rb_str_new2(prom);
@@ -206,6 +264,10 @@ rb_cmetrics_serde_to_msgpack(VALUE self)
     TypedData_Get_Struct(
             self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
 
+    if (cmetricsSerde->instance == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid cmt context");
+    }
+
     ret = cmt_encode_msgpack_create(cmetricsSerde->instance, &buffer, &buffer_size);
 
     if (ret == 0) {
@@ -225,6 +287,10 @@ rb_cmetrics_serde_to_text(VALUE self)
     TypedData_Get_Struct(
             self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
 
+    if (cmetricsSerde->instance == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid cmt context");
+    }
+
     buffer = cmt_encode_text_create(cmetricsSerde->instance);
     if (buffer == NULL) {
         return Qnil;
@@ -237,6 +303,151 @@ rb_cmetrics_serde_to_text(VALUE self)
     return text;
 }
 
+static VALUE
+append_metric_value(struct cmt_map *map,
+                    VALUE rbHash, struct cmt_metric *metric)
+{
+    uint64_t ts;
+    double val;
+    struct cmt_opts *opts;
+
+    opts = map->opts;
+
+    /* Retrieve metric value */
+    val = cmt_metric_get_value(metric);
+
+    ts = cmt_metric_get_timestamp(metric);
+
+    rb_hash_aset(rbHash, rb_str_new2("name"), rb_str_new2(opts->name));
+    rb_hash_aset(rbHash, rb_str_new2("description"), rb_str_new2(opts->description));
+    rb_hash_aset(rbHash, rb_str_new2("value"), DBL2NUM(val));
+    rb_hash_aset(rbHash, rb_str_new2("timestamp"), DBL2NUM(ts/1000000000.0));
+
+    return rbHash;
+}
+
+static VALUE
+format_metric(struct cmt *cmt, struct cmt_map *map,
+              struct cmt_metric *metric)
+{
+    int n;
+    int static_labels = 0;
+    struct cmt_map_label *label_k;
+    struct cmt_map_label *label_v;
+    struct mk_list *head;
+    struct cmt_opts *opts;
+    struct cmt_label *slabel;
+    VALUE rb_hash = rb_hash_new();
+    VALUE shash = rb_hash_new();
+    VALUE lhash = rb_hash_new();
+
+    opts = map->opts;
+
+    /* Measurement */
+    rb_hash_aset(rb_hash, rb_str_new2("namespace"), rb_str_new2(opts->ns));
+    rb_hash_aset(rb_hash, rb_str_new2("subsystem"), rb_str_new2(opts->subsystem));
+
+    /* Static labels (tags) */
+    static_labels = cmt_labels_count(cmt->static_labels);
+    if (static_labels > 0) {
+        mk_list_foreach(head, &cmt->static_labels->list) {
+            slabel = mk_list_entry(head, struct cmt_label, _head);
+            rb_hash_aset(shash, rb_str_new2(slabel->key), rb_str_new2(slabel->val));
+        }
+        rb_hash_aset(rb_hash, rb_str_new2("static_labels"), shash);
+    }
+
+    /* Labels / Tags */
+    n = mk_list_size(&metric->labels);
+    if (n > 0) {
+        label_k = mk_list_entry_first(&map->label_keys, struct cmt_map_label, _head);
+
+        mk_list_foreach(head, &metric->labels) {
+            label_v = mk_list_entry(head, struct cmt_map_label, _head);
+
+            rb_hash_aset(lhash, rb_str_new2(label_k->name), rb_str_new2(label_v->name));
+
+            label_k = mk_list_entry_next(&label_k->_head, struct cmt_map_label,
+                                         _head, &map->label_keys);
+        }
+        rb_hash_aset(rb_hash, rb_str_new2("labels"), lhash);
+    }
+
+    rb_hash = append_metric_value(map, rb_hash, metric);
+
+    return rb_hash;
+}
+
+static VALUE
+format_metrics(struct cmt *cmt,
+               struct cmt_map *map, int add_timestamp)
+{
+    VALUE rbMetrics = rb_ary_new();
+    VALUE rbMetric;
+    struct mk_list *head;
+    struct cmt_metric *metric;
+
+    /* Simple metric, no labels */
+    if (map->metric_static_set == 1) {
+        rbMetric = format_metric(cmt, map, &map->metric);
+        rb_ary_push(rbMetrics, rbMetric);
+    }
+
+    mk_list_foreach(head, &map->metrics) {
+        metric = mk_list_entry(head, struct cmt_metric, _head);
+        rbMetric = format_metric(cmt, map, metric);
+        rb_ary_push(rbMetrics, rbMetric);
+    }
+
+    return rbMetrics;
+}
+
+static VALUE
+rb_cmetrics_serde_get_metrics(VALUE self)
+{
+    VALUE rbMetrics = rb_ary_new();
+    VALUE rbMetricsInner = rb_ary_new();
+    struct CMetricsSerde* cmetricsSerde;
+    struct mk_list *head;
+    struct cmt_gauge *gauge;
+    struct cmt_counter *counter;
+    struct cmt_untyped *untyped;
+    struct cmt *cmt;
+    int add_timestamp = CMT_TRUE;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsSerde, &rb_cmetrics_serde_type, cmetricsSerde);
+
+    cmt = cmetricsSerde->instance;
+
+    if (cmt == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid cmt context");
+    }
+
+    /* Counters */
+    mk_list_foreach(head, &cmt->counters) {
+        counter = mk_list_entry(head, struct cmt_counter, _head);
+        rbMetricsInner = format_metrics(cmt, counter->map, add_timestamp);
+        rb_ary_push(rbMetrics, rbMetricsInner);
+    }
+
+    /* Gauges */
+    mk_list_foreach(head, &cmt->gauges) {
+        gauge = mk_list_entry(head, struct cmt_gauge, _head);
+        rbMetricsInner = format_metrics(cmt, gauge->map, add_timestamp);
+        rb_ary_push(rbMetrics, rbMetricsInner);
+    }
+
+    /* Untyped */
+    mk_list_foreach(head, &cmt->untypeds) {
+        untyped = mk_list_entry(head, struct cmt_untyped, _head);
+        rbMetricsInner = format_metrics(cmt, untyped->map, add_timestamp);
+        rb_ary_push(rbMetrics, rbMetricsInner);
+    }
+
+    return rbMetrics;
+}
+
 void Init_cmetrics_serde(VALUE rb_mCMetrics)
 {
     rb_cSerde = rb_define_class_under(rb_mCMetrics, "Serde", rb_cObject);
@@ -244,10 +455,13 @@ void Init_cmetrics_serde(VALUE rb_mCMetrics)
     rb_define_alloc_func(rb_cSerde, rb_cmetrics_serde_alloc);
 
     rb_define_method(rb_cSerde, "initialize", rb_cmetrics_serde_initialize, 0);
+    rb_define_method(rb_cSerde, "concat", rb_cmetrics_serde_concat_metric, 1);
     rb_define_method(rb_cSerde, "from_msgpack", rb_cmetrics_serde_from_msgpack, -1);
     rb_define_method(rb_cSerde, "to_prometheus", rb_cmetrics_serde_to_prometheus, 0);
     rb_define_method(rb_cSerde, "to_influx", rb_cmetrics_serde_to_influx, 0);
     rb_define_method(rb_cSerde, "to_msgpack", rb_cmetrics_serde_to_msgpack, 0);
     rb_define_method(rb_cSerde, "feed_each", rb_cmetrics_serde_from_msgpack_feed_each, 1);
     rb_define_method(rb_cSerde, "to_s", rb_cmetrics_serde_to_text, 0);
+    rb_define_method(rb_cSerde, "get_metrics", rb_cmetrics_serde_get_metrics, 0);
+    rb_define_method(rb_cSerde, "metrics", rb_cmetrics_serde_get_metrics, 0);
 }

data/ext/cmetrics/cmetrics_untyped.c

@@ -34,16 +34,32 @@ static const rb_data_type_t rb_cmetrics_untyped_type = { "cmetrics/untyped",
                                                          RUBY_TYPED_FREE_IMMEDIATELY };
 
 
+const struct CMetricsUntyped *cmetrics_untyped_get_ptr(VALUE self)
+{
+    struct CMetricsUntyped *cmetricsUntyped = NULL;
+
+    TypedData_Get_Struct(
+            self, struct CMetricsUntyped, &rb_cmetrics_untyped_type, cmetricsUntyped);
+
+    if (NIL_P(self)) {
+        rb_raise(rb_eRuntimeError, "Given CMetrics argument must not be nil");
+    }
+    if (!cmetricsUntyped->untyped) {
+        rb_raise(rb_eRuntimeError, "Create untyped with CMetrics::Untyped#create first.");
+    }
+    return cmetricsUntyped;
+}
+
 static void
 untyped_free(void* ptr)
 {
     struct CMetricsUntyped* cmetricsUntyped = (struct CMetricsUntyped*)ptr;
 
-    if (!cmetricsUntyped) {
-        if (!cmetricsUntyped->untyped) {
+    if (cmetricsUntyped) {
+        if (cmetricsUntyped->untyped) {
             cmt_untyped_destroy(cmetricsUntyped->untyped);
         }
-        if (!cmetricsUntyped->instance) {
+        if (cmetricsUntyped->instance) {
             cmt_destroy(cmetricsUntyped->instance);
         }
     }

data/ext/cmetrics/extconf.rb

@@ -27,19 +27,19 @@ class BuildCMetrics
     @checkpoint = ".#{@recipe.name}-#{@recipe.version}.installed"
     @recipe.target = File.join(ROOT, "ports")
     @recipe.files << {
-      url: "file://#{ROOT}/ext/#{@recipe.name}-#{@recipe.version}.tar.gz",
-      sha256sum: "3375ac1073b0bbea44ee9986601977ef04b119a74a7c663e2486a3ed31953203",
+      url: "https://codeload.github.com/calyptia/cmetrics/tar.gz/v#{version}",
+      sha256sum: "f0c79707ad4d18980bf0d1d64ed8cb73a40c586c36a4caf38233ae8d9a4c6cc7",
     }
   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"))
@@ -52,7 +52,7 @@ class BuildCMetrics
   end
 end
 
-cmetrics = BuildCMetrics.new
+cmetrics = BuildCMetrics.new("0.2.1")
 cmetrics.build
 
 libdir = RbConfig::CONFIG["libdir"]

data/lib/cmetrics/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cmetrics
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0.1
 platform: ruby
 authors:
 - Hiroshi Hatake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-13 00:00:00.000000000 Z
+date: 2021-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,20 +66,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: mini_portile2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.6'
 description: C binding for cmetric library.
 email:
 - cosmo0920.oucc@gmail.com
@@ -88,9 +102,11 @@ extensions:
 - ext/cmetrics/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/apt.yml"
 - ".github/workflows/linux.yml"
 - ".github/workflows/macos.yml"
 - ".github/workflows/windows.yml"
+- ".github/workflows/yum.yml"
 - ".gitignore"
 - Gemfile
 - LICENSE
@@ -98,8 +114,9 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- ci/apt-test.sh
+- ci/yum-test.sh
 - cmetrics-ruby.gemspec
-- ext/cmetrics-master.tar.gz
 - ext/cmetrics/cmetrics.c
 - ext/cmetrics/cmetrics_c.h
 - ext/cmetrics/cmetrics_counter.c
@@ -130,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: C binding for cmetric library.