1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
|
<!--
title: "Develop a custom data collector in Python"
description: "Learn how write a custom data collector in Python, which you'll use to collect metrics from and monitor any application that isn't supported out of the box."
image: /img/seo/guides/python-collector.png
author: "Panagiotis Papaioannou"
author_title: "University of Patras"
author_img: "/img/authors/panagiotis-papaioannou.jpg"
custom_edit_url: https://github.com/netdata/netdata/edit/master/docs/guides/python-collector.md
-->
# Develop a custom data collector in Python
The Netdata Agent uses [data collectors](/docs/collect/how-collectors-work.md) to fetch metrics from hundreds of system,
container, and service endpoints. While the Netdata team and community has built [powerful
collectors](/collectors/COLLECTORS.md) for most system, container, and service/application endpoints, there are plenty
of custom applications that can't be monitored by default.
## Problem
You have a custom application or infrastructure that you need to monitor, but no open-source monitoring tool offers a
prebuilt method for collecting your required metric data.
## Solution
In this tutorial, you'll learn how to leverage the [Python programming language](https://www.python.org/) to build a
custom data collector for the Netdata Agent. Follow along with your own dataset, using the techniques and best practices
covered here, or use the included examples for collecting and organizing eithre random or weather data.
## What you need to get started
- A physical or virtual Linux system, which we'll call a _node_.
- A working installation of the free, open-source [Netdata Agent](/docs/get/README.md).
## Jobs and elements of a Python collector
A Python collector for Netdata is a Python script that gathers data from an external source and transforms these data
into charts to be displayed by Netdata dashboard. The basic jobs of the plugin are:
- Gather the data from the service/application.
- Create the required charts.
- Parse the data to extract or create the actual data to be represented.
- Assign the correct values to the charts
- Set the order for the charts to be displayed.
- Give the charts data to Netdata for visualization.
The basic elements of a Netdata collector are:
- `ORDER[]`: A list containing the charts to be displayed.
- `CHARTS{}`: A dictionary containing the details for the charts to be displayed.
- `data{}`: A dictionary containing the values to be displayed.
- `get_data()`: The basic function of the plugin which will retrun to Netdata the correct values.
Let's walk through these jobs and elements as independent elements first, then apply them to example Python code.
### Determine how to gather metrics data
Netdata can collect data from any program that can print to stdout. Common input sources for collectors can be logfiles,
HTTP requests, executables, and more. While this tutorial will offer some example inputs, your custom application will
have different inputs and metrics.
A great deal of the work in developing a Netdata collector is investigating the target application and understanding
which metrics it exposes and how to
### Create charts
For the data to be represented in the Netdata dashboard, you need to create charts. Charts (in general) are defined by
several characteristics: title, legend, units, type, and presented values. Each chart is represented as a dictionary
entry:
```python
chart= {
"chart_name":
{
"options": [option_list],
"lines": [
[dimension_list]
]
}
}
```
Use the `options` field to set the chart's options, which is a list in the form `options: [name, title, units, family,
context, charttype]`, where:
- `name`: The name of the chart.
- `title` : The title to be displayed in the chart.
- `units` : The units for this chart.
- `family`: An identifier used to group charts together (can be null).
- `context`: An identifier used to group contextually similar charts together. The best practice is to provide a context
that is `A.B`, with `A` being the name of the collector, and `B` being the name of the specific metric.
- `charttype`: Either `line`, `area`, or `stacked`. If null line is the default value.
You can read more about `family` and `context` in the [web dashboard](/web/README.md#families) doc.
Once the chart has been defined, you should define the dimensions of the chart. Dimensions are basically the metrics to
be represented in this chart and each chart can have more than one dimension. In order to define the dimensions, the
"lines" list should be filled in with the required dimensions. Each dimension is a list:
`dimension: [id, name, algorithm, multiplier, divisor]`
- `id` : The id of the dimension. Mandatory unique field (string) required in order to set a value.
- `name`: The name to be presented in the chart. If null id will be used.
- `algorithm`: Can be absolute or incremental. If null absolute is used. Incremental shows the difference from the
previous value.
- `multiplier`: an integer value to divide the collected value, if null, 1 is used
- `divisor`: an integer value to divide the collected value, if null, 1 is used
The multiplier/divisor fields are used in cases where the value to be displayed should be decimal since Netdata only
gathers integer values.
### Parse the data to extract or create the actual data to be represented
Once the data is received, your collector should process it in order to get the values required. If, for example, the
received data is a JSON string, you should parse the data to get the required data to be used for the charts.
### Assign the correct values to the charts
Once you have process your data and get the required values, you need to assign those values to the charts you created.
This is done using the `data` dictionary, which is in the form:
`"data": {dimension_id: value }`, where:
- `dimension_id`: The id of a defined dimension in a created chart.
- `value`: The numerical value to associate with this dimension.
### Set the order for the charts to be displayed
Next, set the order of chart appearance with the `ORDER` list, which is in the form:
`"ORDER": [chart_name_1,chart_name_2, …., chart_name_X]`, where:
- `chart_name_x`: is the chart name to be shown in X order.
### Give the charts data to Netdata for visualization
Our plugin should just rerun the data dictionary. If everything is set correctly the charts should be updated with the
correct values.
## Framework classes
The `python.d` plugin has a number of framework classes that can be used to speed up the development of your python
collector. Your class can inherit one of these framework classes, which have preconfigured methods.
For example, the snippet bellow is from the [RabbitMQ
collector](https://github.com/netdata/netdata/blob/91f3268e9615edd393bd43de4ad8068111024cc9/collectors/python.d.plugin/rabbitmq/rabbitmq.chart.py#L273).
This collector uses an HTTP endpoint and uses the `UrlService` framework class, which only needs to define an HTTP
endpoint for data collection.
```python
class Service(UrlService):
def __init__(self, configuration=None, name=None):
UrlService.__init__(self, configuration=configuration, name=name)
self.order = ORDER
self.definitions = CHARTS
self.url = '{0}://{1}:{2}'.format(
configuration.get('scheme', 'http'),
configuration.get('host', '127.0.0.1'),
configuration.get('port', 15672),
)
self.node_name = str()
self.vhost = VhostStatsBuilder()
self.collected_vhosts = set()
self.collect_queues_metrics = configuration.get('collect_queues_metrics', False)
self.debug("collect_queues_metrics is {0}".format("enabled" if self.collect_queues_metrics else "disabled"))
if self.collect_queues_metrics:
self.queue = QueueStatsBuilder()
self.collected_queues = set()
```
In our use-case, we use the `SimpleService` framework, since there is no framework class that suits our needs.
You can read more about the [framework classes](/collectors/python.d.plugin/README.md#how-to-write-a-new-module) from
the Netdata documentation.
## An example collector using weather station data
Let's build a custom Python collector for visualizing data from a weather monitoring station.
### Determine how to gather metrics data
This example assumes you can gather metrics data through HTTP requests to a web server, and that the data provided are
numeric values for temperature, humidity and pressure. It also assumes you can get the `min`, `max`, and `average`
values for these metrics.
### Chart creation
First, create a single chart that shows the latest temperature metric:
```python
CHARTS = {
"temp_current": {
"options": ["my_temp", "Temperature", "Celsius", "TEMP", "weather_station.temperature", "line"],
"lines": [
["current_temp_id","current_temperature"]
]
}
}
```
## Parse the data to extract or create the actual data to be represented
A standard practice would be to either get the data on JSON format or transform them to JSON format. We use a dictionary
to give this format and issue random values to simulate received data.
The following code iterates through the names of the expected values and creates a dictionary with the name of the value
as `key`, and a random value as `value`.
```python
weather_data=dict()
weather_metrics=[
"temp","av_temp","min_temp","max_temp",
"humid","av_humid","min_humid","max_humid",
"pressure","av_pressure","min_pressure","max_pressure",
]
def populate_data(self):
for metric in self.weather_metrics:
self.weather_data[metric]=random.randint(0,100)
```
### Assign the correct values to the charts
Our chart has a dimension called `current_temp_id`, which should have the temperature value received.
```python
data['current_temp_id'] = self.weather_data["temp"]
```
### Set the order for the charts to be displayed
```python
ORDER = [
"temp_current"
]
```
### Give the charts data to Netdata for visualization
```python
return data
```
A snapshot of the chart created by this plugin:
![A snapshot of the chart created by this plugin](https://i.imgur.com/2tR9KvF.png)
Here's the current source code for the data collector:
```python
# -*- coding: utf-8 -*-
# Description: howto weather station netdata python.d module
# Author: Panagiotis Papaioannou (papajohn-uop)
# SPDX-License-Identifier: GPL-3.0-or-later
from bases.FrameworkServices.SimpleService import SimpleService
import random
NETDATA_UPDATE_EVERY=1
priority = 90000
ORDER = [
"temp_current"
]
CHARTS = {
"temp_current": {
"options": ["my_temp", "Temperature", "Celsius", "TEMP", "weather_station.temperature", "line"],
"lines": [
["current_temperature"]
]
}
}
class Service(SimpleService):
def __init__(self, configuration=None, name=None):
SimpleService.__init__(self, configuration=configuration, name=name)
self.order = ORDER
self.definitions = CHARTS
#values to show at graphs
self.values=dict()
@staticmethod
def check():
return True
weather_data=dict()
weather_metrics=[
"temp","av_temp","min_temp","max_temp",
"humid","av_humid","min_humid","max_humid",
"pressure","av_pressure","min_pressure","max_pressure",
]
def logMe(self,msg):
self.debug(msg)
def populate_data(self):
for metric in self.weather_metrics:
self.weather_data[metric]=random.randint(0,100)
def get_data(self):
#The data dict is basically all the values to be represented
# The entries are in the format: { "dimension": value}
#And each "dimension" shoudl belong to a chart.
data = dict()
self.populate_data()
data['current_temperature'] = self.weather_data["temp"]
return data
```
## Add more charts to the existing weather station collector
To enrich the example, add another chart the collector which to present the humidity metric.
Add a new entry in the `CHARTS` dictionary with the definition for the new chart.
```python
CHARTS = {
'temp_current': {
'options': ['my_temp', 'Temperature', 'Celsius', 'TEMP', 'weather_station.temperature', 'line'],
'lines': [
['current_temperature']
]
},
'humid_current': {
'options': ['my_humid', 'Humidity', '%', 'HUMIDITY', 'weather_station.humidity', 'line'],
'lines': [
['current_humidity']
]
}
}
```
The data has already been created and parsed by the `weather_data=dict()` function, so you only need to populate the
`current_humidity` dimension `self.weather_data["humid"]`.
```python
data['current_temperature'] = self.weather_data["temp"]
data['current_humidity'] = self.weather_data["humid"]
```
Next, put the new `humid_current` chart into the `ORDER` list:
```python
ORDER = [
'temp_current',
'humid_current'
]
```
[Restart Netdata](/docs/configure/start-stop-restart.md) with `sudo systemctl restart netdata` to see the new humidity
chart:
![A snapshot of the modified chart](https://i.imgur.com/XOeCBmg.png)
Next, time to add one more chart that visualizes the average, minimum, and maximum temperature values.
Add a new entry in the `CHARTS` dictionary with the definition for the new chart. Since you want three values
represented in this this chart, add three dimensions. You shoudl also use the same `FAMILY` value in the charts (`TEMP`)
so that those two charts are grouped together.
```python
CHARTS = {
'temp_current': {
'options': ['my_temp', 'Temperature', 'Celsius', 'TEMP', 'weather_station.temperature', 'line'],
'lines': [
['current_temperature']
]
},
'temp_stats': {
'options': ['stats_temp', 'Temperature', 'Celsius', 'TEMP', 'weather_station.temperature_stats', 'line'],
'lines': [
['min_temperature'],
['max_temperature'],
['avg_temperature']
]
},
'humid_current': {
'options': ['my_humid', 'Humidity', '%', 'HUMIDITY', 'weather_station.humidity', 'line'],
'lines': [
['current_humidity']
]
}
}
```
As before, initiate new dimensions and add data to them:
```python
data['current_temperature'] = self.weather_data["temp"]
data['min_temperature'] = self.weather_data["min_temp"]
data['max_temperature'] = self.weather_data["max_temp"]
data['avg_temperature`'] = self.weather_data["av_temp"]
data['current_humidity'] = self.weather_data["humid"]
```
Finally, set the order for the `temp_stats` chart:
```python
ORDER = [
'temp_current',
‘temp_stats’
'humid_current'
]
```
[Restart Netdata](/docs/configure/start-stop
|