pcp_easy 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9d7621df6e8b3c38023e15bfaf5ddaadd584939
-  data.tar.gz: f7d0872485ad3b1aeb5d6b189de5b939ad6b563e
+  metadata.gz: 7b7da9cf7cc2a13ab9973f7c94b5d95eaf31c351
+  data.tar.gz: dd9a83a80fa8ee7614900ee4be39877d26d66682
 SHA512:
-  metadata.gz: c3fa1b4e354c39f3b12ba11ac0f0b1771bc4c11eb9d0d864df697eac017da532d80204a8e304c4395e65dbd562e37bd39cf51ffd32964716175bfdf8a05ca303
-  data.tar.gz: 489ab0ff996d026347bdd968d17a3a1e3968ba8a028780c66c2c5b0837f296b49c7346293af9baaeaf1a182cc21fd155573425f5a457b11640c747067f86422e
+  metadata.gz: 6527fe6f2b9fd4ce89a081db47b6b358cd0dbf4132543f76d1903313a8fe8849e4c440d6067f8e61ee5567396f67f290c6e903c22728b20f0d79de7293af31d7
+  data.tar.gz: 4eb8144063b44ad94807c7134331195913294f38573c3668462f3db3666ca477f2c29609076faf5a6cac533b0fc16a1afc561298d99645cc53fbc69d51586234

data/ext/pcp_easy/agent.c

@@ -60,73 +60,13 @@ static VALUE initialize(VALUE self, VALUE hostname_rb) {
     return self;
 }
 
-static char* get_name_from_instance_id(int instance_id, int maximum_instances, int *instance_ids, char **instance_names) {
-    int i;
-    for(i=0; i<maximum_instances; i++) {
-        if(instance_id == instance_ids[i]) {
-            return instance_names[i];
-        }
-    }
-    return NULL;
-}
-
-static VALUE decode_multiple_instances(pmDesc pm_desc, pmValueSet *pm_value_set, char *metric_name) {
-    int error, i;
-    int number_of_instances = pm_value_set->numval;
-    int *instances = NULL;
-    char **instance_names = NULL;
-    VALUE result = rb_ary_new2(number_of_instances);
-
-
-    if((error = pmGetInDom(pm_desc.indom, &instances, &instance_names)) < 0) {
-        pcpeasy_raise_from_pmapi_error(error);
-    }
-
-    for(i = 0; i < number_of_instances; i++) {
-        char *instance_name = get_name_from_instance_id(pm_value_set->vlist[i].inst, number_of_instances, instances, instance_names);
-        rb_ary_push(result, pcpeasy_metric_new(metric_name, instance_name, &pm_value_set->vlist[i], &pm_desc, pm_value_set->valfmt));
-    }
-
-    free(instances);
-    free(instance_names);
-
-    return result;
-}
-
-static VALUE decode_single_instance(pmDesc pm_desc, pmValueSet *pm_value_set, char *metric_name) {
-    return pcpeasy_metric_new(metric_name, NULL, &pm_value_set->vlist[0], &pm_desc, pm_value_set->valfmt);
-}
-
-static VALUE decode_single_metric(pmID pmid, pmValueSet *pm_value_set, char *metric_name) {
-    int error;
-    pmDesc pm_desc;
-
-    /* No values, bail out */
-    if(pm_value_set->numval == 0) {
-        return Qnil;
-    }
-
-    /* Find out how to decode the metric */
-    if((error = pmLookupDesc(pmid, &pm_desc))) {
-        pcpeasy_raise_from_pmapi_error(error);
-    }
-
-    /* Do we have instances? */
-    if(pm_desc.indom == PM_INDOM_NULL) {
-        return decode_single_instance(pm_desc, pm_value_set, metric_name);
-    } else {
-        return decode_multiple_instances(pm_desc, pm_value_set, metric_name);
-    }
-
-}
-
-static VALUE decode_pm_result(pmID pmid, pmResult *pm_result, char *metric_name) {
+static VALUE decode_pm_result(pmResult *pm_result, char *metric_name) {
     /* No values (or somehow more than 1) */
     if (pm_result->numpmid != 1) {
         return Qnil;
     }
 
-    return decode_single_metric(pmid, pm_result->vset[0], metric_name);
+    return pcpeasy_metric_new(metric_name, pm_result->vset[0]);
 }
 
 static VALUE metric(VALUE self, VALUE metric_string_rb) {
@@ -160,15 +100,15 @@ static VALUE metric(VALUE self, VALUE metric_string_rb) {
     }
 
     /* Decode the result */
-    result = decode_pm_result(pmid, pm_result, metric_name);
+    result = decode_pm_result(pm_result, metric_name);
     pmFreeResult(pm_result);
 
     return result;
 }
 
 
-void pcpeasy_agent_init(VALUE pcpeasy_class) {
-    pcpeasy_agent_class = rb_define_class_under(pcpeasy_class, "Agent", rb_cObject);
+void pcpeasy_agent_init(VALUE rb_cPCPEasy) {
+    pcpeasy_agent_class = rb_define_class_under(rb_cPCPEasy, "Agent", rb_cObject);
 
     rb_define_alloc_func(pcpeasy_agent_class, allocate);
     rb_define_method(pcpeasy_agent_class, "initialize", initialize, 1);

data/ext/pcp_easy/agent.h

@@ -21,6 +21,6 @@
 
 #include <ruby.h>
 
-void pcpeasy_agent_init(VALUE pcpeasy_class);
+void pcpeasy_agent_init(VALUE rb_cPCPEasy);
 
 #endif

data/ext/pcp_easy/exceptions.c

@@ -157,57 +157,57 @@ void pcpeasy_raise_from_pmapi_error(int error_number) {
 }
 
 
-void pcpeasy_exceptions_init(VALUE pcpeasy_class) {
-    pcpeasy_error = rb_define_class_under(pcpeasy_class, "Error", rb_eStandardError);
-    pcpeasy_pmns_error = rb_define_class_under(pcpeasy_class, "PMNSError", pcpeasy_error);
-    pcpeasy_no_pmns_error = rb_define_class_under(pcpeasy_class, "NoPMNSError", pcpeasy_error);
-    pcpeasy_dup_pmns_error = rb_define_class_under(pcpeasy_class, "DupPMNSError", pcpeasy_error);
-    pcpeasy_text_error = rb_define_class_under(pcpeasy_class, "TextError", pcpeasy_error);
-    pcpeasy_app_version_error = rb_define_class_under(pcpeasy_class, "AppVersionError", pcpeasy_error);
-    pcpeasy_value_error = rb_define_class_under(pcpeasy_class, "ValueError", pcpeasy_error);
-    pcpeasy_timeout_error = rb_define_class_under(pcpeasy_class, "TimeoutError", pcpeasy_error);
-    pcpeasy_no_data_error = rb_define_class_under(pcpeasy_class, "NoDataError", pcpeasy_error);
-    pcpeasy_reset_error = rb_define_class_under(pcpeasy_class, "ResetError", pcpeasy_error);
-    pcpeasy_name_error = rb_define_class_under(pcpeasy_class, "NameError", pcpeasy_error);
-    pcpeasy_pmid_error = rb_define_class_under(pcpeasy_class, "PMIDError", pcpeasy_error);
-    pcpeasy_indom_error = rb_define_class_under(pcpeasy_class, "InDomError", pcpeasy_error);
-    pcpeasy_inst_error = rb_define_class_under(pcpeasy_class, "InstError", pcpeasy_error);
-    pcpeasy_unit_error = rb_define_class_under(pcpeasy_class, "UnitError", pcpeasy_error);
-    pcpeasy_conv_error = rb_define_class_under(pcpeasy_class, "ConvError", pcpeasy_error);
-    pcpeasy_trunc_error = rb_define_class_under(pcpeasy_class, "TruncError", pcpeasy_error);
-    pcpeasy_sign_error = rb_define_class_under(pcpeasy_class, "SignError", pcpeasy_error);
-    pcpeasy_profile_error = rb_define_class_under(pcpeasy_class, "ProfileError", pcpeasy_error);
-    pcpeasy_ipc_error = rb_define_class_under(pcpeasy_class, "IPCError", pcpeasy_error);
-    pcpeasy_eof_error = rb_define_class_under(pcpeasy_class, "EOFError", pcpeasy_error);
-    pcpeasy_not_host_error = rb_define_class_under(pcpeasy_class, "NotHostError", pcpeasy_error);
-    pcpeasy_eol_error = rb_define_class_under(pcpeasy_class, "EOLError", pcpeasy_error);
-    pcpeasy_mode_error = rb_define_class_under(pcpeasy_class, "ModeError", pcpeasy_error);
-    pcpeasy_label_error = rb_define_class_under(pcpeasy_class, "LabelError", pcpeasy_error);
-    pcpeasy_log_rec_error = rb_define_class_under(pcpeasy_class, "LogRecError", pcpeasy_error);
-    pcpeasy_not_archive_error = rb_define_class_under(pcpeasy_class, "NotArchiveError", pcpeasy_error);
-    pcpeasy_log_file_error = rb_define_class_under(pcpeasy_class, "LogFileError", pcpeasy_error);
-    pcpeasy_no_context_error = rb_define_class_under(pcpeasy_class, "NoContextError", pcpeasy_error);
-    pcpeasy_profile_spec_error = rb_define_class_under(pcpeasy_class, "ProfileSpecError", pcpeasy_error);
-    pcpeasy_pmid_log_error = rb_define_class_under(pcpeasy_class, "PMIDLogError", pcpeasy_error);
-    pcpeasy_indom_log_error = rb_define_class_under(pcpeasy_class, "InDomLogError", pcpeasy_error);
-    pcpeasy_inst_log_error = rb_define_class_under(pcpeasy_class, "InstLogError", pcpeasy_error);
-    pcpeasy_no_profile_error = rb_define_class_under(pcpeasy_class, "NoProfileError", pcpeasy_error);
-    pcpeasy_no_agent_error = rb_define_class_under(pcpeasy_class, "NoAgentError", pcpeasy_error);
-    pcpeasy_permission_error = rb_define_class_under(pcpeasy_class, "PermissionError", pcpeasy_error);
-    pcpeasy_connlimit_error = rb_define_class_under(pcpeasy_class, "ConnLimitError", pcpeasy_error);
-    pcpeasy_again_error = rb_define_class_under(pcpeasy_class, "AgainError", pcpeasy_error);
-    pcpeasy_is_conn_error = rb_define_class_under(pcpeasy_class, "IsConnError", pcpeasy_error);
-    pcpeasy_not_conn_error = rb_define_class_under(pcpeasy_class, "NotConnError", pcpeasy_error);
-    pcpeasy_need_port_error = rb_define_class_under(pcpeasy_class, "NeedPortError", pcpeasy_error);
-    pcpeasy_non_leaf_error = rb_define_class_under(pcpeasy_class, "NonLeafError", pcpeasy_error);
-    pcpeasy_type_error = rb_define_class_under(pcpeasy_class, "TypeError", pcpeasy_error);
-    pcpeasy_thread_error = rb_define_class_under(pcpeasy_class, "ThreadError", pcpeasy_error);
-    pcpeasy_no_container_error = rb_define_class_under(pcpeasy_class, "NoContainerError", pcpeasy_error);
-    pcpeasy_bad_store_error = rb_define_class_under(pcpeasy_class, "BadStoreError", pcpeasy_error);
-    pcpeasy_too_small_error = rb_define_class_under(pcpeasy_class, "TooSmallError", pcpeasy_error);
-    pcpeasy_too_big_error = rb_define_class_under(pcpeasy_class, "TooBigError", pcpeasy_error);
-    pcpeasy_fault_error = rb_define_class_under(pcpeasy_class, "FaultError", pcpeasy_error);
-    pcpeasy_pmda_ready_error = rb_define_class_under(pcpeasy_class, "PMDAReadyError", pcpeasy_error);
-    pcpeasy_pmda_not_ready_error = rb_define_class_under(pcpeasy_class, "PMDANotReadyError", pcpeasy_error);
-    pcpeasy_nyi_error = rb_define_class_under(pcpeasy_class, "NYIError", pcpeasy_error);
+void pcpeasy_exceptions_init(VALUE rb_cPCPEasy) {
+    pcpeasy_error = rb_define_class_under(rb_cPCPEasy, "Error", rb_eStandardError);
+    pcpeasy_pmns_error = rb_define_class_under(rb_cPCPEasy, "PMNSError", pcpeasy_error);
+    pcpeasy_no_pmns_error = rb_define_class_under(rb_cPCPEasy, "NoPMNSError", pcpeasy_error);
+    pcpeasy_dup_pmns_error = rb_define_class_under(rb_cPCPEasy, "DupPMNSError", pcpeasy_error);
+    pcpeasy_text_error = rb_define_class_under(rb_cPCPEasy, "TextError", pcpeasy_error);
+    pcpeasy_app_version_error = rb_define_class_under(rb_cPCPEasy, "AppVersionError", pcpeasy_error);
+    pcpeasy_value_error = rb_define_class_under(rb_cPCPEasy, "ValueError", pcpeasy_error);
+    pcpeasy_timeout_error = rb_define_class_under(rb_cPCPEasy, "TimeoutError", pcpeasy_error);
+    pcpeasy_no_data_error = rb_define_class_under(rb_cPCPEasy, "NoDataError", pcpeasy_error);
+    pcpeasy_reset_error = rb_define_class_under(rb_cPCPEasy, "ResetError", pcpeasy_error);
+    pcpeasy_name_error = rb_define_class_under(rb_cPCPEasy, "NameError", pcpeasy_error);
+    pcpeasy_pmid_error = rb_define_class_under(rb_cPCPEasy, "PMIDError", pcpeasy_error);
+    pcpeasy_indom_error = rb_define_class_under(rb_cPCPEasy, "InDomError", pcpeasy_error);
+    pcpeasy_inst_error = rb_define_class_under(rb_cPCPEasy, "InstError", pcpeasy_error);
+    pcpeasy_unit_error = rb_define_class_under(rb_cPCPEasy, "UnitError", pcpeasy_error);
+    pcpeasy_conv_error = rb_define_class_under(rb_cPCPEasy, "ConvError", pcpeasy_error);
+    pcpeasy_trunc_error = rb_define_class_under(rb_cPCPEasy, "TruncError", pcpeasy_error);
+    pcpeasy_sign_error = rb_define_class_under(rb_cPCPEasy, "SignError", pcpeasy_error);
+    pcpeasy_profile_error = rb_define_class_under(rb_cPCPEasy, "ProfileError", pcpeasy_error);
+    pcpeasy_ipc_error = rb_define_class_under(rb_cPCPEasy, "IPCError", pcpeasy_error);
+    pcpeasy_eof_error = rb_define_class_under(rb_cPCPEasy, "EOFError", pcpeasy_error);
+    pcpeasy_not_host_error = rb_define_class_under(rb_cPCPEasy, "NotHostError", pcpeasy_error);
+    pcpeasy_eol_error = rb_define_class_under(rb_cPCPEasy, "EOLError", pcpeasy_error);
+    pcpeasy_mode_error = rb_define_class_under(rb_cPCPEasy, "ModeError", pcpeasy_error);
+    pcpeasy_label_error = rb_define_class_under(rb_cPCPEasy, "LabelError", pcpeasy_error);
+    pcpeasy_log_rec_error = rb_define_class_under(rb_cPCPEasy, "LogRecError", pcpeasy_error);
+    pcpeasy_not_archive_error = rb_define_class_under(rb_cPCPEasy, "NotArchiveError", pcpeasy_error);
+    pcpeasy_log_file_error = rb_define_class_under(rb_cPCPEasy, "LogFileError", pcpeasy_error);
+    pcpeasy_no_context_error = rb_define_class_under(rb_cPCPEasy, "NoContextError", pcpeasy_error);
+    pcpeasy_profile_spec_error = rb_define_class_under(rb_cPCPEasy, "ProfileSpecError", pcpeasy_error);
+    pcpeasy_pmid_log_error = rb_define_class_under(rb_cPCPEasy, "PMIDLogError", pcpeasy_error);
+    pcpeasy_indom_log_error = rb_define_class_under(rb_cPCPEasy, "InDomLogError", pcpeasy_error);
+    pcpeasy_inst_log_error = rb_define_class_under(rb_cPCPEasy, "InstLogError", pcpeasy_error);
+    pcpeasy_no_profile_error = rb_define_class_under(rb_cPCPEasy, "NoProfileError", pcpeasy_error);
+    pcpeasy_no_agent_error = rb_define_class_under(rb_cPCPEasy, "NoAgentError", pcpeasy_error);
+    pcpeasy_permission_error = rb_define_class_under(rb_cPCPEasy, "PermissionError", pcpeasy_error);
+    pcpeasy_connlimit_error = rb_define_class_under(rb_cPCPEasy, "ConnLimitError", pcpeasy_error);
+    pcpeasy_again_error = rb_define_class_under(rb_cPCPEasy, "AgainError", pcpeasy_error);
+    pcpeasy_is_conn_error = rb_define_class_under(rb_cPCPEasy, "IsConnError", pcpeasy_error);
+    pcpeasy_not_conn_error = rb_define_class_under(rb_cPCPEasy, "NotConnError", pcpeasy_error);
+    pcpeasy_need_port_error = rb_define_class_under(rb_cPCPEasy, "NeedPortError", pcpeasy_error);
+    pcpeasy_non_leaf_error = rb_define_class_under(rb_cPCPEasy, "NonLeafError", pcpeasy_error);
+    pcpeasy_type_error = rb_define_class_under(rb_cPCPEasy, "TypeError", pcpeasy_error);
+    pcpeasy_thread_error = rb_define_class_under(rb_cPCPEasy, "ThreadError", pcpeasy_error);
+    pcpeasy_no_container_error = rb_define_class_under(rb_cPCPEasy, "NoContainerError", pcpeasy_error);
+    pcpeasy_bad_store_error = rb_define_class_under(rb_cPCPEasy, "BadStoreError", pcpeasy_error);
+    pcpeasy_too_small_error = rb_define_class_under(rb_cPCPEasy, "TooSmallError", pcpeasy_error);
+    pcpeasy_too_big_error = rb_define_class_under(rb_cPCPEasy, "TooBigError", pcpeasy_error);
+    pcpeasy_fault_error = rb_define_class_under(rb_cPCPEasy, "FaultError", pcpeasy_error);
+    pcpeasy_pmda_ready_error = rb_define_class_under(rb_cPCPEasy, "PMDAReadyError", pcpeasy_error);
+    pcpeasy_pmda_not_ready_error = rb_define_class_under(rb_cPCPEasy, "PMDANotReadyError", pcpeasy_error);
+    pcpeasy_nyi_error = rb_define_class_under(rb_cPCPEasy, "NYIError", pcpeasy_error);
 }

data/ext/pcp_easy/exceptions.h

@@ -21,7 +21,7 @@
 
 #include <ruby.h>
 extern VALUE pcpeasy_error;
-void pcpeasy_exceptions_init(VALUE pcpeasy_class);
+void pcpeasy_exceptions_init(VALUE rb_cPCPEasy);
 void pcpeasy_raise_from_pmapi_error(int error_number);
 
 #endif

data/ext/pcp_easy/metric.c

@@ -20,17 +20,17 @@
 #include <pcp/pmapi.h>
 
 #include "exceptions.h"
+#include "metric_value.h"
 
 #define READ_ONLY 1, 0
-#define CONSTRUCTOR_ARGS 6
+#define CONSTRUCTOR_ARGS 5
 #define rb_symbol_new(name) ID2SYM(rb_intern(name))
 
 VALUE pcpeasy_metric_class;
 
-static VALUE initialize(VALUE self, VALUE name, VALUE value, VALUE instance, VALUE semantics, VALUE type, VALUE units) {
+static VALUE initialize(VALUE self, VALUE name, VALUE values, VALUE semantics, VALUE type, VALUE units) {
     rb_iv_set(self, "@name", name);
-    rb_iv_set(self, "@value", value);
-    rb_iv_set(self, "@instance", instance);
+    rb_iv_set(self, "@values", values);
     rb_iv_set(self, "@semantics", semantics);
     rb_iv_set(self, "@type", type);
     rb_iv_set(self, "@units", units);
@@ -51,41 +51,6 @@ static VALUE semantics_symbol(int semantics) {
     }
 }
 
-static VALUE instance_name(char *instance) {
-    if(instance == NULL) {
-        return Qnil;
-    }
-    return rb_tainted_str_new_cstr(instance);
-}
-
-static VALUE value(int value_format, pmValue *pm_value, int type) {
-    pmAtomValue pm_atom_value;
-    int error;
-
-    if((error = pmExtractValue(value_format, pm_value, type, &pm_atom_value, type)) < 0) {
-        pcpeasy_raise_from_pmapi_error(error);
-    }
-
-    switch(type) {
-        case PM_TYPE_32:
-            return LONG2NUM(pm_atom_value.l);
-        case PM_TYPE_U32:
-            return ULONG2NUM(pm_atom_value.ul);
-        case PM_TYPE_64:
-            return LL2NUM(pm_atom_value.ll);
-        case PM_TYPE_U64:
-            return ULL2NUM(pm_atom_value.ull);
-        case PM_TYPE_FLOAT:
-            return DBL2NUM(pm_atom_value.f);
-        case PM_TYPE_DOUBLE:
-            return DBL2NUM(pm_atom_value.d);
-        case PM_TYPE_STRING:
-            return rb_tainted_str_new_cstr(pm_atom_value.vbp->vbuf);
-        default:
-            rb_raise(pcpeasy_error, "Metric type %d not supported", type);
-    }
-}
-
 static int is_field_equal(const char *name, VALUE self, VALUE other) {
     return TYPE(rb_funcall(rb_iv_get(self, name), rb_intern("=="), 1, rb_iv_get(other, name))) == T_TRUE;
 }
@@ -95,9 +60,7 @@ static VALUE equal(VALUE self, VALUE other) {
         return Qfalse;
     if(!is_field_equal("@name", self, other))
         return Qfalse;
-    if(!is_field_equal("@value", self, other))
-        return Qfalse;
-    if(!is_field_equal("@instance", self, other))
+    if(!is_field_equal("@values", self, other))
         return Qfalse;
     if(!is_field_equal("@semantics", self, other))
         return Qfalse;
@@ -230,26 +193,80 @@ static VALUE units(pmUnits pm_units) {
     return units;
 }
 
-VALUE pcpeasy_metric_new(char *metric_name, char *instance, pmValue *pm_value, pmDesc *pm_desc, int value_format) {
+
+static char* get_name_from_instance_id(int instance_id, int maximum_instances, int *instance_ids, char **instance_names) {
+    int i;
+    for(i=0; i<maximum_instances; i++) {
+        if(instance_id == instance_ids[i]) {
+            return instance_names[i];
+        }
+    }
+    return NULL;
+}
+
+static VALUE build_metric_values_for_multiple_instances(pmValueSet *pm_value_set, pmDesc pm_desc) {
+    int error, i;
+    int number_of_instances = pm_value_set->numval;
+    int *instances = NULL;
+    char **instance_names = NULL;
+    VALUE result = rb_ary_new2(number_of_instances);
+
+
+    if((error = pmGetInDom(pm_desc.indom, &instances, &instance_names)) < 0) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
+    for(i = 0; i < number_of_instances; i++) {
+        char *instance_name = get_name_from_instance_id(pm_value_set->vlist[i].inst, number_of_instances, instances, instance_names);
+        rb_ary_push(result, pcpeasy_metric_value_new(instance_name, pm_value_set->valfmt, &pm_value_set->vlist[i], pm_desc.type));
+    }
+
+    free(instances);
+    free(instance_names);
+
+    return result;
+}
+
+static VALUE build_metrics_values(pmValueSet *pm_value_set, pmDesc pm_desc) {
+    VALUE result = rb_ary_new2(pm_value_set->numval);
+
+    if(pm_value_set->numval > 0) {
+        if (pm_desc.indom != PM_INDOM_NULL) {
+            rb_ary_concat(result, build_metric_values_for_multiple_instances(pm_value_set, pm_desc));
+        } else {
+            return rb_ary_push(result, pcpeasy_metric_value_new(NULL, pm_value_set->valfmt, &pm_value_set->vlist[0], pm_desc.type));
+        }
+    }
+    return result;
+}
+
+VALUE pcpeasy_metric_new(char *metric_name, pmValueSet *pm_value_set) {
     VALUE args[CONSTRUCTOR_ARGS];
+    int error;
+    pmDesc pm_desc;
+
+    /* Find out how to decode the metric */
+    if((error = pmLookupDesc(pm_value_set->pmid, &pm_desc))) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
     args[0] = rb_tainted_str_new_cstr(metric_name);
-    args[1] = value(value_format, pm_value, pm_desc->type);
-    args[2] = instance_name(instance);
-    args[3] = semantics_symbol(pm_desc->sem);
-    args[4] = type(pm_desc->type);
-    args[5] = units(pm_desc->units);
+    args[1] = build_metrics_values(pm_value_set, pm_desc);
+    args[2] = semantics_symbol(pm_desc.sem);
+    args[3] = type(pm_desc.type);
+    args[4] = units(pm_desc.units);
 
     return rb_class_new_instance(CONSTRUCTOR_ARGS, args, pcpeasy_metric_class);
 }
 
-void pcpeasy_metric_init(VALUE pcpeasy_class) {
-    pcpeasy_metric_class = rb_define_class_under(pcpeasy_class, "Metric", rb_cObject);
+void pcpeasy_metric_init(VALUE rb_cPCPEasy) {
+    pcpeasy_metric_class = rb_define_class_under(rb_cPCPEasy, "Metric", rb_cObject);
+    pcpeasy_metric_value_init(pcpeasy_metric_class);
 
     rb_define_method(pcpeasy_metric_class, "initialize", initialize, CONSTRUCTOR_ARGS);
     rb_define_method(pcpeasy_metric_class, "==", equal, 1);
     rb_define_attr(pcpeasy_metric_class, "name", READ_ONLY);
-    rb_define_attr(pcpeasy_metric_class, "value", READ_ONLY);
-    rb_define_attr(pcpeasy_metric_class, "instance", READ_ONLY);
+    rb_define_attr(pcpeasy_metric_class, "values", READ_ONLY);
     rb_define_attr(pcpeasy_metric_class, "semantics", READ_ONLY);
     rb_define_attr(pcpeasy_metric_class, "type", READ_ONLY);
     rb_define_attr(pcpeasy_metric_class, "units", READ_ONLY);

data/ext/pcp_easy/metric.h

@@ -22,7 +22,7 @@
 #include <ruby.h>
 #include <pcp/pmapi.h>
 
-void pcpeasy_metric_init(VALUE pcpeasy_class);
-VALUE pcpeasy_metric_new(char *metric_name, char *instance, pmValue *pm_value, pmDesc *pm_desc, int value_format);
+void pcpeasy_metric_init(VALUE rb_cPCPEasy);
+VALUE pcpeasy_metric_new(char *metric_name, pmValueSet *pm_value_set);
 
 #endif

data/ext/pcp_easy/metric_value.c

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <ruby.h>
+#include <pcp/pmapi.h>
+#include "exceptions.h"
+
+#define CONSTRUCTOR_ARGS 2
+#define READ_ONLY 1, 0
+
+
+VALUE easy_metric_value_class;
+
+
+static VALUE instance_name(char *instance) {
+    if(instance == NULL) {
+        return Qnil;
+    }
+    return rb_tainted_str_new_cstr(instance);
+}
+
+static VALUE value(int value_format, pmValue *pm_value, int type) {
+    pmAtomValue pm_atom_value;
+    int error;
+
+    if((error = pmExtractValue(value_format, pm_value, type, &pm_atom_value, type)) < 0) {
+        pcpeasy_raise_from_pmapi_error(error);
+    }
+
+    switch(type) {
+        case PM_TYPE_32:
+            return LONG2NUM(pm_atom_value.l);
+        case PM_TYPE_U32:
+            return ULONG2NUM(pm_atom_value.ul);
+        case PM_TYPE_64:
+            return LL2NUM(pm_atom_value.ll);
+        case PM_TYPE_U64:
+            return ULL2NUM(pm_atom_value.ull);
+        case PM_TYPE_FLOAT:
+            return DBL2NUM(pm_atom_value.f);
+        case PM_TYPE_DOUBLE:
+            return DBL2NUM(pm_atom_value.d);
+        case PM_TYPE_STRING:
+            return rb_tainted_str_new_cstr(pm_atom_value.vbp->vbuf);
+        default:
+            rb_raise(pcpeasy_error, "Metric type %d not supported", type);
+    }
+}
+
+static int is_field_equal(const char *name, VALUE self, VALUE other) {
+    return TYPE(rb_funcall(rb_iv_get(self, name), rb_intern("=="), 1, rb_iv_get(other, name))) == T_TRUE;
+}
+
+static VALUE initialize(VALUE self, VALUE value, VALUE instance) {
+    rb_iv_set(self, "@value", value);
+    rb_iv_set(self, "@instance", instance);
+
+    return self;
+}
+
+static VALUE equal(VALUE self, VALUE other) {
+    if(rb_class_of(other) != easy_metric_value_class)
+        return Qfalse;
+    if(!is_field_equal("@value", self, other))
+        return Qfalse;
+    if(!is_field_equal("@instance", self, other))
+        return Qfalse;
+
+    return Qtrue;
+}
+
+VALUE pcpeasy_metric_value_new(char *instance, int value_format, pmValue *pm_value, int type) {
+    VALUE args[CONSTRUCTOR_ARGS];
+    args[0] = value(value_format, pm_value, type);
+    args[1] = instance_name(instance);
+
+    return rb_class_new_instance(CONSTRUCTOR_ARGS, args, easy_metric_value_class);
+}
+
+void pcpeasy_metric_value_init(VALUE rb_cPCPEasyMetric) {
+    easy_metric_value_class = rb_define_class_under(rb_cPCPEasyMetric, "Value", rb_cObject);
+
+    rb_define_method(easy_metric_value_class, "initialize", initialize, CONSTRUCTOR_ARGS);
+    rb_define_method(easy_metric_value_class, "==", equal, 1);
+    rb_define_attr(easy_metric_value_class, "value", READ_ONLY);
+    rb_define_attr(easy_metric_value_class, "instance", READ_ONLY);
+}

data/ext/pcp_easy/metric_value.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2016 Ryan Doyle
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PCPEZ_RUBY_METRIC_VALUE_H
+#define PCPEZ_RUBY_METRIC_VALUE_H 1
+
+#include <ruby.h>
+#include <pcp/pmapi.h>
+
+VALUE pcpeasy_metric_value_new(char *instance_name, int value_format, pmValue *pm_value, int type);
+void pcpeasy_metric_value_init(VALUE rb_cPCPEasyMetric);
+
+#endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pcp_easy
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ryan Doyle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-31 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: 
 executables: []
@@ -52,6 +66,8 @@ files:
 - ext/pcp_easy/extconf.rb
 - ext/pcp_easy/metric.c
 - ext/pcp_easy/metric.h
+- ext/pcp_easy/metric_value.c
+- ext/pcp_easy/metric_value.h
 - ext/pcp_easy/pcp_easy.c
 homepage: 
 licenses: []
@@ -77,3 +93,4 @@ signing_key:
 specification_version: 4
 summary: Simple query interface for Performance Co-Pilot
 test_files: []
+has_rdoc: