Add cgroups_cpuacct plugin to collect CPU user/system time per cgroup

This is handy for computers using systemd, as systemd puts each service
into a separate cgroup.

Signed-off-by: Florian Forster <octo@collectd.org>

diff --git a/configure.in b/configure.in
index 144f2897267a788700a4c67100afba6699e4c3e9..7a25a0d323d9b06f814312cc929d9d457a6e6b58 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -4956,6 +4956,7 @@ AC_PLUGIN([csv],         [yes],                [CSV output plugin])
 AC_PLUGIN([curl],        [$with_libcurl],      [CURL generic web statistics])
 AC_PLUGIN([curl_json],   [$plugin_curl_json],    [CouchDB statistics])
 AC_PLUGIN([curl_xml],   [$plugin_curl_xml],    [CURL generic xml statistics])
+AC_PLUGIN([cgroups_cpuacct], [yes],            [CGroups CPU usage accounting])
 AC_PLUGIN([dbi],         [$with_libdbi],       [General database statistics])
 AC_PLUGIN([df],          [$plugin_df],         [Filesystem usage statistics])
 AC_PLUGIN([disk],        [$plugin_disk],       [Disk usage statistics])
@@ -5286,6 +5287,7 @@ Configuration:
     bind  . . . . . . . . $enable_bind
     conntrack . . . . . . $enable_conntrack
     contextswitch . . . . $enable_contextswitch
+    cgroups_cpuacct . . . $enable_cgroups_cpuacct
     cpu . . . . . . . . . $enable_cpu
     cpufreq . . . . . . . $enable_cpufreq
     csv . . . . . . . . . $enable_csv

diff --git a/src/Makefile.am b/src/Makefile.am
index e9698882fb25e6841c520196344c688cbb3c28c7..494b343b2718f3f146d685c1bc2528eca63c5571 100644 (file)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -230,6 +230,14 @@ collectd_LDADD += "-dlopen" bind.la
 collectd_DEPENDENCIES += bind.la
 endif
 
+if BUILD_PLUGIN_CGROUPS_CPUACCT
+pkglib_LTLIBRARIES += cgroups_cpuacct.la
+cgroups_cpuacct_la_SOURCES = cgroups_cpuacct.c utils_mount.c utils_mount.h
+cgroups_cpuacct_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" cgroups_cpuacct.la
+collectd_DEPENDENCIES += cgroups_cpuacct.la
+endif
+
 if BUILD_PLUGIN_CONNTRACK
 pkglib_LTLIBRARIES += conntrack.la
 conntrack_la_SOURCES = conntrack.c

diff --git a/src/cgroups_cpuacct.c b/src/cgroups_cpuacct.c
new file mode 100644 (file)
index 0000000..d20ff4b
--- /dev/null
+++ b/src/cgroups_cpuacct.c
@@ -0,0 +1,229 @@
+/**
+ * collectd - src/cgroups_cpuacct.c
+ * Copyright (C) 2011  Michael Stapelberg
+ *
+ * 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; only version 2 of the license is applicable.
+ *
+ * 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, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * Authors:
+ *   Michael Stapelberg <michael at stapelberg.de>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "configfile.h"
+#include "utils_mount.h"
+#include "utils_ignorelist.h"
+
+static const char *config_keys[] =
+{
+       "CGroup",
+       "IgnoreSelected"
+};
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+
+static ignorelist_t *il_cgroup = NULL;
+
+__attribute__ ((nonnull(1)))
+__attribute__ ((nonnull(2)))
+static void cgroups_submit_one (const char *plugin_instance,
+               const char *type, const char *type_instance,
+               derive_t value)
+{
+       value_t values[1];
+       value_list_t vl = VALUE_LIST_INIT;
+
+       values[0].derive = value;
+
+       vl.values = values;
+       vl.values_len = 1;
+       sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+       sstrncpy (vl.plugin, "cgroups_cpuacct", sizeof (vl.plugin));
+       sstrncpy (vl.plugin_instance, plugin_instance,
+               sizeof (vl.plugin_instance));
+       sstrncpy (vl.type, type, sizeof (vl.type));
+       if (type_instance != NULL)
+               sstrncpy (vl.type_instance, type_instance,
+                               sizeof (vl.type_instance));
+
+       plugin_dispatch_values (&vl);
+} /* void cgroups_submit_one */
+
+
+/*
+ * This callback reads the user/system CPU time for each cgroup.
+ *
+ */
+static int read_cpuacct_procs (const char *dirname, const char *filename,
+    void *user_data)
+{
+       char abs_path[PATH_MAX];
+       struct stat statbuf;
+       char buf[1024];
+       int status;
+
+       if (ignorelist_match (il_cgroup, filename))
+               return (0);
+
+       ssnprintf (abs_path, sizeof (abs_path), "%s/%s", dirname, filename);
+
+       status = lstat (abs_path, &statbuf);
+       if (status != 0)
+       {
+               ERROR ("cgroups_cpuacct plugin: stat (%s) failed.", abs_path);
+               return (-1);
+       }
+
+       /* We are only interested in directories, so skip everything else. */
+       if (!S_ISDIR (statbuf.st_mode))
+       {
+               return (0);
+       }
+
+       ssnprintf (abs_path, sizeof (abs_path), "%s/%s/cpuacct.stat", dirname, filename);
+       int bytes_read;
+       if ((bytes_read = read_file_contents (abs_path, buf, sizeof(buf))) <= 0)
+       {
+               char errbuf[1024];
+               ERROR ("cgroups_cpuacct plugin: read_file_contents(%s): %s",
+                               abs_path, sstrerror (errno, errbuf, sizeof (errbuf)));
+               return (-1);
+       }
+       buf[bytes_read] = '\0';
+
+       char *fields[4];
+       int numfields = 0;
+       if ((numfields = strsplit (buf, fields, 4)) != 4)
+       {
+               ERROR ("cgroups_cpuacct plugin: unexpected content in file %s", abs_path);
+               return (-1);
+       }
+       uint64_t usertime, systemtime;
+       usertime = atoll (fields[1]);
+       systemtime = atoll (fields[3]);
+
+       cgroups_submit_one(filename, "cpuacct", "user", (derive_t)usertime);
+       cgroups_submit_one(filename, "cpuacct", "system", (derive_t)systemtime);
+
+       return (0);
+}
+
+/*
+ * Gets called for every file/folder in /sys/fs/cgroup/cpu,cpuacct (or
+ * whereever cpuacct is mounted on the system). Calls walk_directory with the
+ * read_cpuacct_procs callback on every folder it finds, such as "system".
+ *
+ */
+static int read_cpuacct_root (const char *dirname, const char *filename,
+    void *user_data)
+{
+  char abs_path[PATH_MAX];
+  struct stat statbuf;
+  int status;
+
+  ssnprintf (abs_path, sizeof (abs_path), "%s/%s", dirname, filename);
+
+  status = lstat (abs_path, &statbuf);
+  if (status != 0)
+  {
+    ERROR ("cgroups_cpuacct plugin: stat (%s) failed.", abs_path);
+    return (-1);
+  }
+
+  if (S_ISDIR (statbuf.st_mode))
+  {
+    status = walk_directory (abs_path, read_cpuacct_procs, NULL, 0);
+    return (status);
+  }
+
+  return (0);
+}
+
+static int cgroups_init (void)
+{
+       if (il_cgroup == NULL)
+               il_cgroup = ignorelist_create (1);
+
+       return (0);
+}
+
+static int cgroups_config (const char *key, const char *value)
+{
+       cgroups_init ();
+
+       if (strcasecmp (key, "CGroup") == 0)
+       {
+               if (ignorelist_add (il_cgroup, value))
+                       return (1);
+               return (0);
+       }
+       else if (strcasecmp (key, "IgnoreSelected") == 0)
+       {
+               if (IS_TRUE (value))
+               {
+                       ignorelist_set_invert (il_cgroup, 0);
+               }
+               else
+               {
+                       ignorelist_set_invert (il_cgroup, 1);
+               }
+               return (0);
+       }
+
+       return (-1);
+}
+
+static int cgroups_read (void)
+{
+       cu_mount_t *mnt_list;
+       cu_mount_t *mnt_ptr;
+       int cgroup_found = 0;
+
+       mnt_list = NULL;
+       if (cu_mount_getlist (&mnt_list) == NULL)
+       {
+               ERROR ("cgroups_cpuacct plugin: cu_mount_getlist failed.");
+               return (-1);
+       }
+
+       for (mnt_ptr = mnt_list; mnt_ptr != NULL; mnt_ptr = mnt_ptr->next)
+       {
+               /* Find the cgroup mountpoint which contains the cpuacct
+                * controller. */
+               if (strcmp(mnt_ptr->type, "cgroup") != 0 ||
+                       !cu_mount_getoptionvalue(mnt_ptr->options, "cpuacct"))
+                       continue;
+
+               walk_directory (mnt_ptr->dir, read_cpuacct_root, NULL, 0);
+               cgroup_found = 1;
+               /* It doesn't make sense to check other cpuacct mount-points
+                * (if any), they contain the same data. */
+               break;
+       }
+
+       if (!cgroup_found)
+               WARNING ("cpuacct mountpoint not found. Cannot collect any data.");
+
+       cu_mount_freelist (mnt_list);
+
+       return (0);
+} /* int cgroup_read */
+
+void module_register (void)
+{
+       plugin_register_config ("cgroups_cpuacct", cgroups_config,
+                       config_keys, config_keys_num);
+       plugin_register_init ("cgroups_cpuacct", cgroups_init);
+       plugin_register_read ("cgroups_cpuacct", cgroups_read);
+} /* void module_register */

diff --git a/src/collectd.conf.in b/src/collectd.conf.in
index e95fae6a613799b6c72ac758e9502a3bcdc77955..736c97414cf350eba38ecf8abab5d0e1c35eee1c 100644 (file)
--- a/src/collectd.conf.in
+++ b/src/collectd.conf.in
@@ -72,6 +72,7 @@
 #@BUILD_PLUGIN_BIND_TRUE@LoadPlugin bind
 #@BUILD_PLUGIN_CONNTRACK_TRUE@LoadPlugin conntrack
 #@BUILD_PLUGIN_CONTEXTSWITCH_TRUE@LoadPlugin contextswitch
+#@BUILD_PLUGIN_CGROUPS_CPUACCT_TRUE@LoadPlugin cgroups_cpuacct
 @BUILD_PLUGIN_CPU_TRUE@@BUILD_PLUGIN_CPU_TRUE@LoadPlugin cpu
 #@BUILD_PLUGIN_CPUFREQ_TRUE@LoadPlugin cpufreq
 @LOAD_PLUGIN_CSV@LoadPlugin csv

diff --git a/src/collectd.conf.pod b/src/collectd.conf.pod
index 8606d3e05533ff123f606e30ea7ef1f514c8857b..a4542a029e2200185f55e0623f2e299ada83065e 100644 (file)
--- a/src/collectd.conf.pod
+++ b/src/collectd.conf.pod
@@ -852,6 +852,27 @@ By default no detailed zone information is collected.
 
 =back
 
+=head2 Plugin C<cgroups_cpuacct>
+
+This plugin collects the CPU user/system time for each cgroup by reading the
+cpuacct.stat files in the first cpuacct-mountpoint (typically
+F</sys/fs/cgroup/cpu,cpuacct> on machines using systemd).
+
+=over 4
+
+=item B<CGroup> I<Directory>
+
+Select cgroup based on the name.
+
+=item B<IgnoreSelected> B<true>|B<false>
+
+Invert the selection: If set to true, all cgroups B<except> the ones that
+match any one of the criteria are collected. By default only selected
+cgroups are collected if a selection is made. If no selection is configured
+at all, B<all> cgroups are selected.
+
+=back
+
 =head2 Plugin C<cpufreq>
 
 This plugin doesn't have any options. It reads

diff --git a/src/types.db b/src/types.db
index 6f1eaf6139d0d74f079d8e7093a9a0013eeadc9f..679554e8adb0ced8873ac0a682003f80ccf3ba31 100644 (file)
--- a/src/types.db
+++ b/src/types.db
@@ -22,6 +22,7 @@ contextswitch         value:DERIVE:0:U
 counter                        value:COUNTER:U:U
 cpufreq                        value:GAUGE:0:U
 cpu                    value:DERIVE:0:U
+cpuacct                        value:DERIVE:0:U
 current_connections    value:GAUGE:0:U
 current_sessions       value:GAUGE:0:U
 current                        value:GAUGE:U:U