added node.js plugin manager, implemented bind (named) 9.10+ JSON plugin, refactored sma_webbox for the new node.js manager

6 files changed, 1340 insertions, 0 deletions

diff --git a/node.d/Makefile.am b/node.d/Makefile.am
new file mode 100644
index 0000000000..3436f73b13
--- /dev/null
+++ b/node.d/Makefile.am
@@ -0,0 +1,12 @@
+MAINTAINERCLEANFILES= $(srcdir)/Makefile.in
+
+dist_node_SCRIPTS = \
+	README.md \
+	named.node.js \
+	$(NULL)
+
+nodemodulesdir=$(nodedir)/node_modules
+dist_nodemodules_DATA = \
+	node_modules/netdata.js \
+	node_modules/extend.js \
+	$(NULL)
diff --git a/node.d/README.md b/node.d/README.md
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/node.d/README.md
diff --git a/node.d/named.node.js b/node.d/named.node.js
new file mode 100755
index 0000000000..82728f4882
--- /dev/null
+++ b/node.d/named.node.js
@@ -0,0 +1,462 @@
+'use strict';

+

+// collect statistics from bind (named) v9.10+

+//

+// bind statistics documentation at:

+// https://ftp.isc.org/isc/bind/9.10.3/doc/arm/Bv9ARM.ch06.html#statistics

+

+// example configuration in /etc/netdata/named.conf

+// the module supports auto-detection if bind is running in localhost

+

+/*

+{

+	"enable_autodetect": true,

+	"update_every": 5,

+	"servers": [

+		{

+			"name": "bind1",

+			"url": "http://127.0.0.1:8888/json/v1",

+			"update_every": 1

+		},

+		{

+			"name": "bind2",

+			"url": "http://10.1.2.3:8888/json/v1",

+			"update_every": 2

+		}

+	]

+}

+*/

+

+// the following is the bind named.conf configuration required

+

+/*

+statistics-channels {

+        inet 127.0.0.1 port 8888 allow { 127.0.0.1; };

+};

+*/

+

+var url = require('url');

+var http = require('http');

+var netdata = require('netdata');

+

+if(netdata.options.DEBUG === true) netdata.debug('loaded ' + __filename + ' plugin');

+

+var named = {

+	name: __filename,

+	enable_autodetect: true,

+	update_every: 1000,

+

+	charts: {},

+

+	chartFromMembersCreate: function(service, obj, id, title_suffix, units, family_prefix, category_prefix, type, priority, algorithm, multiplier, divisor) {

+		var chart = {

+			id: id,											// the unique id of the chart

+			name: '',										// the unique name of the chart

+			title: service.name + ' ' + title_suffix,		// the title of the chart

+			units: units,									// the units of the chart dimensions

+			family: family_prefix + '_' + service.name,		// the family of the chart

+			category: category_prefix + '_' + service.name,	// the category of the chart

+			type: type,										// the type of the chart

+			priority: priority,								// the priority relative to others in the same family and category

+			update_every: Math.round(service.update_every / 1000), // the expected update frequency of the chart

+			dimensions: {}

+		}

+

+		var found = 0;

+		for(var x in obj) {

+			if(typeof(obj[x]) !== 'undefined' && obj[x] !== 0) {

+				found++;

+				chart.dimensions[x] = {

+					id: x,					// the unique id of the dimension

+					name: x,				// the name of the dimension

+					algorithm: algorithm,	// the id of the netdata algorithm

+					multiplier: multiplier,	// the multiplier

+					divisor: divisor,		// the divisor

+					hidden: false			// is hidden (boolean)

+				}

+			}

+		}

+

+		if(found === false)

+			return null;

+

+		chart = service.chart(id, chart);

+		this.charts[id] = chart;

+		return chart;

+	},

+

+	chartFromMembers: function(service, obj, id_suffix, title_suffix, units, family_prefix, category_prefix, type, priority, algorithm, multiplier, divisor) {

+		var id = 'named_' + service.name + '.' + id_suffix;

+		var chart = this.charts[id];

+

+		if(typeof chart === 'undefined') {

+			chart = this.chartFromMembersCreate(service, obj, id, title_suffix, units, family_prefix, category_prefix, type, priority, algorithm, multiplier, divisor);

+			if(chart === null) return false;

+		}

+		else {

+			// check if we need to re-generate the chart

+			for(var x in obj) {

+				if(typeof(chart.dimensions[x]) === 'undefined') {

+					chart = this.chartFromMembersCreate(service, obj, id, title_suffix, units, family_prefix, category_prefix, type, priority, algorithm, multiplier, divisor);

+					if(chart === null) return false;

+					break;

+				}

+			}

+		}

+

+		var found = 0;

+		service.begin(chart);

+		for(var x in obj) {

+			if(typeof(chart.dimensions[x]) !== 'undefined') {

+				found++;

+				service.set(x, obj[x]);

+			}

+		}

+		service.end();

+

+		if(found > 0) return true;

+		return false;

+	},

+

+	// an index to map values to different charts

+	lookups: {

+		nsstats: {},

+		resolver_stats: {},

+		numfetch: {}

+	},

+

+	processResponse: function(service, data) {

+		if(data !== null) {

+			var r = JSON.parse(data);

+

+			if(service.added !== true)

+				netdata.serviceAdd(service);

+

+			if(typeof r.nsstats !== 'undefined') {

+				// we split the nsstats object to several others

+				var global_requests = {}, global_requests_enable = false;

+				var global_failures = {}, global_failures_enable = false;

+				var global_failures_detail = {}, global_failures_detail_enable = false;

+				var global_updates = {}, global_updates_enable = false;

+				var protocol_queries = {}, protocol_queries_enable = false;

+				var global_queries = {}, global_queries_enable = false;

+				var global_queries_success = {}, global_queries_success_enable = false;

+				var default_enable = false;

+				var RecursClients = 0;

+

+				// RecursClients is an absolute value

+				if(typeof r.nsstats['RecursClients'] !== 'undefined') {

+					RecursClients = r.nsstats['RecursClients'];

+					delete r.nsstats['RecursClients'];

+				}

+

+				for( var x in r.nsstats ) {

+					// we maintain an index of the values found

+					// mapping them to objects splitted

+

+					var look = named.lookups.nsstats[x];

+					if(typeof look === 'undefined') {

+						// a new value, not found in the index

+						// index it:

+						if(x === 'Requestv4') {

+							named.lookups.nsstats[x] = {

+								name: 'IPv4',

+								type: 'global_requests'

+							};

+						}

+						else if(x === 'Requestv6') {

+							named.lookups.nsstats[x] = {

+								name: 'IPv6',

+								type: 'global_requests'

+							};

+						}

+						else if(x === 'QryFailure') {

+							named.lookups.nsstats[x] = {

+								name: 'failures',

+								type: 'global_failures'

+							};

+						}

+						else if(x === 'QryUDP') {

+							named.lookups.nsstats[x] = {

+								name: 'UDP',

+								type: 'protocol_queries'

+							};

+						}

+						else if(x === 'QryTCP') {

+							named.lookups.nsstats[x] = {

+								name: 'TCP',

+								type: 'protocol_queries'

+							};

+						}

+						else if(x === 'QrySuccess') {

+							named.lookups.nsstats[x] = {

+								name: 'queries',

+								type: 'global_queries_success'

+							};

+						}

+						else if(x.match(/QryRej$/) !== null) {

+							named.lookups.nsstats[x] = {

+								name: x,

+								type: 'global_failures_detail'

+							};

+						}

+						else if(x.match(/^Qry/) !== null) {

+							named.lookups.nsstats[x] = {

+								name: x,

+								type: 'global_queries'

+							};

+						}

+						else if(x.match(/^Update/) !== null) {

+							named.lookups.nsstats[x] = {

+								name: x,

+								type: 'global_updates'

+							};

+						}

+						else {

+							// values not mapped, will remain

+							// in the default map

+							named.lookups.nsstats[x] = {

+								name: x,

+								type: 'default'

+							};

+						}

+

+						look = named.lookups.nsstats[x];

+						// netdata.error('lookup nsstats value: ' + x + ' >>> ' + named.lookups.nsstats[x].type);

+					}

+

+					switch(look.type) {

+						case 'global_requests': global_requests[look.name] = r.nsstats[x]; delete r.nsstats[x]; global_requests_enable = true; break;

+						case 'global_queries': global_queries[look.name] = r.nsstats[x]; delete r.nsstats[x]; global_queries_enable = true; break;

+						case 'global_queries_success': global_queries_success[look.name] = r.nsstats[x]; delete r.nsstats[x]; global_queries_success_enable = true; break;

+						case 'global_updates': global_updates[look.name] = r.nsstats[x]; delete r.nsstats[x]; global_updates_enable = true; break;

+						case 'protocol_queries': protocol_queries[look.name] = r.nsstats[x]; delete r.nsstats[x]; protocol_queries_enable = true; break;

+						case 'global_failures': global_failures[look.name] = r.nsstats[x]; delete r.nsstats[x]; global_failures_enable = true; break;

+						case 'global_failures_detail': global_failures_detail[look.name] = r.nsstats[x]; delete r.nsstats[x]; global_failures_detail_enable = true; break;

+						default: default_enable = true; break;

+					}

+				}

+

+				if(global_requests_enable == true)

+					service.module.chartFromMembers(service, global_requests, 'received_requests', 'Bind, Global Received Requests by IP version', 'requests/s', 'named', 'named', netdata.chartTypes.stacked, 100, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(global_queries_success_enable == true)

+					service.module.chartFromMembers(service, global_queries_success, 'global_queries_success', 'Bind, Global Successful Queries', 'queries/s', 'named', 'named', netdata.chartTypes.line, 150, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(protocol_queries_enable == true)

+					service.module.chartFromMembers(service, protocol_queries, 'protocols_queries', 'Bind, Global Queries by IP Protocol', 'queries/s', 'named', 'named', netdata.chartTypes.stacked, 200, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(global_queries_enable == true)

+					service.module.chartFromMembers(service, global_queries, 'global_queries', 'Bind, Global Queries Analysis', 'queries/s', 'named', 'named', netdata.chartTypes.stacked, 300, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(global_updates_enable == true)

+					service.module.chartFromMembers(service, global_updates, 'received_updates', 'Bind, Global Received Updates', 'updates/s', 'named', 'named', netdata.chartTypes.stacked, 900, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(global_failures_enable == true)

+					service.module.chartFromMembers(service, global_failures, 'query_failures', 'Bind, Global Query Failures', 'failures/s', 'named', 'named', netdata.chartTypes.line, 950, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(global_failures_detail_enable == true)

+					service.module.chartFromMembers(service, global_failures_detail, 'query_failures_detail', 'Bind, Global Query Failures Analysis', 'failures/s', 'named', 'named', netdata.chartTypes.stacked, 960, netdata.chartAlgorithms.incremental, 1, 1);

+

+				if(default_enable === true)

+					service.module.chartFromMembers(service, r.nsstats, 'nsstats', 'Bind, Other Global Server Statistics', 'operations/s', 'named', 'named', netdata.chartTypes.line, 999, netdata.chartAlgorithms.incremental, 1, 1);

+

+				// RecursClients chart

+				{

+					var id = 'named_' + service.name + '.recursive_clients';

+					var chart = named.charts[id];

+

+					if(typeof chart === 'undefined') {

+						chart = {

+							id: id,											// the unique id of the chart

+							name: '',										// the unique name of the chart

+							title: service.name + ' Bind, Current Recursive Clients',		// the title of the chart

+							units: 'clients',								// the units of the chart dimensions

+							family: 'named',								// the family of the chart

+							category: 'named',								// the category of the chart

+							type: netdata.chartTypes.line,					// the type of the chart

+							priority: 150,									// the priority relative to others in the same family and category

+							update_every: Math.round(service.update_every / 1000), // the expected update frequency of the chart

+							dimensions: {

+								'clients': {

+									id: 'clients',								// the unique id of the dimension

+									name: '',									// the name of the dimension

+									algorithm: netdata.chartAlgorithms.absolute,// the id of the netdata algorithm

+									multiplier: 1,								// the multiplier

+									divisor: 1,									// the divisor

+									hidden: false								// is hidden (boolean)

+								}

+							}

+						};

+

+						chart = service.chart(id, chart);

+						named.charts[id] = chart;

+					}

+

+					service.begin(chart);

+					service.set('clients', RecursClients);

+					service.end();

+				}

+			}

+

+			if(typeof r.opcodes !== 'undefined')

+				service.module.chartFromMembers(service, r.opcodes, 'in_opcodes', 'Bind, Global Incoming Requests by OpCode', 'requests/s', 'named', 'named', netdata.chartTypes.stacked, 1000, netdata.chartAlgorithms.incremental, 1, 1);

+

+			if(typeof r.qtypes !== 'undefined')

+				service.module.chartFromMembers(service, r.qtypes, 'in_qtypes', 'Bind, Global Incoming Requests by Query Type', 'requests/s', 'named', 'named', netdata.chartTypes.stacked, 2000, netdata.chartAlgorithms.incremental, 1, 1);

+

+			if(typeof r.views !== 'undefined') {

+				for( var x in r.views ) {

+					var resolver = r.views[x].resolver;

+

+					if(typeof resolver !== 'undefined') {

+						if(typeof resolver.stats !== 'undefined') {

+							var NumFetch = 0;

+							var key = service.name + '.' + x;

+							var default_enable = false;

+							var rtt = {}, rtt_enable = false;

+

+							// NumFetch is an absolute value

+							if(typeof resolver.stats['NumFetch'] !== 'undefined') {

+								named.lookups.numfetch[key] = true;

+								NumFetch = resolver.stats['NumFetch'];

+								delete resolver.stats['NumFetch'];

+							}

+							if(typeof resolver.stats['BucketSize'] !== 'undefined') {

+								delete resolver.stats['BucketSize'];

+							}

+

+							// split the QryRTT* from the main chart

+							for( var y in resolver.stats ) {

+								// we maintain an index of the values found

+								// mapping them to objects splitted

+

+								var look = named.lookups.resolver_stats[y];

+								if(typeof look === 'undefined') {

+									if(y.match(/^QryRTT/) !== null) {

+										named.lookups.resolver_stats[y] = {

+											name: y,

+											type: 'rtt'

+										};

+									}

+									else {

+										named.lookups.resolver_stats[y] = {

+											name: y,

+											type: 'default'

+										};

+									}

+

+									look = named.lookups.resolver_stats[y];

+									// netdata.error('lookup resolver stats value: ' + y + ' >>> ' + look.type);

+								}

+

+								switch(look.type) {

+									case 'rtt': rtt[look.name] = resolver.stats[y]; delete resolver.stats[y]; rtt_enable = true; break;

+									default: default_enable = true; break;

+								}

+							}

+

+							if(rtt_enable)

+								service.module.chartFromMembers(service, rtt, 'view_resolver_rtt_' + x, 'Bind, ' + x + ' View, Resolver Round Trip Timings', 'queries/s', 'named', 'named', netdata.chartTypes.stacked, 5600, netdata.chartAlgorithms.incremental, 1, 1);

+

+							if(default_enable)

+								service.module.chartFromMembers(service, resolver.stats, 'view_resolver_stats_' + x, 'Bind, ' + x + ' View, Resolver Statistics', 'operations/s', 'named', 'named', netdata.chartTypes.line, 5500, netdata.chartAlgorithms.incremental, 1, 1);

+

+							// NumFetch chart

+							if(typeof named.lookups.numfetch[key] !== 'undefined') {

+								var id = 'named_' + service.name + '.view_resolver_numfetch_' + x;

+								var chart = named.charts[id];

+

+								if(typeof chart === 'undefined') {

+									chart = {

+										id: id,											// the unique id of the chart

+										name: '',										// the unique name of the chart

+										title: service.name + ' Bind, ' + x + ' View, Resolver Active Queries',		// the title of the chart

+										units: 'queries',								// the units of the chart dimensions

+										family: 'named',								// the family of the chart

+										category: 'named',								// the category of the chart

+										type: netdata.chartTypes.line,					// the type of the chart

+										priority: 5000,									// the priority relative to others in the same family and category

+										update_every: Math.round(service.update_every / 1000), // the expected update frequency of the chart

+										dimensions: {

+											'queries': {

+												id: 'queries',								// the unique id of the dimension

+												name: '',									// the name of the dimension

+												algorithm: netdata.chartAlgorithms.absolute,// the id of the netdata algorithm

+												multiplier: 1,								// the multiplier

+												divisor: 1,									// the divisor

+												hidden: false								// is hidden (boolean)

+											}

+										}

+									};

+

+									chart = service.chart(id, chart);

+									named.charts[id] = chart;

+								}

+

+								service.begin(chart);

+								service.set('queries', NumFetch);

+								service.end();

+							}

+						}

+						

+						if(typeof resolver.qtypes !== 'undefined')

+							service.module.chartFromMembers(service, resolver.qtypes, 'view_resolver_qtypes_' + x, 'Bind, ' + x + ' View, Requests by Query Type', 'requests/s', 'named', 'named', netdata.chartTypes.stacked, 6000, netdata.chartAlgorithms.incremental, 1, 1);

+					}

+				}

+			}

+		}

+	},

+

+	// module.serviceExecute()

+	// this function is called only from this module

+	// its purpose is to prepare the request and call

+	// netdata.serviceExecute()

+	serviceExecute: function(name, a_url, update_every) {

+		if(netdata.options.DEBUG === true) netdata.debug(this.name + ': ' + name + ': url: ' + a_url + ', update_every: ' + update_every);

+		netdata.serviceExecute({

+			name: name,

+			request: netdata.requestFromURL(a_url),

+			update_every: update_every,

+			added: false,

+			enabled: true,

+			module: this

+		}, this.processResponse);

+	},

+

+	configure: function(config) {

+		var added = 0;

+

+		if(this.enable_autodetect === true) {

+			this.serviceExecute('local', 'http://localhost:8888/json/v1', this.update_every);

+			added++;

+		}

+		

+		if(typeof(config.servers) !== 'undefined') {

+			var len = config.servers.length;

+			while(len--) {

+				if(typeof config.servers[len].update_every === 'undefined')

+					config.servers[len].update_every = this.update_every;

+				else

+					config.servers[len].update_every = config.servers[len].update_every * 1000;

+

+				this.serviceExecute(config.servers[len].name, config.servers[len].url, config.servers[len].update_every);

+				added++;

+			}

+		}

+

+		return added;

+	},

+

+	// module.update()

+	// this is called repeatidly to collect data, by calling

+	// netdata.serviceExecute()

+	update: function(service, callback) {

+		netdata.serviceExecute(service, function(serv, data) {

+			service.module.processResponse(serv, data);

+			callback();

+		});

+	},

+};

+

+module.exports = named;

diff --git a/node.d/node_modules/extend.js b/node.d/node_modules/extend.js
new file mode 100644
index 0000000000..0fdd8be220
--- /dev/null
+++ b/node.d/node_modules/extend.js
@@ -0,0 +1,87 @@
+// https://github.com/justmoon/node-extend
+
+'use strict';
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var toStr = Object.prototype.toString;
+
+var isArray = function isArray(arr) {
+	if (typeof Array.isArray === 'function') {
+		return Array.isArray(arr);
+	}
+
+	return toStr.call(arr) === '[object Array]';
+};
+
+var isPlainObject = function isPlainObject(obj) {
+	if (!obj || toStr.call(obj) !== '[object Object]') {
+		return false;
+	}
+
+	var hasOwnConstructor = hasOwn.call(obj, 'constructor');
+	var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+	// Not own constructor property must be Object
+	if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+		return false;
+	}
+
+	// Own properties are enumerated firstly, so to speed up,
+	// if last one is own, then all properties are own.
+	var key;
+	for (key in obj) { /**/ }
+
+	return typeof key === 'undefined' || hasOwn.call(obj, key);
+};
+
+module.exports = function extend() {
+	var options, name, src, copy, copyIsArray, clone;
+	var target = arguments[0];
+	var i = 1;
+	var length = arguments.length;
+	var deep = false;
+
+	// Handle a deep copy situation
+	if (typeof target === 'boolean') {
+		deep = target;
+		target = arguments[1] || {};
+		// skip the boolean and the target
+		i = 2;
+	} else if ((typeof target !== 'object' && typeof target !== 'function') || target == null) {
+		target = {};
+	}
+
+	for (; i < length; ++i) {
+		options = arguments[i];
+		// Only deal with non-null/undefined values
+		if (options != null) {
+			// Extend the base object
+			for (name in options) {
+				src = target[name];
+				copy = options[name];
+
+				// Prevent never-ending loop
+				if (target !== copy) {
+					// Recurse if we're merging plain objects or arrays
+					if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
+						if (copyIsArray) {
+							copyIsArray = false;
+							clone = src && isArray(src) ? src : [];
+						} else {
+							clone = src && isPlainObject(src) ? src : {};
+						}
+
+						// Never move original objects, clone them
+						target[name] = extend(deep, clone, copy);
+
+					// Don't bring in undefined values
+					} else if (typeof copy !== 'undefined') {
+						target[name] = copy;
+					}
+				}
+			}
+		}
+	}
+
+	// Return the modified object
+	return target;
+};
diff --git a/node.d/node_modules/netdata.js b/node.d/node_modules/netdata.js
new file mode 100755
index 0000000000..1e594ba0b7
--- /dev/null
+++ b/node.d/node_modules/netdata.js
@@ -0,0 +1,538 @@
+'use strict';

+

+var url = require('url');

+var http = require('http');

+var util = require('util');

+

+/*

+var netdata = require('netdata');

+

+var example_chart = {

+	id: 'id',						// the unique id of the chart

+	name: 'name',					// the name of the chart

+	title: 'title',					// the title of the chart

+	units: 'units',					// the units of the chart dimensions

+	family: 'family',				// the family of the chart

+	category: 'category',			// the category of the chart

+	type: netdata.chartTypes.line,	// the type of the chart

+	priority: 0,					// the priority relative to others in the same family and category

+	update_every: 1,				// the expected update frequency of the chart

+	dimensions: {

+		'dim1': {

+			id: 'dim1',				// the unique id of the dimension

+			name: 'name',			// the name of the dimension

+			algorithm: netdata.chartAlgorithms.absolute,	// the id of the netdata algorithm

+			multiplier: 1,			// the multiplier

+			divisor: 1,				// the divisor

+			hidden: false,			// is hidden (boolean)

+		},

+		'dim2': {

+			id: 'dim2',				// the unique id of the dimension

+			name: 'name',			// the name of the dimension

+			algorithm: 'absolute',	// the id of the netdata algorithm

+			multiplier: 1,			// the multiplier

+			divisor: 1,				// the divisor

+			hidden: false,			// is hidden (boolean)

+		}

+		// add as many dimensions as needed

+	}

+};

+*/

+

+var netdata = {

+	options: {

+		filename: __filename,

+		DEBUG: false,

+		update_every: 1000,

+	},

+

+	chartAlgorithms: {

+		incremental: 'incremental',

+		absolute: 'absolute',

+		percentage_of_absolute_row: 'percentage-of-absolute-row',

+		percentage_of_incremental_row: 'percentage-of-incremental-row'

+	},

+

+	chartTypes: {

+		line: 'line',

+		area: 'area',

+		stacked: 'stacked'

+	},

+

+	services: new Array(),

+	modules_configuring: 0,

+	charts: {},

+

+	stringify: function(obj) {

+		return util.inspect(obj, {depth: 10});

+	},

+

+	// show debug info, if debug is enabled

+	debug: function(msg) {

+		if(this.options.DEBUG === true) {

+			var now = new Date();

+			console.error(now.toString() + ': ' + netdata.options.filename + ': DEBUG: ' + ((typeof(msg) === 'object')?netdata.stringify(msg):msg).toString());

+		}

+	},

+

+	// log an error

+	error: function(msg) {

+		var now = new Date();

+		console.error(now.toString() + ': ' + netdata.options.filename + ': ERROR: ' + ((typeof(msg) === 'object')?netdata.stringify(msg):msg).toString());

+	},

+

+	// send data to netdata

+	send: function(msg) {

+		console.log(msg.toString());

+	},

+

+	serviceAdd: function(service) {

+		if(service.added !== true) {

+			service.updates = 0;

+			service.enabled = true;

+			service.added = true;

+			service.running = false;

+			service.started = 0;

+			service.ended = 0;

+			service._current_chart = null; // the current chart we work on

+			service._queue = '';

+			service.queue = function(txt) {

+				this._queue += txt + '\n';

+			};

+

+			service._send_chart_to_netdata = function(chart) {

+				// internal function to send a chart to netdata

+				this.queue('CHART "' + chart.id + '" "' + chart.name + '" "' + chart.title + '" "' + chart.units + '" "' + chart.family + '" "' + chart.category + '" "' + chart.type + '" ' + chart.priority.toString() + ' ' + chart.update_every.toString());

+				

+				for(var dim in chart.dimensions) {

+					var d = chart.dimensions[dim];

+

+					this.queue('DIMENSION "' + d.id + '" "' + d.name + '" "' + d.algorithm + '" ' + d.multiplier.toString() + ' ' + d.divisor.toString() + ' ' + ((d.hidden === true)?'hidden':'').toString());

+					d._created = true;

+					d._updated = false;

+				}

+

+				chart._created = true;

+				chart._updated = false;

+			};

+

+			// begin data collection for a chart

+			service.begin = function(chart) {

+				if(this._current_chart !== null && this._current_chart !== chart) {

+					netdata.error('Called begin() for chart ' + chart.id + ' while chart ' + this._current_chart.id + ' is still open. Closing it.');

+					this.end();

+				}

+

+				if(typeof(chart.id) === 'undefined' || netdata.charts[chart.id] != chart) {

+					netdata.error('Called begin() for chart ' + chart.id + ' that is not mine. Where did you find it? Ignoring it.');

+					return false;

+				}

+

+				if(netdata.options.DEBUG === true) netdata.debug('setting current chart to ' + chart.id);

+				this._current_chart = chart;

+				this._current_chart._began = true;

+

+				if(this._current_chart._dimensions_count !== 0) {

+					if(this._current_chart._created === false || this._current_chart._updated === true)

+						this._send_chart_to_netdata(this._current_chart);

+

+					var now = this.ended;

+					this.queue('BEGIN ' + this._current_chart.id + ' ' + ((this._current_chart._last_updated > 0)?((now - this._current_chart._last_updated) * 1000):'').toString());

+				}

+				// else netdata.error('Called begin() for chart ' + chart.id + ' which is empty.');

+

+				this._current_chart._last_updated = now;

+				this._current_chart._began = true;

+				this._current_chart._counter++;

+

+				return true;

+			};

+

+			// set a collected value for a chart

+			// we do most things on the first value we attempt to set

+			service.set = function(dimension, value) {

+				if(this._current_chart === null) {

+					netdata.error('Called set(' + dimension + ', ' + value + ') without an open chart.');

+					return false;

+				}

+

+				if(typeof(this._current_chart.dimensions[dimension]) === 'undefined') {

+					netdata.error('Called set(' + dimension + ', ' + value + ') but dimension "' + dimension + '" does not exist in chart "' + this._current_chart.id + '".');

+					return false;

+				}

+

+				if(this._current_chart._dimensions_count !== 0)

+					this.queue('SET ' + dimension + ' = ' + value);

+

+				return true;

+			};

+

+			// end data collection for the current chart - after calling begin()

+			service.end = function() {

+				if(this._current_chart !== null && this._current_chart._began === false) {

+					netdata.error('Called end() without an open chart.');

+					return false;

+				}

+

+				if(this._current_chart._dimensions_count !== 0) {

+					this.queue('END');

+					netdata.send(this._queue);

+				}

+

+				this._queue = '';

+				this._current_chart._began = false;

+				if(netdata.options.DEBUG === true) netdata.debug('committed chart ' + this._current_chart.id);

+				this._current_chart = null;

+				return true;

+			};

+

+			// discard the collected values for the current chart - after calling begin()

+			service.flush = function() {

+				if(this._current_chart === null || this._current_chart._began === false) {

+					netdata.error('Called flush() without an open chart.');

+					return false;

+				}

+

+				this._queue = '';

+				this._current_chart._began = false;

+				this._current_chart = null;

+				return true;

+			};

+

+			// create a netdata chart

+			service.chart = function(id, chart) {

+				if(typeof(netdata.charts[id]) === 'undefined') {

+					netdata.charts[id] = {

+						_created: false,

+						_updated: false,

+						_began: false,

+						_counter: 0,

+						_last_updated: 0,

+						_dimensions_count: 0,

+						id: id,

+						name: id,

+						title: 'untitled chart',

+						units: 'a unit',

+						family: id,

+						category: id,

+						type: netdata.chartTypes.line,

+						priority: 0,

+						update_every: netdata.options.update_every,

+						dimensions: {}

+					};

+				}

+

+				var c = netdata.charts[id];

+

+				if(typeof(chart.name) !== 'undefined' && chart.name !== c.name) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its name');

+					c.name = chart.name;

+					c._updated = true;

+				}

+

+				if(typeof(chart.title) !== 'undefined' && chart.title !== c.title) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its title');

+					c.title = chart.title;

+					c._updated = true;

+				}

+

+				if(typeof(chart.units) !== 'undefined' && chart.units !== c.units) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its units');

+					c.units = chart.units;

+					c._updated = true;

+				}

+

+				if(typeof(chart.family) !== 'undefined' && chart.family !== c.family) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its family');

+					c.family = chart.family;

+					c._updated = true;

+				}

+

+				if(typeof(chart.category) !== 'undefined' && chart.category !== c.category) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its category');

+					c.category = chart.category;

+					c._updated = true;

+				}

+

+				if(typeof(chart.type) !== 'undefined' && chart.type !== c.type) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its type');

+					c.type = chart.type;

+					c._updated = true;

+				}

+

+				if(typeof(chart.priority) !== 'undefined' && chart.priority !== c.priority) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its priority');

+					c.priority = chart.priority;

+					c._updated = true;

+				}

+

+				if(typeof(chart.update_every) !== 'undefined' && chart.update_every !== c.update_every) {

+					if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' updated its update_every');

+					c.update_every = chart.update_every;

+					c._updated = true;

+				}

+

+				if(typeof(chart.dimensions) !== 'undefined') {

+					for(var x in chart.dimensions) {

+						if(typeof(c.dimensions[x]) === 'undefined') {

+							c._dimensions_count++;

+

+							c.dimensions[x] = {

+								_created: false,

+								_updated: false,

+								id: x,					// the unique id of the dimension

+								name: x,				// the name of the dimension

+								algorithm: netdata.chartAlgorithms.absolute,	// the id of the netdata algorithm

+								multiplier: 1,			// the multiplier

+								divisor: 1,				// the divisor

+								hidden: false,			// is hidden (boolean)

+							};

+

+							if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ' created dimension ' + x);

+							c._updated = true;

+						}

+

+						var dim = chart.dimensions[x];

+						var d = c.dimensions[x];

+

+						if(typeof(dim.name) !== 'undefined' && d.name !== dim.name) {

+							if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ', dimension ' + x + ' updated its name');

+							d.name = dim.name;

+							d._updated = true;

+						}

+

+						if(typeof(dim.algorithm) !== 'undefined' && d.algorithm !== dim.algorithm) {

+							if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ', dimension ' + x + ' updated its algorithm from ' + d.algorithm + ' to ' + dim.algorithm);

+							d.algorithm = dim.algorithm;

+							d._updated = true;

+						}

+

+						if(typeof(dim.multiplier) !== 'undefined' && d.multiplier !== dim.multiplier) {

+							if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ', dimension ' + x + ' updated its multiplier');

+							d.multiplier = dim.multiplier;

+							d._updated = true;

+						}

+

+						if(typeof(dim.divisor) !== 'undefined' && d.divisor !== dim.divisor) {

+							if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ', dimension ' + x + ' updated its divisor');

+							d.divisor = dim.divisor;

+							d._updated = true;

+						}

+

+						if(typeof(dim.hidden) !== 'undefined' && d.hidden !== dim.hidden) {

+							if(netdata.options.DEBUG === true) netdata.debug('chart ' + id + ', dimension ' + x + ' updated its hidden status');

+							d.hidden = dim.hidden;

+							d._updated = true;

+						}

+

+						if(d._updated) c._updated = true;

+					}

+				}

+

+				if(netdata.options.DEBUG === true) netdata.debug(netdata.ch