[collectd] Making monitoring of heterogeneous environments easier with percentage based metrics

[Yves Mettier]

Hello,

I like better the function with variable arguments, with NULL as the 
last arg.

Yes, it makes it a bit error prone. But what do you think of this ?

printf("Error %d");



Here is an error someone can easily do :

Step 1 : write the code
    char const *names[] = { "free", "cached", "buffered" };
    gauge_t values[] = { NAN, NAN, NAN };
    [...]

Step 2 : repair your mistake (add the missing "used" item)
    char const *names[] = { "free", "cached", "buffered" };
    gauge_t values[] = { NAN, NAN, NAN };
    [...]

Ooops, I forgot to add an item to values[]



Another one, with the variable argument function, with a given number of 
args (3rd argument of plugin_dispatch_list() ):

Step 1 : write the code
     plugin_dispatch_list (vl, 1, 3, "free", 100.0, "cached", 200.0,
        "buffered", 300.0);

Step 2 : repair your mistake (add the missing "used" item)
     plugin_dispatch_list (vl, 1, 3, "free", 100.0, "cached", 200.0,
        "buffered", 300.0, "used", 1000.0);

Ooops, I forgot to set 4 as the 3rd argument


As you see, anyone can make errors...
So I prefer your version with variable arguments and NULL at the end : 
it's easier to write and update.

It's only my opinion.

Happy new year !

Yves

---
- Homepage       - http://ymettier.free.fr                             -
- GPG key        - http://ymettier.free.fr/gpg.txt                     -
- C en action    - http://ymettier.free.fr/livres/C_en_action_ed2.html -
- Guide Survie C - http://www.pearson.fr/livre/?GCOI=27440100673730    -

Le 2014-01-13 10:50, Florian Forster a écrit :
> Hi Jeremy,
> 
> On Tue, Jan 07, 2014 at 07:47:25PM -0500, Jeremy Katz wrote:
>> In larger environments which have heterogeneous resources it's 
>> frequently
>> useful to look at utilization of various resources as percentages.
>> […]
>> But all of these end up having a ton of repetition.
> 
> I agree that the amount of repetition is bad and some infrastructure to
> simplify these calculations would be nice. I would, however, prefer not
> to make this a truly global option.
> 
> What do you think about an interface like this:
> 
>   /* Takes a list of type instances and values and dispatches that in a
>    * batch, making sure that all values have the same time stamp. If
>    * "percentage" is set to true, "type" is set to "percent" and a
>    * percentage is calculated and dispatched, rather than the absolute
>    * values. Values that are NaN are dispatched as NaN and will not
>    * influence the total. Returns the number of values it failed to
>    * dispatch.
>    */
>   int plugin_dispatch_set (value_list_t const *vl,
>       size_t          argc,
>       char const    **type_instances,
>       gauge_t const  *values,
>       _Bool           percentage);
> 
> It would then still be up to the plugin to use this new interface, but
> the changes required to each plugin would be much simpler, for example:
> 
>   char const *names[] = { "free", "cached", "buffered", "used" };
>   gauge_t values[] = { NAN, NAN, NAN, NAN };
>   value_list_t vl = VALUE_LIST_INIT;
>   /* Init "values" and "vl". */
>   plugin_dispatch_set (vl, STATIC_ARRAY_SIZE (names), names, values, 
> 1);
> 
> Alternatively, I could picture a function with variable arguments,
> that's used like this:
> 
>   __attribute__((sentinel))
>   int plugin_dispatch_list (value_list_t const *vl,
>       _Bool percentage, ...);
>   plugin_dispatch_list (vl, 1, "free", 100.0, "cached", 200.0,
>       "buffered", 300.0, "used", 1000.0, NULL);
> 
> This might be a bit easier to write, but makes it a bit error prone,
> e.g. when someone forgets to add the NULL pointer (the "sentinel"
> attribute should catch this on GCC). An alternative would be to pass in
> the number of values, but that can't be checked during compile time
> either.
> 
> Best regards,
> —octo
> _______________________________________________
> collectd mailing list
> collectd at verplant.org
> http://mailman.verplant.org/listinfo/collectd