statsd.c 98 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556
  1. // SPDX-License-Identifier: GPL-3.0-or-later
  2. #include "statsd.h"
  3. #define STATSD_CHART_PREFIX "statsd"
  4. #define PLUGIN_STATSD_NAME "statsd.plugin"
  5. // --------------------------------------------------------------------------------------
  6. // #define STATSD_MULTITHREADED 1
  7. #ifdef STATSD_MULTITHREADED
  8. // DO NOT ENABLE MULTITHREADING - IT IS NOT WELL TESTED
  9. #define STATSD_AVL_TREE avl_tree_lock
  10. #define STATSD_AVL_INSERT avl_insert_lock
  11. #define STATSD_AVL_SEARCH avl_search_lock
  12. #define STATSD_AVL_INDEX_INIT { .avl_tree = { NULL, statsd_metric_compare }, .rwlock = AVL_LOCK_INITIALIZER }
  13. #define STATSD_FIRST_PTR_MUTEX netdata_mutex_t first_mutex
  14. #define STATSD_FIRST_PTR_MUTEX_INIT .first_mutex = NETDATA_MUTEX_INITIALIZER
  15. #define STATSD_FIRST_PTR_MUTEX_LOCK(index) netdata_mutex_lock(&((index)->first_mutex))
  16. #define STATSD_FIRST_PTR_MUTEX_UNLOCK(index) netdata_mutex_unlock(&((index)->first_mutex))
  17. #define STATSD_DICTIONARY_OPTIONS DICTIONARY_FLAG_DEFAULT
  18. #else
  19. #define STATSD_AVL_TREE avl_tree
  20. #define STATSD_AVL_INSERT avl_insert
  21. #define STATSD_AVL_SEARCH avl_search
  22. #define STATSD_AVL_INDEX_INIT { .root = NULL, .compar = statsd_metric_compare }
  23. #define STATSD_FIRST_PTR_MUTEX
  24. #define STATSD_FIRST_PTR_MUTEX_INIT
  25. #define STATSD_FIRST_PTR_MUTEX_LOCK(index)
  26. #define STATSD_FIRST_PTR_MUTEX_UNLOCK(index)
  27. #define STATSD_DICTIONARY_OPTIONS DICTIONARY_FLAG_SINGLE_THREADED
  28. #endif
  29. #define STATSD_DECIMAL_DETAIL 1000 // floating point values get multiplied by this, with the same divisor
  30. // --------------------------------------------------------------------------------------------------------------------
  31. // data specific to each metric type
  32. typedef struct statsd_metric_gauge {
  33. LONG_DOUBLE value;
  34. } STATSD_METRIC_GAUGE;
  35. typedef struct statsd_metric_counter { // counter and meter
  36. long long value;
  37. } STATSD_METRIC_COUNTER;
  38. typedef struct statsd_histogram_extensions {
  39. netdata_mutex_t mutex;
  40. // average is stored in metric->last
  41. collected_number last_min;
  42. collected_number last_max;
  43. collected_number last_percentile;
  44. collected_number last_median;
  45. collected_number last_stddev;
  46. collected_number last_sum;
  47. int zeroed;
  48. RRDDIM *rd_min;
  49. RRDDIM *rd_max;
  50. RRDDIM *rd_percentile;
  51. RRDDIM *rd_median;
  52. RRDDIM *rd_stddev;
  53. RRDDIM *rd_sum;
  54. size_t size;
  55. size_t used;
  56. LONG_DOUBLE *values; // dynamic array of values collected
  57. } STATSD_METRIC_HISTOGRAM_EXTENSIONS;
  58. typedef struct statsd_metric_histogram { // histogram and timer
  59. STATSD_METRIC_HISTOGRAM_EXTENSIONS *ext;
  60. } STATSD_METRIC_HISTOGRAM;
  61. typedef struct statsd_metric_set {
  62. DICTIONARY *dict;
  63. size_t unique;
  64. } STATSD_METRIC_SET;
  65. // --------------------------------------------------------------------------------------------------------------------
  66. // this is a metric - for all types of metrics
  67. typedef enum statsd_metric_options {
  68. STATSD_METRIC_OPTION_NONE = 0x00000000, // no options set
  69. STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED = 0x00000001, // do not update the chart dimension, when this metric is not collected
  70. STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED = 0x00000002, // render a private chart for this metric
  71. STATSD_METRIC_OPTION_PRIVATE_CHART_CHECKED = 0x00000004, // the metric has been checked if it should get private chart or not
  72. STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT = 0x00000008, // show the count of events for this private chart
  73. STATSD_METRIC_OPTION_CHECKED_IN_APPS = 0x00000010, // set when this metric has been checked against apps
  74. STATSD_METRIC_OPTION_USED_IN_APPS = 0x00000020, // set when this metric is used in apps
  75. STATSD_METRIC_OPTION_CHECKED = 0x00000040, // set when the charting thread checks this metric for use in charts (its usefulness)
  76. STATSD_METRIC_OPTION_USEFUL = 0x00000080, // set when the charting thread finds the metric useful (i.e. used in a chart)
  77. } STATS_METRIC_OPTIONS;
  78. typedef enum statsd_metric_type {
  79. STATSD_METRIC_TYPE_GAUGE,
  80. STATSD_METRIC_TYPE_COUNTER,
  81. STATSD_METRIC_TYPE_METER,
  82. STATSD_METRIC_TYPE_TIMER,
  83. STATSD_METRIC_TYPE_HISTOGRAM,
  84. STATSD_METRIC_TYPE_SET
  85. } STATSD_METRIC_TYPE;
  86. typedef struct statsd_metric {
  87. avl avl; // indexing - has to be first
  88. const char *name; // the name of the metric
  89. uint32_t hash; // hash of the name
  90. STATSD_METRIC_TYPE type;
  91. // metadata about data collection
  92. collected_number events; // the number of times this metric has been collected (never resets)
  93. size_t count; // the number of times this metric has been collected since the last flush
  94. // the actual collected data
  95. union {
  96. STATSD_METRIC_GAUGE gauge;
  97. STATSD_METRIC_COUNTER counter;
  98. STATSD_METRIC_HISTOGRAM histogram;
  99. STATSD_METRIC_SET set;
  100. };
  101. // chart related members
  102. STATS_METRIC_OPTIONS options; // STATSD_METRIC_OPTION_* (bitfield)
  103. char reset; // set to 1 by the charting thread to instruct the collector thread(s) to reset this metric
  104. collected_number last; // the last value sent to netdata
  105. RRDSET *st; // the private chart of this metric
  106. RRDDIM *rd_value; // the dimension of this metric value
  107. RRDDIM *rd_count; // the dimension for the number of events received
  108. // linking, used for walking through all metrics
  109. struct statsd_metric *next;
  110. struct statsd_metric *next_useful;
  111. } STATSD_METRIC;
  112. // --------------------------------------------------------------------------------------------------------------------
  113. // each type of metric has its own index
  114. typedef struct statsd_index {
  115. char *name; // the name of the index of metrics
  116. size_t events; // the number of events processed for this index
  117. size_t metrics; // the number of metrics in this index
  118. size_t useful; // the number of useful metrics in this index
  119. STATSD_AVL_TREE index; // the AVL tree
  120. STATSD_METRIC *first; // the linked list of metrics (new metrics are added in front)
  121. STATSD_METRIC *first_useful; // the linked list of useful metrics (new metrics are added in front)
  122. STATSD_FIRST_PTR_MUTEX; // when mutli-threading is enabled, a lock to protect the linked list
  123. STATS_METRIC_OPTIONS default_options; // default options for all metrics in this index
  124. } STATSD_INDEX;
  125. static int statsd_metric_compare(void* a, void* b);
  126. // --------------------------------------------------------------------------------------------------------------------
  127. // synthetic charts
  128. typedef enum statsd_app_chart_dimension_value_type {
  129. STATSD_APP_CHART_DIM_VALUE_TYPE_EVENTS,
  130. STATSD_APP_CHART_DIM_VALUE_TYPE_LAST,
  131. STATSD_APP_CHART_DIM_VALUE_TYPE_AVERAGE,
  132. STATSD_APP_CHART_DIM_VALUE_TYPE_SUM,
  133. STATSD_APP_CHART_DIM_VALUE_TYPE_MIN,
  134. STATSD_APP_CHART_DIM_VALUE_TYPE_MAX,
  135. STATSD_APP_CHART_DIM_VALUE_TYPE_PERCENTILE,
  136. STATSD_APP_CHART_DIM_VALUE_TYPE_MEDIAN,
  137. STATSD_APP_CHART_DIM_VALUE_TYPE_STDDEV
  138. } STATSD_APP_CHART_DIM_VALUE_TYPE;
  139. typedef struct statsd_app_chart_dimension {
  140. const char *name; // the name of this dimension
  141. const char *metric; // the source metric name of this dimension
  142. uint32_t metric_hash; // hash for fast string comparisons
  143. SIMPLE_PATTERN *metric_pattern; // set when the 'metric' is a simple pattern
  144. collected_number multiplier; // the multipler of the dimension
  145. collected_number divisor; // the divisor of the dimension
  146. RRDDIM_FLAGS flags; // the RRDDIM flags for this dimension
  147. STATSD_APP_CHART_DIM_VALUE_TYPE value_type; // which value to use of the source metric
  148. RRDDIM *rd; // a pointer to the RRDDIM that has been created for this dimension
  149. collected_number *value_ptr; // a pointer to the source metric value
  150. RRD_ALGORITHM algorithm; // the algorithm of this dimension
  151. struct statsd_app_chart_dimension *next; // the next dimension for this chart
  152. } STATSD_APP_CHART_DIM;
  153. typedef struct statsd_app_chart {
  154. const char *source;
  155. const char *id;
  156. const char *name;
  157. const char *title;
  158. const char *family;
  159. const char *context;
  160. const char *units;
  161. long priority;
  162. RRDSET_TYPE chart_type;
  163. STATSD_APP_CHART_DIM *dimensions;
  164. size_t dimensions_count;
  165. size_t dimensions_linked_count;
  166. RRDSET *st;
  167. struct statsd_app_chart *next;
  168. } STATSD_APP_CHART;
  169. typedef struct statsd_app {
  170. const char *name;
  171. SIMPLE_PATTERN *metrics;
  172. STATS_METRIC_OPTIONS default_options;
  173. RRD_MEMORY_MODE rrd_memory_mode;
  174. DICTIONARY *dict;
  175. long rrd_history_entries;
  176. const char *source;
  177. STATSD_APP_CHART *charts;
  178. struct statsd_app *next;
  179. } STATSD_APP;
  180. // --------------------------------------------------------------------------------------------------------------------
  181. // global statsd data
  182. struct collection_thread_status {
  183. int status;
  184. size_t max_sockets;
  185. netdata_thread_t thread;
  186. struct rusage rusage;
  187. RRDSET *st_cpu;
  188. RRDDIM *rd_user;
  189. RRDDIM *rd_system;
  190. };
  191. static struct statsd {
  192. STATSD_INDEX gauges;
  193. STATSD_INDEX counters;
  194. STATSD_INDEX timers;
  195. STATSD_INDEX histograms;
  196. STATSD_INDEX meters;
  197. STATSD_INDEX sets;
  198. size_t unknown_types;
  199. size_t socket_errors;
  200. size_t tcp_socket_connects;
  201. size_t tcp_socket_disconnects;
  202. size_t tcp_socket_connected;
  203. size_t tcp_socket_reads;
  204. size_t tcp_packets_received;
  205. size_t tcp_bytes_read;
  206. size_t udp_socket_reads;
  207. size_t udp_packets_received;
  208. size_t udp_bytes_read;
  209. int enabled;
  210. int update_every;
  211. SIMPLE_PATTERN *charts_for;
  212. size_t tcp_idle_timeout;
  213. collected_number decimal_detail;
  214. size_t private_charts;
  215. size_t max_private_charts;
  216. size_t max_private_charts_hard;
  217. RRD_MEMORY_MODE private_charts_memory_mode;
  218. long private_charts_rrd_history_entries;
  219. unsigned int private_charts_hidden:1;
  220. STATSD_APP *apps;
  221. size_t recvmmsg_size;
  222. size_t histogram_increase_step;
  223. double histogram_percentile;
  224. char *histogram_percentile_str;
  225. int threads;
  226. struct collection_thread_status *collection_threads_status;
  227. LISTEN_SOCKETS sockets;
  228. } statsd = {
  229. .enabled = 1,
  230. .max_private_charts = 200,
  231. .max_private_charts_hard = 1000,
  232. .private_charts_hidden = 0,
  233. .recvmmsg_size = 10,
  234. .decimal_detail = STATSD_DECIMAL_DETAIL,
  235. .gauges = {
  236. .name = "gauge",
  237. .events = 0,
  238. .metrics = 0,
  239. .index = STATSD_AVL_INDEX_INIT,
  240. .default_options = STATSD_METRIC_OPTION_NONE,
  241. .first = NULL,
  242. STATSD_FIRST_PTR_MUTEX_INIT
  243. },
  244. .counters = {
  245. .name = "counter",
  246. .events = 0,
  247. .metrics = 0,
  248. .index = STATSD_AVL_INDEX_INIT,
  249. .default_options = STATSD_METRIC_OPTION_NONE,
  250. .first = NULL,
  251. STATSD_FIRST_PTR_MUTEX_INIT
  252. },
  253. .timers = {
  254. .name = "timer",
  255. .events = 0,
  256. .metrics = 0,
  257. .index = STATSD_AVL_INDEX_INIT,
  258. .default_options = STATSD_METRIC_OPTION_NONE,
  259. .first = NULL,
  260. STATSD_FIRST_PTR_MUTEX_INIT
  261. },
  262. .histograms = {
  263. .name = "histogram",
  264. .events = 0,
  265. .metrics = 0,
  266. .index = STATSD_AVL_INDEX_INIT,
  267. .default_options = STATSD_METRIC_OPTION_NONE,
  268. .first = NULL,
  269. STATSD_FIRST_PTR_MUTEX_INIT
  270. },
  271. .meters = {
  272. .name = "meter",
  273. .events = 0,
  274. .metrics = 0,
  275. .index = STATSD_AVL_INDEX_INIT,
  276. .default_options = STATSD_METRIC_OPTION_NONE,
  277. .first = NULL,
  278. STATSD_FIRST_PTR_MUTEX_INIT
  279. },
  280. .sets = {
  281. .name = "set",
  282. .events = 0,
  283. .metrics = 0,
  284. .index = STATSD_AVL_INDEX_INIT,
  285. .default_options = STATSD_METRIC_OPTION_NONE,
  286. .first = NULL,
  287. STATSD_FIRST_PTR_MUTEX_INIT
  288. },
  289. .tcp_idle_timeout = 600,
  290. .apps = NULL,
  291. .histogram_percentile = 95.0,
  292. .histogram_increase_step = 10,
  293. .threads = 0,
  294. .collection_threads_status = NULL,
  295. .sockets = {
  296. .config = &netdata_config,
  297. .config_section = CONFIG_SECTION_STATSD,
  298. .default_bind_to = "udp:localhost tcp:localhost",
  299. .default_port = STATSD_LISTEN_PORT,
  300. .backlog = STATSD_LISTEN_BACKLOG
  301. },
  302. };
  303. // --------------------------------------------------------------------------------------------------------------------
  304. // statsd index management - add/find metrics
  305. static int statsd_metric_compare(void* a, void* b) {
  306. if(((STATSD_METRIC *)a)->hash < ((STATSD_METRIC *)b)->hash) return -1;
  307. else if(((STATSD_METRIC *)a)->hash > ((STATSD_METRIC *)b)->hash) return 1;
  308. else return strcmp(((STATSD_METRIC *)a)->name, ((STATSD_METRIC *)b)->name);
  309. }
  310. static inline STATSD_METRIC *statsd_metric_index_find(STATSD_INDEX *index, const char *name, uint32_t hash) {
  311. STATSD_METRIC tmp;
  312. tmp.name = name;
  313. tmp.hash = (hash)?hash:simple_hash(tmp.name);
  314. return (STATSD_METRIC *)STATSD_AVL_SEARCH(&index->index, (avl *)&tmp);
  315. }
  316. static inline STATSD_METRIC *statsd_find_or_add_metric(STATSD_INDEX *index, const char *name, STATSD_METRIC_TYPE type) {
  317. debug(D_STATSD, "searching for metric '%s' under '%s'", name, index->name);
  318. uint32_t hash = simple_hash(name);
  319. STATSD_METRIC *m = statsd_metric_index_find(index, name, hash);
  320. if(unlikely(!m)) {
  321. debug(D_STATSD, "Creating new %s metric '%s'", index->name, name);
  322. m = (STATSD_METRIC *)callocz(sizeof(STATSD_METRIC), 1);
  323. m->name = strdupz(name);
  324. m->hash = hash;
  325. m->type = type;
  326. m->options = index->default_options;
  327. if(type == STATSD_METRIC_TYPE_HISTOGRAM || type == STATSD_METRIC_TYPE_TIMER) {
  328. m->histogram.ext = callocz(sizeof(STATSD_METRIC_HISTOGRAM_EXTENSIONS), 1);
  329. netdata_mutex_init(&m->histogram.ext->mutex);
  330. }
  331. STATSD_METRIC *n = (STATSD_METRIC *)STATSD_AVL_INSERT(&index->index, (avl *)m);
  332. if(unlikely(n != m)) {
  333. freez((void *)m->histogram.ext);
  334. freez((void *)m->name);
  335. freez((void *)m);
  336. m = n;
  337. }
  338. else {
  339. STATSD_FIRST_PTR_MUTEX_LOCK(index);
  340. index->metrics++;
  341. m->next = index->first;
  342. index->first = m;
  343. STATSD_FIRST_PTR_MUTEX_UNLOCK(index);
  344. }
  345. }
  346. index->events++;
  347. return m;
  348. }
  349. // --------------------------------------------------------------------------------------------------------------------
  350. // statsd parsing numbers
  351. static inline LONG_DOUBLE statsd_parse_float(const char *v, LONG_DOUBLE def) {
  352. LONG_DOUBLE value;
  353. if(likely(v && *v)) {
  354. char *e = NULL;
  355. value = str2ld(v, &e);
  356. if(unlikely(e && *e))
  357. error("STATSD: excess data '%s' after value '%s'", e, v);
  358. }
  359. else
  360. value = def;
  361. return value;
  362. }
  363. static inline LONG_DOUBLE statsd_parse_sampling_rate(const char *v) {
  364. LONG_DOUBLE sampling_rate = statsd_parse_float(v, 1.0);
  365. if(unlikely(isless(sampling_rate, 0.001))) sampling_rate = 0.001;
  366. if(unlikely(isgreater(sampling_rate, 1.0))) sampling_rate = 1.0;
  367. return sampling_rate;
  368. }
  369. static inline long long statsd_parse_int(const char *v, long long def) {
  370. long long value;
  371. if(likely(v && *v)) {
  372. char *e = NULL;
  373. value = str2ll(v, &e);
  374. if(unlikely(e && *e))
  375. error("STATSD: excess data '%s' after value '%s'", e, v);
  376. }
  377. else
  378. value = def;
  379. return value;
  380. }
  381. // --------------------------------------------------------------------------------------------------------------------
  382. // statsd processors per metric type
  383. static inline void statsd_reset_metric(STATSD_METRIC *m) {
  384. m->reset = 0;
  385. m->count = 0;
  386. }
  387. static inline int value_is_zinit(const char *value) {
  388. return (value && *value == 'z' && *++value == 'i' && *++value == 'n' && *++value == 'i' && *++value == 't' && *++value == '\0');
  389. }
  390. #define is_metric_checked(m) ((m)->options & STATSD_METRIC_OPTION_CHECKED)
  391. #define is_metric_useful_for_collection(m) (!is_metric_checked(m) || ((m)->options & STATSD_METRIC_OPTION_USEFUL))
  392. static inline void statsd_process_gauge(STATSD_METRIC *m, const char *value, const char *sampling) {
  393. if(!is_metric_useful_for_collection(m)) return;
  394. if(unlikely(!value || !*value)) {
  395. error("STATSD: metric '%s' of type gauge, with empty value is ignored.", m->name);
  396. return;
  397. }
  398. if(unlikely(m->reset)) {
  399. // no need to reset anything specific for gauges
  400. statsd_reset_metric(m);
  401. }
  402. if(unlikely(value_is_zinit(value))) {
  403. // magic loading of metric, without affecting anything
  404. }
  405. else {
  406. if (unlikely(*value == '+' || *value == '-'))
  407. m->gauge.value += statsd_parse_float(value, 1.0) / statsd_parse_sampling_rate(sampling);
  408. else
  409. m->gauge.value = statsd_parse_float(value, 1.0);
  410. m->events++;
  411. m->count++;
  412. }
  413. }
  414. static inline void statsd_process_counter_or_meter(STATSD_METRIC *m, const char *value, const char *sampling) {
  415. if(!is_metric_useful_for_collection(m)) return;
  416. // we accept empty values for counters
  417. if(unlikely(m->reset)) statsd_reset_metric(m);
  418. if(unlikely(value_is_zinit(value))) {
  419. // magic loading of metric, without affecting anything
  420. }
  421. else {
  422. m->counter.value += llrintl((LONG_DOUBLE) statsd_parse_int(value, 1) / statsd_parse_sampling_rate(sampling));
  423. m->events++;
  424. m->count++;
  425. }
  426. }
  427. #define statsd_process_counter(m, value, sampling) statsd_process_counter_or_meter(m, value, sampling)
  428. #define statsd_process_meter(m, value, sampling) statsd_process_counter_or_meter(m, value, sampling)
  429. static inline void statsd_process_histogram_or_timer(STATSD_METRIC *m, const char *value, const char *sampling, const char *type) {
  430. if(!is_metric_useful_for_collection(m)) return;
  431. if(unlikely(!value || !*value)) {
  432. error("STATSD: metric of type %s, with empty value is ignored.", type);
  433. return;
  434. }
  435. if(unlikely(m->reset)) {
  436. m->histogram.ext->used = 0;
  437. statsd_reset_metric(m);
  438. }
  439. if(unlikely(value_is_zinit(value))) {
  440. // magic loading of metric, without affecting anything
  441. }
  442. else {
  443. LONG_DOUBLE v = statsd_parse_float(value, 1.0);
  444. LONG_DOUBLE sampling_rate = statsd_parse_sampling_rate(sampling);
  445. if(unlikely(isless(sampling_rate, 0.01))) sampling_rate = 0.01;
  446. if(unlikely(isgreater(sampling_rate, 1.0))) sampling_rate = 1.0;
  447. long long samples = llrintl(1.0 / sampling_rate);
  448. while(samples-- > 0) {
  449. if(unlikely(m->histogram.ext->used == m->histogram.ext->size)) {
  450. netdata_mutex_lock(&m->histogram.ext->mutex);
  451. m->histogram.ext->size += statsd.histogram_increase_step;
  452. m->histogram.ext->values = reallocz(m->histogram.ext->values, sizeof(LONG_DOUBLE) * m->histogram.ext->size);
  453. netdata_mutex_unlock(&m->histogram.ext->mutex);
  454. }
  455. m->histogram.ext->values[m->histogram.ext->used++] = v;
  456. }
  457. m->events++;
  458. m->count++;
  459. }
  460. }
  461. #define statsd_process_timer(m, value, sampling) statsd_process_histogram_or_timer(m, value, sampling, "timer")
  462. #define statsd_process_histogram(m, value, sampling) statsd_process_histogram_or_timer(m, value, sampling, "histogram")
  463. static inline void statsd_process_set(STATSD_METRIC *m, const char *value) {
  464. if(!is_metric_useful_for_collection(m)) return;
  465. if(unlikely(!value || !*value)) {
  466. error("STATSD: metric of type set, with empty value is ignored.");
  467. return;
  468. }
  469. if(unlikely(m->reset)) {
  470. if(likely(m->set.dict)) {
  471. dictionary_destroy(m->set.dict);
  472. m->set.dict = NULL;
  473. }
  474. statsd_reset_metric(m);
  475. }
  476. if (unlikely(!m->set.dict)) {
  477. m->set.dict = dictionary_create(STATSD_DICTIONARY_OPTIONS | DICTIONARY_FLAG_VALUE_LINK_DONT_CLONE);
  478. m->set.unique = 0;
  479. }
  480. if(unlikely(value_is_zinit(value))) {
  481. // magic loading of metric, without affecting anything
  482. }
  483. else {
  484. void *t = dictionary_get(m->set.dict, value);
  485. if (unlikely(!t)) {
  486. dictionary_set(m->set.dict, value, NULL, 1);
  487. m->set.unique++;
  488. }
  489. m->events++;
  490. m->count++;
  491. }
  492. }
  493. // --------------------------------------------------------------------------------------------------------------------
  494. // statsd parsing
  495. static void statsd_process_metric(const char *name, const char *value, const char *type, const char *sampling, const char *tags) {
  496. (void)tags;
  497. debug(D_STATSD, "STATSD: raw metric '%s', value '%s', type '%s', sampling '%s', tags '%s'", name?name:"(null)", value?value:"(null)", type?type:"(null)", sampling?sampling:"(null)", tags?tags:"(null)");
  498. if(unlikely(!name || !*name)) return;
  499. if(unlikely(!type || !*type)) type = "m";
  500. char t0 = type[0], t1 = type[1];
  501. if(unlikely(t0 == 'g' && t1 == '\0')) {
  502. statsd_process_gauge(
  503. statsd_find_or_add_metric(&statsd.gauges, name, STATSD_METRIC_TYPE_GAUGE),
  504. value, sampling);
  505. }
  506. else if(unlikely((t0 == 'c' || t0 == 'C') && t1 == '\0')) {
  507. // etsy/statsd uses 'c'
  508. // brubeck uses 'C'
  509. statsd_process_counter(
  510. statsd_find_or_add_metric(&statsd.counters, name, STATSD_METRIC_TYPE_COUNTER),
  511. value, sampling);
  512. }
  513. else if(unlikely(t0 == 'm' && t1 == '\0')) {
  514. statsd_process_meter(
  515. statsd_find_or_add_metric(&statsd.meters, name, STATSD_METRIC_TYPE_METER),
  516. value, sampling);
  517. }
  518. else if(unlikely(t0 == 'h' && t1 == '\0')) {
  519. statsd_process_histogram(
  520. statsd_find_or_add_metric(&statsd.histograms, name, STATSD_METRIC_TYPE_HISTOGRAM),
  521. value, sampling);
  522. }
  523. else if(unlikely(t0 == 's' && t1 == '\0')) {
  524. statsd_process_set(
  525. statsd_find_or_add_metric(&statsd.sets, name, STATSD_METRIC_TYPE_SET),
  526. value);
  527. }
  528. else if(unlikely(t0 == 'm' && t1 == 's' && type[2] == '\0')) {
  529. statsd_process_timer(
  530. statsd_find_or_add_metric(&statsd.timers, name, STATSD_METRIC_TYPE_TIMER),
  531. value, sampling);
  532. }
  533. else {
  534. statsd.unknown_types++;
  535. error("STATSD: metric '%s' with value '%s' is sent with unknown metric type '%s'", name, value?value:"", type);
  536. }
  537. }
  538. static inline const char *statsd_parse_skip_up_to(const char *s, char d1, char d2) {
  539. char c;
  540. for(c = *s; c && c != d1 && c != d2 && c != '\r' && c != '\n'; c = *++s) ;
  541. return s;
  542. }
  543. const char *statsd_parse_skip_spaces(const char *s) {
  544. char c;
  545. for(c = *s; c && ( c == ' ' || c == '\t' || c == '\r' || c == '\n' ); c = *++s) ;
  546. return s;
  547. }
  548. static inline const char *statsd_parse_field_trim(const char *start, char *end) {
  549. if(unlikely(!start)) {
  550. start = end;
  551. return start;
  552. }
  553. while(start <= end && (*start == ' ' || *start == '\t'))
  554. start++;
  555. *end = '\0';
  556. end--;
  557. while(end >= start && (*end == ' ' || *end == '\t'))
  558. *end-- = '\0';
  559. return start;
  560. }
  561. static inline size_t statsd_process(char *buffer, size_t size, int require_newlines) {
  562. buffer[size] = '\0';
  563. debug(D_STATSD, "RECEIVED: %zu bytes: '%s'", size, buffer);
  564. const char *s = buffer;
  565. while(*s) {
  566. const char *name = NULL, *value = NULL, *type = NULL, *sampling = NULL, *tags = NULL;
  567. char *name_end = NULL, *value_end = NULL, *type_end = NULL, *sampling_end = NULL, *tags_end = NULL;
  568. s = name_end = (char *)statsd_parse_skip_up_to(name = s, ':', '|');
  569. if(name == name_end) {
  570. s = statsd_parse_skip_spaces(s);
  571. continue;
  572. }
  573. if(likely(*s == ':'))
  574. s = value_end = (char *) statsd_parse_skip_up_to(value = ++s, '|', '|');
  575. if(likely(*s == '|'))
  576. s = type_end = (char *) statsd_parse_skip_up_to(type = ++s, '|', '@');
  577. if(likely(*s == '|' || *s == '@')) {
  578. s = sampling_end = (char *) statsd_parse_skip_up_to(sampling = ++s, '|', '#');
  579. if(*sampling == '@') sampling++;
  580. }
  581. if(likely(*s == '|' || *s == '#')) {
  582. s = tags_end = (char *) statsd_parse_skip_up_to(tags = ++s, '|', '|');
  583. if(*tags == '#') tags++;
  584. }
  585. // skip everything until the end of the line
  586. while(*s && *s != '\n') s++;
  587. if(unlikely(require_newlines && *s != '\n' && s > buffer)) {
  588. // move the remaining data to the beginning
  589. size -= (name - buffer);
  590. memmove(buffer, name, size);
  591. return size;
  592. }
  593. else
  594. s = statsd_parse_skip_spaces(s);
  595. statsd_process_metric(
  596. statsd_parse_field_trim(name, name_end)
  597. , statsd_parse_field_trim(value, value_end)
  598. , statsd_parse_field_trim(type, type_end)
  599. , statsd_parse_field_trim(sampling, sampling_end)
  600. , statsd_parse_field_trim(tags, tags_end)
  601. );
  602. }
  603. return 0;
  604. }
  605. // --------------------------------------------------------------------------------------------------------------------
  606. // statsd pollfd interface
  607. #define STATSD_TCP_BUFFER_SIZE 65536 // minimize tcp reads
  608. #define STATSD_UDP_BUFFER_SIZE 9000 // this should be up to MTU
  609. typedef enum {
  610. STATSD_SOCKET_DATA_TYPE_TCP,
  611. STATSD_SOCKET_DATA_TYPE_UDP
  612. } STATSD_SOCKET_DATA_TYPE;
  613. struct statsd_tcp {
  614. STATSD_SOCKET_DATA_TYPE type;
  615. size_t size;
  616. size_t len;
  617. char buffer[];
  618. };
  619. #ifdef HAVE_RECVMMSG
  620. struct statsd_udp {
  621. int *running;
  622. STATSD_SOCKET_DATA_TYPE type;
  623. size_t size;
  624. struct iovec *iovecs;
  625. struct mmsghdr *msgs;
  626. };
  627. #else
  628. struct statsd_udp {
  629. int *running;
  630. STATSD_SOCKET_DATA_TYPE type;
  631. char buffer[STATSD_UDP_BUFFER_SIZE];
  632. };
  633. #endif
  634. // new TCP client connected
  635. static void *statsd_add_callback(POLLINFO *pi, short int *events, void *data) {
  636. (void)pi;
  637. (void)data;
  638. *events = POLLIN;
  639. struct statsd_tcp *t = (struct statsd_tcp *)callocz(sizeof(struct statsd_tcp) + STATSD_TCP_BUFFER_SIZE, 1);
  640. t->type = STATSD_SOCKET_DATA_TYPE_TCP;
  641. t->size = STATSD_TCP_BUFFER_SIZE - 1;
  642. statsd.tcp_socket_connects++;
  643. statsd.tcp_socket_connected++;
  644. return t;
  645. }
  646. // TCP client disconnected
  647. static void statsd_del_callback(POLLINFO *pi) {
  648. struct statsd_tcp *t = pi->data;
  649. if(likely(t)) {
  650. if(t->type == STATSD_SOCKET_DATA_TYPE_TCP) {
  651. if(t->len != 0) {
  652. statsd.socket_errors++;
  653. error("STATSD: client is probably sending unterminated metrics. Closed socket left with '%s'. Trying to process it.", t->buffer);
  654. statsd_process(t->buffer, t->len, 0);
  655. }
  656. statsd.tcp_socket_disconnects++;
  657. statsd.tcp_socket_connected--;
  658. }
  659. else
  660. error("STATSD: internal error: received socket data type is %d, but expected %d", (int)t->type, (int)STATSD_SOCKET_DATA_TYPE_TCP);
  661. freez(t);
  662. }
  663. }
  664. // Receive data
  665. static int statsd_rcv_callback(POLLINFO *pi, short int *events) {
  666. *events = POLLIN;
  667. int fd = pi->fd;
  668. switch(pi->socktype) {
  669. case SOCK_STREAM: {
  670. struct statsd_tcp *d = (struct statsd_tcp *)pi->data;
  671. if(unlikely(!d)) {
  672. error("STATSD: internal error: expected TCP data pointer is NULL");
  673. statsd.socket_errors++;
  674. return -1;
  675. }
  676. #ifdef NETDATA_INTERNAL_CHECKS
  677. if(unlikely(d->type != STATSD_SOCKET_DATA_TYPE_TCP)) {
  678. error("STATSD: internal error: socket data type should be %d, but it is %d", (int)STATSD_SOCKET_DATA_TYPE_TCP, (int)d->type);
  679. statsd.socket_errors++;
  680. return -1;
  681. }
  682. #endif
  683. int ret = 0;
  684. ssize_t rc;
  685. do {
  686. rc = recv(fd, &d->buffer[d->len], d->size - d->len, MSG_DONTWAIT);
  687. if (rc < 0) {
  688. // read failed
  689. if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR) {
  690. error("STATSD: recv() on TCP socket %d failed.", fd);
  691. statsd.socket_errors++;
  692. ret = -1;
  693. }
  694. }
  695. else if (!rc) {
  696. // connection closed
  697. debug(D_STATSD, "STATSD: client disconnected.");
  698. ret = -1;
  699. }
  700. else {
  701. // data received
  702. d->len += rc;
  703. statsd.tcp_socket_reads++;
  704. statsd.tcp_bytes_read += rc;
  705. }
  706. if(likely(d->len > 0)) {
  707. statsd.tcp_packets_received++;
  708. d->len = statsd_process(d->buffer, d->len, 1);
  709. }
  710. if(unlikely(ret == -1))
  711. return -1;
  712. } while (rc != -1);
  713. break;
  714. }
  715. case SOCK_DGRAM: {
  716. struct statsd_udp *d = (struct statsd_udp *)pi->data;
  717. if(unlikely(!d)) {
  718. error("STATSD: internal error: expected UDP data pointer is NULL");
  719. statsd.socket_errors++;
  720. return -1;
  721. }
  722. #ifdef NETDATA_INTERNAL_CHECKS
  723. if(unlikely(d->type != STATSD_SOCKET_DATA_TYPE_UDP)) {
  724. error("STATSD: internal error: socket data should be %d, but it is %d", (int)d->type, (int)STATSD_SOCKET_DATA_TYPE_UDP);
  725. statsd.socket_errors++;
  726. return -1;
  727. }
  728. #endif
  729. #ifdef HAVE_RECVMMSG
  730. ssize_t rc;
  731. do {
  732. rc = recvmmsg(fd, d->msgs, (unsigned int)d->size, MSG_DONTWAIT, NULL);
  733. if (rc < 0) {
  734. // read failed
  735. if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR) {
  736. error("STATSD: recvmmsg() on UDP socket %d failed.", fd);
  737. statsd.socket_errors++;
  738. return -1;
  739. }
  740. } else if (rc) {
  741. // data received
  742. statsd.udp_socket_reads++;
  743. statsd.udp_packets_received += rc;
  744. size_t i;
  745. for (i = 0; i < (size_t)rc; ++i) {
  746. size_t len = (size_t)d->msgs[i].msg_len;
  747. statsd.udp_bytes_read += len;
  748. statsd_process(d->msgs[i].msg_hdr.msg_iov->iov_base, len, 0);
  749. }
  750. }
  751. } while (rc != -1);
  752. #else // !HAVE_RECVMMSG
  753. ssize_t rc;
  754. do {
  755. rc = recv(fd, d->buffer, STATSD_UDP_BUFFER_SIZE - 1, MSG_DONTWAIT);
  756. if (rc < 0) {
  757. // read failed
  758. if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR) {
  759. error("STATSD: recv() on UDP socket %d failed.", fd);
  760. statsd.socket_errors++;
  761. return -1;
  762. }
  763. } else if (rc) {
  764. // data received
  765. statsd.udp_socket_reads++;
  766. statsd.udp_packets_received++;
  767. statsd.udp_bytes_read += rc;
  768. statsd_process(d->buffer, (size_t) rc, 0);
  769. }
  770. } while (rc != -1);
  771. #endif
  772. break;
  773. }
  774. default: {
  775. error("STATSD: internal error: unknown socktype %d on socket %d", pi->socktype, fd);
  776. statsd.socket_errors++;
  777. return -1;
  778. }
  779. }
  780. return 0;
  781. }
  782. static int statsd_snd_callback(POLLINFO *pi, short int *events) {
  783. (void)pi;
  784. (void)events;
  785. error("STATSD: snd_callback() called, but we never requested to send data to statsd clients.");
  786. return -1;
  787. }
  788. static void statsd_timer_callback(void *timer_data) {
  789. struct collection_thread_status *status = timer_data;
  790. getrusage(RUSAGE_THREAD, &status->rusage);
  791. }
  792. // --------------------------------------------------------------------------------------------------------------------
  793. // statsd child thread to collect metrics from network
  794. void statsd_collector_thread_cleanup(void *data) {
  795. struct statsd_udp *d = data;
  796. *d->running = 0;
  797. info("cleaning up...");
  798. #ifdef HAVE_RECVMMSG
  799. size_t i;
  800. for (i = 0; i < d->size; i++)
  801. freez(d->iovecs[i].iov_base);
  802. freez(d->iovecs);
  803. freez(d->msgs);
  804. #endif
  805. freez(d);
  806. }
  807. void *statsd_collector_thread(void *ptr) {
  808. struct collection_thread_status *status = ptr;
  809. status->status = 1;
  810. info("STATSD collector thread started with taskid %d", gettid());
  811. struct statsd_udp *d = callocz(sizeof(struct statsd_udp), 1);
  812. d->running = &status->status;
  813. netdata_thread_cleanup_push(statsd_collector_thread_cleanup, d);
  814. #ifdef HAVE_RECVMMSG
  815. d->type = STATSD_SOCKET_DATA_TYPE_UDP;
  816. d->size = statsd.recvmmsg_size;
  817. d->iovecs = callocz(sizeof(struct iovec), d->size);
  818. d->msgs = callocz(sizeof(struct mmsghdr), d->size);
  819. size_t i;
  820. for (i = 0; i < d->size; i++) {
  821. d->iovecs[i].iov_base = mallocz(STATSD_UDP_BUFFER_SIZE);
  822. d->iovecs[i].iov_len = STATSD_UDP_BUFFER_SIZE - 1;
  823. d->msgs[i].msg_hdr.msg_iov = &d->iovecs[i];
  824. d->msgs[i].msg_hdr.msg_iovlen = 1;
  825. }
  826. #endif
  827. poll_events(&statsd.sockets
  828. , statsd_add_callback
  829. , statsd_del_callback
  830. , statsd_rcv_callback
  831. , statsd_snd_callback
  832. , statsd_timer_callback
  833. , NULL
  834. , (void *)d
  835. , 0 // tcp request timeout, 0 = disabled
  836. , statsd.tcp_idle_timeout // tcp idle timeout, 0 = disabled
  837. , statsd.update_every * 1000
  838. , ptr // timer_data
  839. , status->max_sockets
  840. );
  841. netdata_thread_cleanup_pop(1);
  842. return NULL;
  843. }
  844. // --------------------------------------------------------------------------------------------------------------------
  845. // statsd applications configuration files parsing
  846. #define STATSD_CONF_LINE_MAX 8192
  847. static STATSD_APP_CHART_DIM_VALUE_TYPE string2valuetype(const char *type, size_t line, const char *filename) {
  848. if(!type || !*type) type = "last";
  849. if(!strcmp(type, "events")) return STATSD_APP_CHART_DIM_VALUE_TYPE_EVENTS;
  850. else if(!strcmp(type, "last")) return STATSD_APP_CHART_DIM_VALUE_TYPE_LAST;
  851. else if(!strcmp(type, "min")) return STATSD_APP_CHART_DIM_VALUE_TYPE_MIN;
  852. else if(!strcmp(type, "max")) return STATSD_APP_CHART_DIM_VALUE_TYPE_MAX;
  853. else if(!strcmp(type, "sum")) return STATSD_APP_CHART_DIM_VALUE_TYPE_SUM;
  854. else if(!strcmp(type, "average")) return STATSD_APP_CHART_DIM_VALUE_TYPE_AVERAGE;
  855. else if(!strcmp(type, "median")) return STATSD_APP_CHART_DIM_VALUE_TYPE_MEDIAN;
  856. else if(!strcmp(type, "stddev")) return STATSD_APP_CHART_DIM_VALUE_TYPE_STDDEV;
  857. else if(!strcmp(type, "percentile")) return STATSD_APP_CHART_DIM_VALUE_TYPE_PERCENTILE;
  858. error("STATSD: invalid type '%s' at line %zu of file '%s'. Using 'last'.", type, line, filename);
  859. return STATSD_APP_CHART_DIM_VALUE_TYPE_LAST;
  860. }
  861. static const char *valuetype2string(STATSD_APP_CHART_DIM_VALUE_TYPE type) {
  862. switch(type) {
  863. case STATSD_APP_CHART_DIM_VALUE_TYPE_EVENTS: return "events";
  864. case STATSD_APP_CHART_DIM_VALUE_TYPE_LAST: return "last";
  865. case STATSD_APP_CHART_DIM_VALUE_TYPE_MIN: return "min";
  866. case STATSD_APP_CHART_DIM_VALUE_TYPE_MAX: return "max";
  867. case STATSD_APP_CHART_DIM_VALUE_TYPE_SUM: return "sum";
  868. case STATSD_APP_CHART_DIM_VALUE_TYPE_AVERAGE: return "average";
  869. case STATSD_APP_CHART_DIM_VALUE_TYPE_MEDIAN: return "median";
  870. case STATSD_APP_CHART_DIM_VALUE_TYPE_STDDEV: return "stddev";
  871. case STATSD_APP_CHART_DIM_VALUE_TYPE_PERCENTILE: return "percentile";
  872. }
  873. return "unknown";
  874. }
  875. static STATSD_APP_CHART_DIM *add_dimension_to_app_chart(
  876. STATSD_APP *app
  877. , STATSD_APP_CHART *chart
  878. , const char *metric_name
  879. , const char *dim_name
  880. , collected_number multiplier
  881. , collected_number divisor
  882. , RRDDIM_FLAGS flags
  883. , STATSD_APP_CHART_DIM_VALUE_TYPE value_type
  884. ) {
  885. STATSD_APP_CHART_DIM *dim = callocz(sizeof(STATSD_APP_CHART_DIM), 1);
  886. dim->metric = strdupz(metric_name);
  887. dim->metric_hash = simple_hash(dim->metric);
  888. dim->name = strdupz((dim_name)?dim_name:"");
  889. dim->multiplier = multiplier;
  890. dim->divisor = divisor;
  891. dim->value_type = value_type;
  892. dim->flags = flags;
  893. if(!dim->multiplier)
  894. dim->multiplier = 1;
  895. if(!dim->divisor)
  896. dim->divisor = 1;
  897. // append it to the list of dimension
  898. STATSD_APP_CHART_DIM *tdim;
  899. for(tdim = chart->dimensions; tdim && tdim->next ; tdim = tdim->next) ;
  900. if(!tdim) {
  901. dim->next = chart->dimensions;
  902. chart->dimensions = dim;
  903. }
  904. else {
  905. dim->next = tdim->next;
  906. tdim->next = dim;
  907. }
  908. chart->dimensions_count++;
  909. debug(D_STATSD, "Added dimension '%s' to chart '%s' of app '%s', for metric '%s', with type %u, multiplier " COLLECTED_NUMBER_FORMAT ", divisor " COLLECTED_NUMBER_FORMAT,
  910. dim->name, chart->id, app->name, dim->metric, dim->value_type, dim->multiplier, dim->divisor);
  911. return dim;
  912. }
  913. static int statsd_readfile(const char *filename, STATSD_APP *app, STATSD_APP_CHART *chart, DICTIONARY *dict) {
  914. debug(D_STATSD, "STATSD configuration reading file '%s'", filename);
  915. char *buffer = mallocz(STATSD_CONF_LINE_MAX + 1);
  916. FILE *fp = fopen(filename, "r");
  917. if(!fp) {
  918. error("STATSD: cannot open file '%s'.", filename);
  919. freez(buffer);
  920. return -1;
  921. }
  922. size_t line = 0;
  923. char *s;
  924. while(fgets(buffer, STATSD_CONF_LINE_MAX, fp) != NULL) {
  925. buffer[STATSD_CONF_LINE_MAX] = '\0';
  926. line++;
  927. s = trim(buffer);
  928. if (!s || *s == '#') {
  929. debug(D_STATSD, "STATSD: ignoring line %zu of file '%s', it is empty.", line, filename);
  930. continue;
  931. }
  932. debug(D_STATSD, "STATSD: processing line %zu of file '%s': %s", line, filename, buffer);
  933. if(*s == 'i' && strncmp(s, "include", 7) == 0) {
  934. s = trim(&s[7]);
  935. if(s && *s) {
  936. char *tmp;
  937. if(*s == '/')
  938. tmp = strdupz(s);
  939. else {
  940. // the file to be included is relative to current file
  941. // find the directory name from the file we already read
  942. char *filename2 = strdupz(filename); // copy filename, since dirname() will change it
  943. char *dir = dirname(filename2); // find the directory part of the filename
  944. tmp = strdupz_path_subpath(dir, s); // compose the new filename to read;
  945. freez(filename2); // free the filename we copied
  946. }
  947. statsd_readfile(tmp, app, chart, dict);
  948. freez(tmp);
  949. }
  950. else
  951. error("STATSD: ignoring line %zu of file '%s', include filename is empty", line, filename);
  952. continue;
  953. }
  954. int len = (int) strlen(s);
  955. if (*s == '[' && s[len - 1] == ']') {
  956. // new section
  957. s[len - 1] = '\0';
  958. s++;
  959. if (!strcmp(s, "app")) {
  960. // a new app
  961. app = callocz(sizeof(STATSD_APP), 1);
  962. app->name = strdupz("unnamed");
  963. app->rrd_memory_mode = localhost->rrd_memory_mode;
  964. app->rrd_history_entries = localhost->rrd_history_entries;
  965. app->next = statsd.apps;
  966. statsd.apps = app;
  967. chart = NULL;
  968. dict = NULL;
  969. {
  970. char lineandfile[FILENAME_MAX + 1];
  971. snprintfz(lineandfile, FILENAME_MAX, "%zu@%s", line, filename);
  972. app->source = strdupz(lineandfile);
  973. }
  974. }
  975. else if(app) {
  976. if(!strcmp(s, "dictionary")) {
  977. if(!app->dict)
  978. app->dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED);
  979. dict = app->dict;
  980. }
  981. else {
  982. dict = NULL;
  983. // a new chart
  984. chart = callocz(sizeof(STATSD_APP_CHART), 1);
  985. netdata_fix_chart_id(s);
  986. chart->id = strdupz(s);
  987. chart->name = strdupz(s);
  988. chart->title = strdupz("Statsd chart");
  989. chart->context = strdupz(s);
  990. chart->family = strdupz("overview");
  991. chart->units = strdupz("value");
  992. chart->priority = NETDATA_CHART_PRIO_STATSD_PRIVATE;
  993. chart->chart_type = RRDSET_TYPE_LINE;
  994. chart->next = app->charts;
  995. app->charts = chart;
  996. {
  997. char lineandfile[FILENAME_MAX + 1];
  998. snprintfz(lineandfile, FILENAME_MAX, "%zu@%s", line, filename);
  999. chart->source = strdupz(lineandfile);
  1000. }
  1001. }
  1002. }
  1003. else
  1004. error("STATSD: ignoring line %zu ('%s') of file '%s', [app] is not defined.", line, s, filename);
  1005. continue;
  1006. }
  1007. if(!app) {
  1008. error("STATSD: ignoring line %zu ('%s') of file '%s', it is outside all sections.", line, s, filename);
  1009. continue;
  1010. }
  1011. char *name = s;
  1012. char *value = strchr(s, '=');
  1013. if(!value) {
  1014. error("STATSD: ignoring line %zu ('%s') of file '%s', there is no = in it.", line, s, filename);
  1015. continue;
  1016. }
  1017. *value = '\0';
  1018. value++;
  1019. name = trim(name);
  1020. value = trim(value);
  1021. if(!name || *name == '#') {
  1022. error("STATSD: ignoring line %zu of file '%s', name is empty.", line, filename);
  1023. continue;
  1024. }
  1025. if(!value) {
  1026. debug(D_CONFIG, "STATSD: ignoring line %zu of file '%s', value is empty.", line, filename);
  1027. continue;
  1028. }
  1029. if(unlikely(dict)) {
  1030. // parse [dictionary] members
  1031. dictionary_set(dict, name, value, strlen(value) + 1);
  1032. }
  1033. else if(!chart) {
  1034. // parse [app] members
  1035. if(!strcmp(name, "name")) {
  1036. freez((void *)app->name);
  1037. netdata_fix_chart_name(value);
  1038. app->name = strdupz(value);
  1039. }
  1040. else if (!strcmp(name, "metrics")) {
  1041. simple_pattern_free(app->metrics);
  1042. app->metrics = simple_pattern_create(value, NULL, SIMPLE_PATTERN_EXACT);
  1043. }
  1044. else if (!strcmp(name, "private charts")) {
  1045. if (!strcmp(value, "yes") || !strcmp(value, "on"))
  1046. app->default_options |= STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1047. else
  1048. app->default_options &= ~STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1049. }
  1050. else if (!strcmp(name, "gaps when not collected")) {
  1051. if (!strcmp(value, "yes") || !strcmp(value, "on"))
  1052. app->default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1053. }
  1054. else if (!strcmp(name, "memory mode")) {
  1055. app->rrd_memory_mode = rrd_memory_mode_id(value);
  1056. }
  1057. else if (!strcmp(name, "history")) {
  1058. app->rrd_history_entries = atol(value);
  1059. if (app->rrd_history_entries < 5)
  1060. app->rrd_history_entries = 5;
  1061. }
  1062. else {
  1063. error("STATSD: ignoring line %zu ('%s') of file '%s'. Unknown keyword for the [app] section.", line, name, filename);
  1064. continue;
  1065. }
  1066. }
  1067. else {
  1068. // parse [chart] members
  1069. if(!strcmp(name, "name")) {
  1070. freez((void *)chart->name);
  1071. netdata_fix_chart_id(value);
  1072. chart->name = strdupz(value);
  1073. }
  1074. else if(!strcmp(name, "title")) {
  1075. freez((void *)chart->title);
  1076. chart->title = strdupz(value);
  1077. }
  1078. else if (!strcmp(name, "family")) {
  1079. freez((void *)chart->family);
  1080. chart->family = strdupz(value);
  1081. }
  1082. else if (!strcmp(name, "context")) {
  1083. freez((void *)chart->context);
  1084. netdata_fix_chart_id(value);
  1085. chart->context = strdupz(value);
  1086. }
  1087. else if (!strcmp(name, "units")) {
  1088. freez((void *)chart->units);
  1089. chart->units = strdupz(value);
  1090. }
  1091. else if (!strcmp(name, "priority")) {
  1092. chart->priority = atol(value);
  1093. }
  1094. else if (!strcmp(name, "type")) {
  1095. chart->chart_type = rrdset_type_id(value);
  1096. }
  1097. else if (!strcmp(name, "dimension")) {
  1098. // metric [name [type [multiplier [divisor]]]]
  1099. char *words[10];
  1100. pluginsd_split_words(value, words, 10);
  1101. int pattern = 0;
  1102. size_t i = 0;
  1103. char *metric_name = words[i++];
  1104. if(strcmp(metric_name, "pattern") == 0) {
  1105. metric_name = words[i++];
  1106. pattern = 1;
  1107. }
  1108. char *dim_name = words[i++];
  1109. char *type = words[i++];
  1110. char *multipler = words[i++];
  1111. char *divisor = words[i++];
  1112. char *options = words[i++];
  1113. RRDDIM_FLAGS flags = RRDDIM_FLAG_NONE;
  1114. if(options && *options) {
  1115. if(strstr(options, "hidden") != NULL) flags |= RRDDIM_FLAG_HIDDEN;
  1116. if(strstr(options, "noreset") != NULL) flags |= RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS;
  1117. if(strstr(options, "nooverflow") != NULL) flags |= RRDDIM_FLAG_DONT_DETECT_RESETS_OR_OVERFLOWS;
  1118. }
  1119. if(!pattern) {
  1120. if(app->dict) {
  1121. if(dim_name && *dim_name) {
  1122. char *n = dictionary_get(app->dict, dim_name);
  1123. if(n) dim_name = n;
  1124. }
  1125. else {
  1126. dim_name = dictionary_get(app->dict, metric_name);
  1127. }
  1128. }
  1129. if(!dim_name || !*dim_name)
  1130. dim_name = metric_name;
  1131. }
  1132. STATSD_APP_CHART_DIM *dim = add_dimension_to_app_chart(
  1133. app
  1134. , chart
  1135. , metric_name
  1136. , dim_name
  1137. , (multipler && *multipler)?str2l(multipler):1
  1138. , (divisor && *divisor)?str2l(divisor):1
  1139. , flags
  1140. , string2valuetype(type, line, filename)
  1141. );
  1142. if(pattern)
  1143. dim->metric_pattern = simple_pattern_create(dim->metric, NULL, SIMPLE_PATTERN_EXACT);
  1144. }
  1145. else {
  1146. error("STATSD: ignoring line %zu ('%s') of file '%s'. Unknown keyword for the [%s] section.", line, name, filename, chart->id);
  1147. continue;
  1148. }
  1149. }
  1150. }
  1151. freez(buffer);
  1152. fclose(fp);
  1153. return 0;
  1154. }
  1155. static int statsd_file_callback(const char *filename, void *data) {
  1156. (void)data;
  1157. return statsd_readfile(filename, NULL, NULL, NULL);
  1158. }
  1159. static inline void statsd_readdir(const char *user_path, const char *stock_path, const char *subpath) {
  1160. recursive_config_double_dir_load(user_path, stock_path, subpath, statsd_file_callback, NULL, 0);
  1161. }
  1162. // --------------------------------------------------------------------------------------------------------------------
  1163. // send metrics to netdata - in private charts - called from the main thread
  1164. // extract chart type and chart id from metric name
  1165. static inline void statsd_get_metric_type_and_id(STATSD_METRIC *m, char *type, char *id, const char *defid, size_t len) {
  1166. char *s;
  1167. snprintfz(type, len, "%s_%s_%s", STATSD_CHART_PREFIX, defid, m->name);
  1168. for(s = type; *s ;s++)
  1169. if(unlikely(*s == '.')) break;
  1170. if(*s == '.') {
  1171. *s++ = '\0';
  1172. strncpyz(id, s, len);
  1173. }
  1174. else {
  1175. strncpyz(id, defid, len);
  1176. }
  1177. netdata_fix_chart_id(type);
  1178. netdata_fix_chart_id(id);
  1179. }
  1180. static inline RRDSET *statsd_private_rrdset_create(
  1181. STATSD_METRIC *m
  1182. , const char *type
  1183. , const char *id
  1184. , const char *name
  1185. , const char *family
  1186. , const char *context
  1187. , const char *title
  1188. , const char *units
  1189. , long priority
  1190. , int update_every
  1191. , RRDSET_TYPE chart_type
  1192. ) {
  1193. RRD_MEMORY_MODE memory_mode = statsd.private_charts_memory_mode;
  1194. long history = statsd.private_charts_rrd_history_entries;
  1195. if(unlikely(statsd.private_charts >= statsd.max_private_charts)) {
  1196. debug(D_STATSD, "STATSD: metric '%s' will be charted with memory mode = none, because the maximum number of charts has been reached.", m->name);
  1197. info("STATSD: metric '%s' will be charted with memory mode = none, because the maximum number of charts (%zu) has been reached. Increase the number of charts by editing netdata.conf, [statsd] section.", m->name, statsd.max_private_charts);
  1198. memory_mode = RRD_MEMORY_MODE_NONE;
  1199. history = 5;
  1200. }
  1201. statsd.private_charts++;
  1202. RRDSET *st = rrdset_create_custom(
  1203. localhost // host
  1204. , type // type
  1205. , id // id
  1206. , name // name
  1207. , family // family
  1208. , context // context
  1209. , title // title
  1210. , units // units
  1211. , PLUGIN_STATSD_NAME // plugin
  1212. , "private_chart" // module
  1213. , priority // priority
  1214. , update_every // update every
  1215. , chart_type // chart type
  1216. , memory_mode // memory mode
  1217. , history // history
  1218. );
  1219. rrdset_flag_set(st, RRDSET_FLAG_STORE_FIRST);
  1220. if(statsd.private_charts_hidden)
  1221. rrdset_flag_set(st, RRDSET_FLAG_HIDDEN);
  1222. // rrdset_flag_set(st, RRDSET_FLAG_DEBUG);
  1223. return st;
  1224. }
  1225. static inline void statsd_private_chart_gauge(STATSD_METRIC *m) {
  1226. debug(D_STATSD, "updating private chart for gauge metric '%s'", m->name);
  1227. if(unlikely(!m->st)) {
  1228. char type[RRD_ID_LENGTH_MAX + 1], id[RRD_ID_LENGTH_MAX + 1];
  1229. statsd_get_metric_type_and_id(m, type, id, "gauge", RRD_ID_LENGTH_MAX);
  1230. char context[RRD_ID_LENGTH_MAX + 1];
  1231. snprintfz(context, RRD_ID_LENGTH_MAX, "statsd_gauge.%s", m->name);
  1232. char title[RRD_ID_LENGTH_MAX + 1];
  1233. snprintfz(title, RRD_ID_LENGTH_MAX, "statsd private chart for gauge %s", m->name);
  1234. m->st = statsd_private_rrdset_create(
  1235. m
  1236. , type
  1237. , id
  1238. , NULL // name
  1239. , "gauges" // family (submenu)
  1240. , context // context
  1241. , title // title
  1242. , "value" // units
  1243. , NETDATA_CHART_PRIO_STATSD_PRIVATE
  1244. , statsd.update_every
  1245. , RRDSET_TYPE_LINE
  1246. );
  1247. m->rd_value = rrddim_add(m->st, "gauge", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1248. if(m->options & STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT)
  1249. m->rd_count = rrddim_add(m->st, "events", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1250. }
  1251. else rrdset_next(m->st);
  1252. rrddim_set_by_pointer(m->st, m->rd_value, m->last);
  1253. if(m->rd_count)
  1254. rrddim_set_by_pointer(m->st, m->rd_count, m->events);
  1255. rrdset_done(m->st);
  1256. }
  1257. static inline void statsd_private_chart_counter_or_meter(STATSD_METRIC *m, const char *dim, const char *family) {
  1258. debug(D_STATSD, "updating private chart for %s metric '%s'", dim, m->name);
  1259. if(unlikely(!m->st)) {
  1260. char type[RRD_ID_LENGTH_MAX + 1], id[RRD_ID_LENGTH_MAX + 1];
  1261. statsd_get_metric_type_and_id(m, type, id, dim, RRD_ID_LENGTH_MAX);
  1262. char context[RRD_ID_LENGTH_MAX + 1];
  1263. snprintfz(context, RRD_ID_LENGTH_MAX, "statsd_%s.%s", dim, m->name);
  1264. char title[RRD_ID_LENGTH_MAX + 1];
  1265. snprintfz(title, RRD_ID_LENGTH_MAX, "statsd private chart for %s %s", dim, m->name);
  1266. m->st = statsd_private_rrdset_create(
  1267. m
  1268. , type
  1269. , id
  1270. , NULL // name
  1271. , family // family (submenu)
  1272. , context // context
  1273. , title // title
  1274. , "events/s" // units
  1275. , NETDATA_CHART_PRIO_STATSD_PRIVATE
  1276. , statsd.update_every
  1277. , RRDSET_TYPE_AREA
  1278. );
  1279. m->rd_value = rrddim_add(m->st, dim, NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1280. if(m->options & STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT)
  1281. m->rd_count = rrddim_add(m->st, "events", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1282. }
  1283. else rrdset_next(m->st);
  1284. rrddim_set_by_pointer(m->st, m->rd_value, m->last);
  1285. if(m->rd_count)
  1286. rrddim_set_by_pointer(m->st, m->rd_count, m->events);
  1287. rrdset_done(m->st);
  1288. }
  1289. static inline void statsd_private_chart_set(STATSD_METRIC *m) {
  1290. debug(D_STATSD, "updating private chart for set metric '%s'", m->name);
  1291. if(unlikely(!m->st)) {
  1292. char type[RRD_ID_LENGTH_MAX + 1], id[RRD_ID_LENGTH_MAX + 1];
  1293. statsd_get_metric_type_and_id(m, type, id, "set", RRD_ID_LENGTH_MAX);
  1294. char context[RRD_ID_LENGTH_MAX + 1];
  1295. snprintfz(context, RRD_ID_LENGTH_MAX, "statsd_set.%s", m->name);
  1296. char title[RRD_ID_LENGTH_MAX + 1];
  1297. snprintfz(title, RRD_ID_LENGTH_MAX, "statsd private chart for set %s", m->name);
  1298. m->st = statsd_private_rrdset_create(
  1299. m
  1300. , type
  1301. , id
  1302. , NULL // name
  1303. , "sets" // family (submenu)
  1304. , context // context
  1305. , title // title
  1306. , "entries" // units
  1307. , NETDATA_CHART_PRIO_STATSD_PRIVATE
  1308. , statsd.update_every
  1309. , RRDSET_TYPE_LINE
  1310. );
  1311. m->rd_value = rrddim_add(m->st, "set", "set size", 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1312. if(m->options & STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT)
  1313. m->rd_count = rrddim_add(m->st, "events", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1314. }
  1315. else rrdset_next(m->st);
  1316. rrddim_set_by_pointer(m->st, m->rd_value, m->last);
  1317. if(m->rd_count)
  1318. rrddim_set_by_pointer(m->st, m->rd_count, m->events);
  1319. rrdset_done(m->st);
  1320. }
  1321. static inline void statsd_private_chart_timer_or_histogram(STATSD_METRIC *m, const char *dim, const char *family, const char *units) {
  1322. debug(D_STATSD, "updating private chart for %s metric '%s'", dim, m->name);
  1323. if(unlikely(!m->st)) {
  1324. char type[RRD_ID_LENGTH_MAX + 1], id[RRD_ID_LENGTH_MAX + 1];
  1325. statsd_get_metric_type_and_id(m, type, id, dim, RRD_ID_LENGTH_MAX);
  1326. char context[RRD_ID_LENGTH_MAX + 1];
  1327. snprintfz(context, RRD_ID_LENGTH_MAX, "statsd_%s.%s", dim, m->name);
  1328. char title[RRD_ID_LENGTH_MAX + 1];
  1329. snprintfz(title, RRD_ID_LENGTH_MAX, "statsd private chart for %s %s", dim, m->name);
  1330. m->st = statsd_private_rrdset_create(
  1331. m
  1332. , type
  1333. , id
  1334. , NULL // name
  1335. , family // family (submenu)
  1336. , context // context
  1337. , title // title
  1338. , units // units
  1339. , NETDATA_CHART_PRIO_STATSD_PRIVATE
  1340. , statsd.update_every
  1341. , RRDSET_TYPE_AREA
  1342. );
  1343. m->histogram.ext->rd_min = rrddim_add(m->st, "min", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1344. m->histogram.ext->rd_max = rrddim_add(m->st, "max", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1345. m->rd_value = rrddim_add(m->st, "average", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1346. m->histogram.ext->rd_percentile = rrddim_add(m->st, statsd.histogram_percentile_str, NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1347. m->histogram.ext->rd_median = rrddim_add(m->st, "median", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1348. m->histogram.ext->rd_stddev = rrddim_add(m->st, "stddev", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1349. m->histogram.ext->rd_sum = rrddim_add(m->st, "sum", NULL, 1, statsd.decimal_detail, RRD_ALGORITHM_ABSOLUTE);
  1350. if(m->options & STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT)
  1351. m->rd_count = rrddim_add(m->st, "events", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1352. }
  1353. else rrdset_next(m->st);
  1354. rrddim_set_by_pointer(m->st, m->histogram.ext->rd_min, m->histogram.ext->last_min);
  1355. rrddim_set_by_pointer(m->st, m->histogram.ext->rd_max, m->histogram.ext->last_max);
  1356. rrddim_set_by_pointer(m->st, m->histogram.ext->rd_percentile, m->histogram.ext->last_percentile);
  1357. rrddim_set_by_pointer(m->st, m->histogram.ext->rd_median, m->histogram.ext->last_median);
  1358. rrddim_set_by_pointer(m->st, m->histogram.ext->rd_stddev, m->histogram.ext->last_stddev);
  1359. rrddim_set_by_pointer(m->st, m->histogram.ext->rd_sum, m->histogram.ext->last_sum);
  1360. rrddim_set_by_pointer(m->st, m->rd_value, m->last);
  1361. if(m->rd_count)
  1362. rrddim_set_by_pointer(m->st, m->rd_count, m->events);
  1363. rrdset_done(m->st);
  1364. }
  1365. // --------------------------------------------------------------------------------------------------------------------
  1366. // statsd flush metrics
  1367. static inline void statsd_flush_gauge(STATSD_METRIC *m) {
  1368. debug(D_STATSD, "flushing gauge metric '%s'", m->name);
  1369. int updated = 0;
  1370. if(unlikely(!m->reset && m->count)) {
  1371. m->last = (collected_number) (m->gauge.value * statsd.decimal_detail);
  1372. m->reset = 1;
  1373. updated = 1;
  1374. }
  1375. if(unlikely(m->options & STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED && (updated || !(m->options & STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED))))
  1376. statsd_private_chart_gauge(m);
  1377. }
  1378. static inline void statsd_flush_counter_or_meter(STATSD_METRIC *m, const char *dim, const char *family) {
  1379. debug(D_STATSD, "flushing %s metric '%s'", dim, m->name);
  1380. int updated = 0;
  1381. if(unlikely(!m->reset && m->count)) {
  1382. m->last = m->counter.value;
  1383. m->reset = 1;
  1384. updated = 1;
  1385. }
  1386. if(unlikely(m->options & STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED && (updated || !(m->options & STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED))))
  1387. statsd_private_chart_counter_or_meter(m, dim, family);
  1388. }
  1389. static inline void statsd_flush_counter(STATSD_METRIC *m) {
  1390. statsd_flush_counter_or_meter(m, "counter", "counters");
  1391. }
  1392. static inline void statsd_flush_meter(STATSD_METRIC *m) {
  1393. statsd_flush_counter_or_meter(m, "meter", "meters");
  1394. }
  1395. static inline void statsd_flush_set(STATSD_METRIC *m) {
  1396. debug(D_STATSD, "flushing set metric '%s'", m->name);
  1397. int updated = 0;
  1398. if(unlikely(!m->reset && m->count)) {
  1399. m->last = (collected_number)m->set.unique;
  1400. m->reset = 1;
  1401. updated = 1;
  1402. }
  1403. else {
  1404. m->last = 0;
  1405. }
  1406. if(unlikely(m->options & STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED && (updated || !(m->options & STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED))))
  1407. statsd_private_chart_set(m);
  1408. }
  1409. static inline void statsd_flush_timer_or_histogram(STATSD_METRIC *m, const char *dim, const char *family, const char *units) {
  1410. debug(D_STATSD, "flushing %s metric '%s'", dim, m->name);
  1411. int updated = 0;
  1412. if(unlikely(!m->reset && m->count && m->histogram.ext->used > 0)) {
  1413. netdata_mutex_lock(&m->histogram.ext->mutex);
  1414. size_t len = m->histogram.ext->used;
  1415. LONG_DOUBLE *series = m->histogram.ext->values;
  1416. sort_series(series, len);
  1417. m->histogram.ext->last_min = (collected_number)roundl(series[0] * statsd.decimal_detail);
  1418. m->histogram.ext->last_max = (collected_number)roundl(series[len - 1] * statsd.decimal_detail);
  1419. m->last = (collected_number)roundl(average(series, len) * statsd.decimal_detail);
  1420. m->histogram.ext->last_median = (collected_number)roundl(median_on_sorted_series(series, len) * statsd.decimal_detail);
  1421. m->histogram.ext->last_stddev = (collected_number)roundl(standard_deviation(series, len) * statsd.decimal_detail);
  1422. m->histogram.ext->last_sum = (collected_number)roundl(sum(series, len) * statsd.decimal_detail);
  1423. size_t pct_len = (size_t)floor((double)len * statsd.histogram_percentile / 100.0);
  1424. if(pct_len < 1)
  1425. m->histogram.ext->last_percentile = (collected_number)(series[0] * statsd.decimal_detail);
  1426. else
  1427. m->histogram.ext->last_percentile = (collected_number)roundl(series[pct_len - 1] * statsd.decimal_detail);
  1428. netdata_mutex_unlock(&m->histogram.ext->mutex);
  1429. debug(D_STATSD, "STATSD %s metric %s: min " COLLECTED_NUMBER_FORMAT ", max " COLLECTED_NUMBER_FORMAT ", last " COLLECTED_NUMBER_FORMAT ", pcent " COLLECTED_NUMBER_FORMAT ", median " COLLECTED_NUMBER_FORMAT ", stddev " COLLECTED_NUMBER_FORMAT ", sum " COLLECTED_NUMBER_FORMAT,
  1430. dim, m->name, m->histogram.ext->last_min, m->histogram.ext->last_max, m->last, m->histogram.ext->last_percentile, m->histogram.ext->last_median, m->histogram.ext->last_stddev, m->histogram.ext->last_sum);
  1431. m->histogram.ext->zeroed = 0;
  1432. m->reset = 1;
  1433. updated = 1;
  1434. }
  1435. else if(unlikely(!m->histogram.ext->zeroed)) {
  1436. // reset the metrics
  1437. // if we collected anything, they will be updated below
  1438. // this ensures that we report zeros if nothing is collected
  1439. m->histogram.ext->last_min = 0;
  1440. m->histogram.ext->last_max = 0;
  1441. m->last = 0;
  1442. m->histogram.ext->last_median = 0;
  1443. m->histogram.ext->last_stddev = 0;
  1444. m->histogram.ext->last_sum = 0;
  1445. m->histogram.ext->last_percentile = 0;
  1446. m->histogram.ext->zeroed = 1;
  1447. }
  1448. if(unlikely(m->options & STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED && (updated || !(m->options & STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED))))
  1449. statsd_private_chart_timer_or_histogram(m, dim, family, units);
  1450. }
  1451. static inline void statsd_flush_timer(STATSD_METRIC *m) {
  1452. statsd_flush_timer_or_histogram(m, "timer", "timers", "milliseconds");
  1453. }
  1454. static inline void statsd_flush_histogram(STATSD_METRIC *m) {
  1455. statsd_flush_timer_or_histogram(m, "histogram", "histograms", "value");
  1456. }
  1457. static inline RRD_ALGORITHM statsd_algorithm_for_metric(STATSD_METRIC *m) {
  1458. switch(m->type) {
  1459. default:
  1460. case STATSD_METRIC_TYPE_GAUGE:
  1461. case STATSD_METRIC_TYPE_SET:
  1462. case STATSD_METRIC_TYPE_TIMER:
  1463. case STATSD_METRIC_TYPE_HISTOGRAM:
  1464. return RRD_ALGORITHM_ABSOLUTE;
  1465. case STATSD_METRIC_TYPE_METER:
  1466. case STATSD_METRIC_TYPE_COUNTER:
  1467. return RRD_ALGORITHM_INCREMENTAL;
  1468. }
  1469. }
  1470. static inline void link_metric_to_app_dimension(STATSD_APP *app, STATSD_METRIC *m, STATSD_APP_CHART *chart, STATSD_APP_CHART_DIM *dim) {
  1471. if(dim->value_type == STATSD_APP_CHART_DIM_VALUE_TYPE_EVENTS) {
  1472. dim->value_ptr = &m->events;
  1473. dim->algorithm = RRD_ALGORITHM_INCREMENTAL;
  1474. }
  1475. else if(m->type == STATSD_METRIC_TYPE_HISTOGRAM || m->type == STATSD_METRIC_TYPE_TIMER) {
  1476. dim->algorithm = RRD_ALGORITHM_ABSOLUTE;
  1477. dim->divisor *= statsd.decimal_detail;
  1478. switch(dim->value_type) {
  1479. case STATSD_APP_CHART_DIM_VALUE_TYPE_EVENTS:
  1480. // will never match - added to avoid warning
  1481. break;
  1482. case STATSD_APP_CHART_DIM_VALUE_TYPE_LAST:
  1483. case STATSD_APP_CHART_DIM_VALUE_TYPE_AVERAGE:
  1484. dim->value_ptr = &m->last;
  1485. break;
  1486. case STATSD_APP_CHART_DIM_VALUE_TYPE_SUM:
  1487. dim->value_ptr = &m->histogram.ext->last_sum;
  1488. break;
  1489. case STATSD_APP_CHART_DIM_VALUE_TYPE_MIN:
  1490. dim->value_ptr = &m->histogram.ext->last_min;
  1491. break;
  1492. case STATSD_APP_CHART_DIM_VALUE_TYPE_MAX:
  1493. dim->value_ptr = &m->histogram.ext->last_max;
  1494. break;
  1495. case STATSD_APP_CHART_DIM_VALUE_TYPE_MEDIAN:
  1496. dim->value_ptr = &m->histogram.ext->last_median;
  1497. break;
  1498. case STATSD_APP_CHART_DIM_VALUE_TYPE_PERCENTILE:
  1499. dim->value_ptr = &m->histogram.ext->last_percentile;
  1500. break;
  1501. case STATSD_APP_CHART_DIM_VALUE_TYPE_STDDEV:
  1502. dim->value_ptr = &m->histogram.ext->last_stddev;
  1503. break;
  1504. }
  1505. }
  1506. else {
  1507. if (dim->value_type != STATSD_APP_CHART_DIM_VALUE_TYPE_LAST)
  1508. error("STATSD: unsupported value type for dimension '%s' of chart '%s' of app '%s' on metric '%s'", dim->name, chart->id, app->name, m->name);
  1509. dim->value_ptr = &m->last;
  1510. dim->algorithm = statsd_algorithm_for_metric(m);
  1511. if(m->type == STATSD_METRIC_TYPE_GAUGE)
  1512. dim->divisor *= statsd.decimal_detail;
  1513. }
  1514. if(unlikely(chart->st && dim->rd)) {
  1515. rrddim_set_algorithm(chart->st, dim->rd, dim->algorithm);
  1516. rrddim_set_multiplier(chart->st, dim->rd, dim->multiplier);
  1517. rrddim_set_divisor(chart->st, dim->rd, dim->divisor);
  1518. }
  1519. chart->dimensions_linked_count++;
  1520. m->options |= STATSD_METRIC_OPTION_USED_IN_APPS;
  1521. debug(D_STATSD, "metric '%s' of type %u linked with app '%s', chart '%s', dimension '%s', algorithm '%s'", m->name, m->type, app->name, chart->id, dim->name, rrd_algorithm_name(dim->algorithm));
  1522. }
  1523. static inline void check_if_metric_is_for_app(STATSD_INDEX *index, STATSD_METRIC *m) {
  1524. (void)index;
  1525. STATSD_APP *app;
  1526. for(app = statsd.apps; app ;app = app->next) {
  1527. if(unlikely(simple_pattern_matches(app->metrics, m->name))) {
  1528. debug(D_STATSD, "metric '%s' matches app '%s'", m->name, app->name);
  1529. // the metric should get the options from the app
  1530. if(app->default_options & STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED)
  1531. m->options |= STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1532. else
  1533. m->options &= ~STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1534. if(app->default_options & STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED)
  1535. m->options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1536. else
  1537. m->options &= ~STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1538. m->options |= STATSD_METRIC_OPTION_PRIVATE_CHART_CHECKED;
  1539. // check if there is a chart in this app, willing to get this metric
  1540. STATSD_APP_CHART *chart;
  1541. for(chart = app->charts; chart; chart = chart->next) {
  1542. STATSD_APP_CHART_DIM *dim;
  1543. for(dim = chart->dimensions; dim ; dim = dim->next) {
  1544. if(unlikely(dim->metric_pattern)) {
  1545. size_t dim_name_len = strlen(dim->name);
  1546. size_t wildcarded_len = dim_name_len + strlen(m->name) + 1;
  1547. char wildcarded[wildcarded_len];
  1548. strcpy(wildcarded, dim->name);
  1549. char *ws = &wildcarded[dim_name_len];
  1550. if(simple_pattern_matches_extract(dim->metric_pattern, m->name, ws, wildcarded_len - dim_name_len)) {
  1551. char *final_name = NULL;
  1552. if(app->dict) {
  1553. if(likely(*wildcarded)) {
  1554. // use the name of the wildcarded string
  1555. final_name = dictionary_get(app->dict, wildcarded);
  1556. }
  1557. if(unlikely(!final_name)) {
  1558. // use the name of the metric
  1559. final_name = dictionary_get(app->dict, m->name);
  1560. }
  1561. }
  1562. if(unlikely(!final_name))
  1563. final_name = wildcarded;
  1564. add_dimension_to_app_chart(
  1565. app
  1566. , chart
  1567. , m->name
  1568. , final_name
  1569. , dim->multiplier
  1570. , dim->divisor
  1571. , dim->flags
  1572. , dim->value_type
  1573. );
  1574. // the new dimension is appended to the list
  1575. // so, it will be matched and linked later too
  1576. }
  1577. }
  1578. else if(!dim->value_ptr && dim->metric_hash == m->hash && !strcmp(dim->metric, m->name)) {
  1579. // we have a match - this metric should be linked to this dimension
  1580. link_metric_to_app_dimension(app, m, chart, dim);
  1581. }
  1582. }
  1583. }
  1584. }
  1585. }
  1586. }
  1587. static inline RRDDIM *statsd_add_dim_to_app_chart(STATSD_APP *app, STATSD_APP_CHART *chart, STATSD_APP_CHART_DIM *dim) {
  1588. (void)app;
  1589. // allow the same statsd metric to be added multiple times to the same chart
  1590. STATSD_APP_CHART_DIM *tdim;
  1591. size_t count_same_metric = 0, count_same_metric_value_type = 0;
  1592. size_t pos_same_metric_value_type = 0;
  1593. for (tdim = chart->dimensions; tdim && tdim->next; tdim = tdim->next) {
  1594. if (dim->metric_hash == tdim->metric_hash && !strcmp(dim->metric, tdim->metric)) {
  1595. count_same_metric++;
  1596. if(dim->value_type == tdim->value_type) {
  1597. count_same_metric_value_type++;
  1598. if (tdim == dim)
  1599. pos_same_metric_value_type = count_same_metric_value_type;
  1600. }
  1601. }
  1602. }
  1603. if(count_same_metric > 1) {
  1604. // the same metric is found multiple times
  1605. size_t len = strlen(dim->metric) + 100;
  1606. char metric[ len + 1 ];
  1607. if(count_same_metric_value_type > 1) {
  1608. // the same metric, with the same value type, is added multiple times
  1609. snprintfz(metric, len, "%s_%s%zu", dim->metric, valuetype2string(dim->value_type), pos_same_metric_value_type);
  1610. }
  1611. else {
  1612. // the same metric, with different value type is added
  1613. snprintfz(metric, len, "%s_%s", dim->metric, valuetype2string(dim->value_type));
  1614. }
  1615. dim->rd = rrddim_add(chart->st, metric, dim->name, dim->multiplier, dim->divisor, dim->algorithm);
  1616. if(dim->flags != RRDDIM_FLAG_NONE) dim->rd->flags |= dim->flags;
  1617. return dim->rd;
  1618. }
  1619. dim->rd = rrddim_add(chart->st, dim->metric, dim->name, dim->multiplier, dim->divisor, dim->algorithm);
  1620. if(dim->flags != RRDDIM_FLAG_NONE) dim->rd->flags |= dim->flags;
  1621. return dim->rd;
  1622. }
  1623. static inline void statsd_update_app_chart(STATSD_APP *app, STATSD_APP_CHART *chart) {
  1624. debug(D_STATSD, "updating chart '%s' for app '%s'", chart->id, app->name);
  1625. if(!chart->st) {
  1626. chart->st = rrdset_create_custom(
  1627. localhost // host
  1628. , app->name // type
  1629. , chart->id // id
  1630. , chart->name // name
  1631. , chart->family // family
  1632. , chart->context // context
  1633. , chart->title // title
  1634. , chart->units // units
  1635. , PLUGIN_STATSD_NAME // plugin
  1636. , chart->source // module
  1637. , chart->priority // priority
  1638. , statsd.update_every // update every
  1639. , chart->chart_type // chart type
  1640. , app->rrd_memory_mode // memory mode
  1641. , app->rrd_history_entries // history
  1642. );
  1643. rrdset_flag_set(chart->st, RRDSET_FLAG_STORE_FIRST);
  1644. // rrdset_flag_set(chart->st, RRDSET_FLAG_DEBUG);
  1645. }
  1646. else rrdset_next(chart->st);
  1647. STATSD_APP_CHART_DIM *dim;
  1648. for(dim = chart->dimensions; dim ;dim = dim->next) {
  1649. if(likely(!dim->metric_pattern)) {
  1650. if (unlikely(!dim->rd))
  1651. statsd_add_dim_to_app_chart(app, chart, dim);
  1652. if (unlikely(dim->value_ptr)) {
  1653. debug(D_STATSD, "updating dimension '%s' (%s) of chart '%s' (%s) for app '%s' with value " COLLECTED_NUMBER_FORMAT, dim->name, dim->rd->id, chart->id, chart->st->id, app->name, *dim->value_ptr);
  1654. rrddim_set_by_pointer(chart->st, dim->rd, *dim->value_ptr);
  1655. }
  1656. }
  1657. }
  1658. rrdset_done(chart->st);
  1659. debug(D_STATSD, "completed update of chart '%s' for app '%s'", chart->id, app->name);
  1660. }
  1661. static inline void statsd_update_all_app_charts(void) {
  1662. // debug(D_STATSD, "updating app charts");
  1663. STATSD_APP *app;
  1664. for(app = statsd.apps; app ;app = app->next) {
  1665. // debug(D_STATSD, "updating charts for app '%s'", app->name);
  1666. STATSD_APP_CHART *chart;
  1667. for(chart = app->charts; chart ;chart = chart->next) {
  1668. if(unlikely(chart->dimensions_linked_count)) {
  1669. statsd_update_app_chart(app, chart);
  1670. }
  1671. }
  1672. }
  1673. // debug(D_STATSD, "completed update of app charts");
  1674. }
  1675. const char *statsd_metric_type_string(STATSD_METRIC_TYPE type) {
  1676. switch(type) {
  1677. case STATSD_METRIC_TYPE_COUNTER: return "counter";
  1678. case STATSD_METRIC_TYPE_GAUGE: return "gauge";
  1679. case STATSD_METRIC_TYPE_HISTOGRAM: return "histogram";
  1680. case STATSD_METRIC_TYPE_METER: return "meter";
  1681. case STATSD_METRIC_TYPE_SET: return "set";
  1682. case STATSD_METRIC_TYPE_TIMER: return "timer";
  1683. default: return "unknown";
  1684. }
  1685. }
  1686. static inline void statsd_flush_index_metrics(STATSD_INDEX *index, void (*flush_metric)(STATSD_METRIC *)) {
  1687. STATSD_METRIC *m;
  1688. // find the useful metrics (incremental = each time we are called, we check the new metrics only)
  1689. for(m = index->first; m ; m = m->next) {
  1690. // since we add new metrics at the beginning
  1691. // check for useful charts, until the point we last checked
  1692. if(unlikely(is_metric_checked(m))) break;
  1693. if(unlikely(!(m->options & STATSD_METRIC_OPTION_CHECKED_IN_APPS))) {
  1694. log_access("NEW STATSD METRIC '%s': '%s'", statsd_metric_type_string(m->type), m->name);
  1695. check_if_metric_is_for_app(index, m);
  1696. m->options |= STATSD_METRIC_OPTION_CHECKED_IN_APPS;
  1697. }
  1698. if(unlikely(!(m->options & STATSD_METRIC_OPTION_PRIVATE_CHART_CHECKED))) {
  1699. if(unlikely(statsd.private_charts >= statsd.max_private_charts_hard)) {
  1700. debug(D_STATSD, "STATSD: metric '%s' will not be charted, because the hard limit of the maximum number of charts has been reached.", m->name);
  1701. info("STATSD: metric '%s' will not be charted, because the hard limit of the maximum number of charts (%zu) has been reached. Increase the number of charts by editing netdata.conf, [statsd] section.", m->name, statsd.max_private_charts);
  1702. m->options &= ~STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1703. }
  1704. else {
  1705. if (simple_pattern_matches(statsd.charts_for, m->name)) {
  1706. debug(D_STATSD, "STATSD: metric '%s' will be charted.", m->name);
  1707. m->options |= STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1708. } else {
  1709. debug(D_STATSD, "STATSD: metric '%s' will not be charted.", m->name);
  1710. m->options &= ~STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED;
  1711. }
  1712. }
  1713. m->options |= STATSD_METRIC_OPTION_PRIVATE_CHART_CHECKED;
  1714. }
  1715. // mark it as checked
  1716. m->options |= STATSD_METRIC_OPTION_CHECKED;
  1717. // check if it is used in charts
  1718. if((m->options & (STATSD_METRIC_OPTION_PRIVATE_CHART_ENABLED|STATSD_METRIC_OPTION_USED_IN_APPS)) && !(m->options & STATSD_METRIC_OPTION_USEFUL)) {
  1719. m->options |= STATSD_METRIC_OPTION_USEFUL;
  1720. index->useful++;
  1721. m->next_useful = index->first_useful;
  1722. index->first_useful = m;
  1723. }
  1724. }
  1725. // flush all the useful metrics
  1726. for(m = index->first_useful; m ; m = m->next_useful) {
  1727. flush_metric(m);
  1728. }
  1729. }
  1730. // --------------------------------------------------------------------------------------
  1731. // statsd main thread
  1732. static int statsd_listen_sockets_setup(void) {
  1733. return listen_sockets_setup(&statsd.sockets);
  1734. }
  1735. static void statsd_main_cleanup(void *data) {
  1736. struct netdata_static_thread *static_thread = (struct netdata_static_thread *)data;
  1737. static_thread->enabled = NETDATA_MAIN_THREAD_EXITING;
  1738. info("cleaning up...");
  1739. if (statsd.collection_threads_status) {
  1740. int i;
  1741. for (i = 0; i < statsd.threads; i++) {
  1742. if(statsd.collection_threads_status[i].status) {
  1743. info("STATSD: stopping data collection thread %d...", i + 1);
  1744. netdata_thread_cancel(statsd.collection_threads_status[i].thread);
  1745. }
  1746. else {
  1747. info("STATSD: data collection thread %d found stopped.", i + 1);
  1748. }
  1749. }
  1750. }
  1751. info("STATSD: closing sockets...");
  1752. listen_sockets_close(&statsd.sockets);
  1753. info("STATSD: cleanup completed.");
  1754. static_thread->enabled = NETDATA_MAIN_THREAD_EXITED;
  1755. }
  1756. void *statsd_main(void *ptr) {
  1757. netdata_thread_cleanup_push(statsd_main_cleanup, ptr);
  1758. // ----------------------------------------------------------------------------------------------------------------
  1759. // statsd configuration
  1760. statsd.enabled = config_get_boolean(CONFIG_SECTION_STATSD, "enabled", statsd.enabled);
  1761. statsd.update_every = default_rrd_update_every;
  1762. statsd.update_every = (int)config_get_number(CONFIG_SECTION_STATSD, "update every (flushInterval)", statsd.update_every);
  1763. if(statsd.update_every < default_rrd_update_every) {
  1764. error("STATSD: minimum flush interval %d given, but the minimum is the update every of netdata. Using %d", statsd.update_every, default_rrd_update_every);
  1765. statsd.update_every = default_rrd_update_every;
  1766. }
  1767. #ifdef HAVE_RECVMMSG
  1768. statsd.recvmmsg_size = (size_t)config_get_number(CONFIG_SECTION_STATSD, "udp messages to process at once", (long long)statsd.recvmmsg_size);
  1769. #endif
  1770. statsd.charts_for = simple_pattern_create(config_get(CONFIG_SECTION_STATSD, "create private charts for metrics matching", "*"), NULL, SIMPLE_PATTERN_EXACT);
  1771. statsd.max_private_charts = (size_t)config_get_number(CONFIG_SECTION_STATSD, "max private charts allowed", (long long)statsd.max_private_charts);
  1772. statsd.max_private_charts_hard = (size_t)config_get_number(CONFIG_SECTION_STATSD, "max private charts hard limit", (long long)statsd.max_private_charts * 5);
  1773. statsd.private_charts_memory_mode = rrd_memory_mode_id(config_get(CONFIG_SECTION_STATSD, "private charts memory mode", rrd_memory_mode_name(default_rrd_memory_mode)));
  1774. statsd.private_charts_rrd_history_entries = (int)config_get_number(CONFIG_SECTION_STATSD, "private charts history", default_rrd_history_entries);
  1775. statsd.decimal_detail = (collected_number)config_get_number(CONFIG_SECTION_STATSD, "decimal detail", (long long int)statsd.decimal_detail);
  1776. statsd.tcp_idle_timeout = (size_t) config_get_number(CONFIG_SECTION_STATSD, "disconnect idle tcp clients after seconds", (long long int)statsd.tcp_idle_timeout);
  1777. statsd.private_charts_hidden = (unsigned int)config_get_boolean(CONFIG_SECTION_STATSD, "private charts hidden", statsd.private_charts_hidden);
  1778. statsd.histogram_percentile = (double)config_get_float(CONFIG_SECTION_STATSD, "histograms and timers percentile (percentThreshold)", statsd.histogram_percentile);
  1779. if(isless(statsd.histogram_percentile, 0) || isgreater(statsd.histogram_percentile, 100)) {
  1780. error("STATSD: invalid histograms and timers percentile %0.5f given", statsd.histogram_percentile);
  1781. statsd.histogram_percentile = 95.0;
  1782. }
  1783. {
  1784. char buffer[100 + 1];
  1785. snprintf(buffer, 100, "%0.1f%%", statsd.histogram_percentile);
  1786. statsd.histogram_percentile_str = strdupz(buffer);
  1787. }
  1788. if(config_get_boolean(CONFIG_SECTION_STATSD, "add dimension for number of events received", 1)) {
  1789. statsd.gauges.default_options |= STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT;
  1790. statsd.counters.default_options |= STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT;
  1791. statsd.meters.default_options |= STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT;
  1792. statsd.sets.default_options |= STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT;
  1793. statsd.histograms.default_options |= STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT;
  1794. statsd.timers.default_options |= STATSD_METRIC_OPTION_CHART_DIMENSION_COUNT;
  1795. }
  1796. if(config_get_boolean(CONFIG_SECTION_STATSD, "gaps on gauges (deleteGauges)", 0))
  1797. statsd.gauges.default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1798. if(config_get_boolean(CONFIG_SECTION_STATSD, "gaps on counters (deleteCounters)", 0))
  1799. statsd.counters.default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1800. if(config_get_boolean(CONFIG_SECTION_STATSD, "gaps on meters (deleteMeters)", 0))
  1801. statsd.meters.default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1802. if(config_get_boolean(CONFIG_SECTION_STATSD, "gaps on sets (deleteSets)", 0))
  1803. statsd.sets.default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1804. if(config_get_boolean(CONFIG_SECTION_STATSD, "gaps on histograms (deleteHistograms)", 0))
  1805. statsd.histograms.default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1806. if(config_get_boolean(CONFIG_SECTION_STATSD, "gaps on timers (deleteTimers)", 0))
  1807. statsd.timers.default_options |= STATSD_METRIC_OPTION_SHOW_GAPS_WHEN_NOT_COLLECTED;
  1808. size_t max_sockets = (size_t)config_get_number(CONFIG_SECTION_STATSD, "statsd server max TCP sockets", (long long int)(rlimit_nofile.rlim_cur / 4));
  1809. #ifdef STATSD_MULTITHREADED
  1810. statsd.threads = (int)config_get_number(CONFIG_SECTION_STATSD, "threads", processors);
  1811. if(statsd.threads < 1) {
  1812. error("STATSD: Invalid number of threads %d, using %d", statsd.threads, processors);
  1813. statsd.threads = processors;
  1814. config_set_number(CONFIG_SECTION_STATSD, "collector threads", statsd.threads);
  1815. }
  1816. #else
  1817. statsd.threads = 1;
  1818. #endif
  1819. // read custom application definitions
  1820. statsd_readdir(netdata_configured_user_config_dir, netdata_configured_stock_config_dir, "statsd.d");
  1821. // ----------------------------------------------------------------------------------------------------------------
  1822. // statsd setup
  1823. if(!statsd.enabled) return NULL;
  1824. statsd_listen_sockets_setup();
  1825. if(!statsd.sockets.opened) {
  1826. error("STATSD: No statsd sockets to listen to. statsd will be disabled.");
  1827. goto cleanup;
  1828. }
  1829. statsd.collection_threads_status = callocz((size_t)statsd.threads, sizeof(struct collection_thread_status));
  1830. int i;
  1831. for(i = 0; i < statsd.threads ;i++) {
  1832. statsd.collection_threads_status[i].max_sockets = max_sockets / statsd.threads;
  1833. char tag[NETDATA_THREAD_TAG_MAX + 1];
  1834. snprintfz(tag, NETDATA_THREAD_TAG_MAX, "STATSD_COLLECTOR[%d]", i + 1);
  1835. netdata_thread_create(&statsd.collection_threads_status[i].thread, tag, NETDATA_THREAD_OPTION_DEFAULT, statsd_collector_thread, &statsd.collection_threads_status[i]);
  1836. }
  1837. // ----------------------------------------------------------------------------------------------------------------
  1838. // statsd monitoring charts
  1839. RRDSET *st_metrics = rrdset_create_localhost(
  1840. "netdata"
  1841. , "statsd_metrics"
  1842. , NULL
  1843. , "statsd"
  1844. , NULL
  1845. , "Metrics in the netdata statsd database"
  1846. , "metrics"
  1847. , PLUGIN_STATSD_NAME
  1848. , "stats"
  1849. , 132010
  1850. , statsd.update_every
  1851. , RRDSET_TYPE_STACKED
  1852. );
  1853. RRDDIM *rd_metrics_gauge = rrddim_add(st_metrics, "gauges", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1854. RRDDIM *rd_metrics_counter = rrddim_add(st_metrics, "counters", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1855. RRDDIM *rd_metrics_timer = rrddim_add(st_metrics, "timers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1856. RRDDIM *rd_metrics_meter = rrddim_add(st_metrics, "meters", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1857. RRDDIM *rd_metrics_histogram = rrddim_add(st_metrics, "histograms", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1858. RRDDIM *rd_metrics_set = rrddim_add(st_metrics, "sets", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1859. RRDSET *st_useful_metrics = rrdset_create_localhost(
  1860. "netdata"
  1861. , "statsd_useful_metrics"
  1862. , NULL
  1863. , "statsd"
  1864. , NULL
  1865. , "Useful metrics in the netdata statsd database"
  1866. , "metrics"
  1867. , PLUGIN_STATSD_NAME
  1868. , "stats"
  1869. , 132010
  1870. , statsd.update_every
  1871. , RRDSET_TYPE_STACKED
  1872. );
  1873. RRDDIM *rd_useful_metrics_gauge = rrddim_add(st_useful_metrics, "gauges", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1874. RRDDIM *rd_useful_metrics_counter = rrddim_add(st_useful_metrics, "counters", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1875. RRDDIM *rd_useful_metrics_timer = rrddim_add(st_useful_metrics, "timers", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1876. RRDDIM *rd_useful_metrics_meter = rrddim_add(st_useful_metrics, "meters", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1877. RRDDIM *rd_useful_metrics_histogram = rrddim_add(st_useful_metrics, "histograms", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1878. RRDDIM *rd_useful_metrics_set = rrddim_add(st_useful_metrics, "sets", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1879. RRDSET *st_events = rrdset_create_localhost(
  1880. "netdata"
  1881. , "statsd_events"
  1882. , NULL
  1883. , "statsd"
  1884. , NULL
  1885. , "Events processed by the netdata statsd server"
  1886. , "events/s"
  1887. , PLUGIN_STATSD_NAME
  1888. , "stats"
  1889. , 132011
  1890. , statsd.update_every
  1891. , RRDSET_TYPE_STACKED
  1892. );
  1893. RRDDIM *rd_events_gauge = rrddim_add(st_events, "gauges", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1894. RRDDIM *rd_events_counter = rrddim_add(st_events, "counters", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1895. RRDDIM *rd_events_timer = rrddim_add(st_events, "timers", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1896. RRDDIM *rd_events_meter = rrddim_add(st_events, "meters", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1897. RRDDIM *rd_events_histogram = rrddim_add(st_events, "histograms", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1898. RRDDIM *rd_events_set = rrddim_add(st_events, "sets", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1899. RRDDIM *rd_events_unknown = rrddim_add(st_events, "unknown", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1900. RRDDIM *rd_events_errors = rrddim_add(st_events, "errors", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1901. RRDSET *st_reads = rrdset_create_localhost(
  1902. "netdata"
  1903. , "statsd_reads"
  1904. , NULL
  1905. , "statsd"
  1906. , NULL
  1907. , "Read operations made by the netdata statsd server"
  1908. , "reads/s"
  1909. , PLUGIN_STATSD_NAME
  1910. , "stats"
  1911. , 132012
  1912. , statsd.update_every
  1913. , RRDSET_TYPE_STACKED
  1914. );
  1915. RRDDIM *rd_reads_tcp = rrddim_add(st_reads, "tcp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1916. RRDDIM *rd_reads_udp = rrddim_add(st_reads, "udp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1917. RRDSET *st_bytes = rrdset_create_localhost(
  1918. "netdata"
  1919. , "statsd_bytes"
  1920. , NULL
  1921. , "statsd"
  1922. , NULL
  1923. , "Bytes read by the netdata statsd server"
  1924. , "kilobits/s"
  1925. , PLUGIN_STATSD_NAME
  1926. , "stats"
  1927. , 132013
  1928. , statsd.update_every
  1929. , RRDSET_TYPE_STACKED
  1930. );
  1931. RRDDIM *rd_bytes_tcp = rrddim_add(st_bytes, "tcp", NULL, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
  1932. RRDDIM *rd_bytes_udp = rrddim_add(st_bytes, "udp", NULL, 8, BITS_IN_A_KILOBIT, RRD_ALGORITHM_INCREMENTAL);
  1933. RRDSET *st_packets = rrdset_create_localhost(
  1934. "netdata"
  1935. , "statsd_packets"
  1936. , NULL
  1937. , "statsd"
  1938. , NULL
  1939. , "Network packets processed by the netdata statsd server"
  1940. , "packets/s"
  1941. , PLUGIN_STATSD_NAME
  1942. , "stats"
  1943. , 132014
  1944. , statsd.update_every
  1945. , RRDSET_TYPE_STACKED
  1946. );
  1947. RRDDIM *rd_packets_tcp = rrddim_add(st_packets, "tcp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1948. RRDDIM *rd_packets_udp = rrddim_add(st_packets, "udp", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1949. RRDSET *st_tcp_connects = rrdset_create_localhost(
  1950. "netdata"
  1951. , "tcp_connects"
  1952. , NULL
  1953. , "statsd"
  1954. , NULL
  1955. , "statsd server TCP connects and disconnects"
  1956. , "events"
  1957. , PLUGIN_STATSD_NAME
  1958. , "stats"
  1959. , 132015
  1960. , statsd.update_every
  1961. , RRDSET_TYPE_LINE
  1962. );
  1963. RRDDIM *rd_tcp_connects = rrddim_add(st_tcp_connects, "connects", NULL, 1, 1, RRD_ALGORITHM_INCREMENTAL);
  1964. RRDDIM *rd_tcp_disconnects = rrddim_add(st_tcp_connects, "disconnects", NULL, -1, 1, RRD_ALGORITHM_INCREMENTAL);
  1965. RRDSET *st_tcp_connected = rrdset_create_localhost(
  1966. "netdata"
  1967. , "tcp_connected"
  1968. , NULL
  1969. , "statsd"
  1970. , NULL
  1971. , "statsd server TCP connected sockets"
  1972. , "sockets"
  1973. , PLUGIN_STATSD_NAME
  1974. , "stats"
  1975. , 132016
  1976. , statsd.update_every
  1977. , RRDSET_TYPE_LINE
  1978. );
  1979. RRDDIM *rd_tcp_connected = rrddim_add(st_tcp_connected, "connected", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1980. RRDSET *st_pcharts = rrdset_create_localhost(
  1981. "netdata"
  1982. , "private_charts"
  1983. , NULL
  1984. , "statsd"
  1985. , NULL
  1986. , "Private metric charts created by the netdata statsd server"
  1987. , "charts"
  1988. , PLUGIN_STATSD_NAME
  1989. , "stats"
  1990. , 132020
  1991. , statsd.update_every
  1992. , RRDSET_TYPE_AREA
  1993. );
  1994. RRDDIM *rd_pcharts = rrddim_add(st_pcharts, "charts", NULL, 1, 1, RRD_ALGORITHM_ABSOLUTE);
  1995. RRDSET *stcpu_thread = rrdset_create_localhost(
  1996. "netdata"
  1997. , "plugin_statsd_charting_cpu"
  1998. , NULL
  1999. , "statsd"
  2000. , "netdata.statsd_cpu"
  2001. , "NetData statsd charting thread CPU usage"
  2002. , "milliseconds/s"
  2003. , PLUGIN_STATSD_NAME
  2004. , "stats"
  2005. , 132001
  2006. , statsd.update_every
  2007. , RRDSET_TYPE_STACKED
  2008. );
  2009. RRDDIM *rd_user = rrddim_add(stcpu_thread, "user", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL);
  2010. RRDDIM *rd_system = rrddim_add(stcpu_thread, "system", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL);
  2011. struct rusage thread;
  2012. for(i = 0; i < statsd.threads ;i++) {
  2013. char id[100 + 1];
  2014. char title[100 + 1];
  2015. snprintfz(id, 100, "plugin_statsd_collector%d_cpu", i + 1);
  2016. snprintfz(title, 100, "NetData statsd collector thread No %d CPU usage", i + 1);
  2017. statsd.collection_threads_status[i].st_cpu = rrdset_create_localhost(
  2018. "netdata"
  2019. , id
  2020. , NULL
  2021. , "statsd"
  2022. , "netdata.statsd_cpu"
  2023. , title
  2024. , "milliseconds/s"
  2025. , PLUGIN_STATSD_NAME
  2026. , "stats"
  2027. , 132002 + i
  2028. , statsd.update_every
  2029. , RRDSET_TYPE_STACKED
  2030. );
  2031. statsd.collection_threads_status[i].rd_user = rrddim_add(statsd.collection_threads_status[i].st_cpu, "user", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL);
  2032. statsd.collection_threads_status[i].rd_system = rrddim_add(statsd.collection_threads_status[i].st_cpu, "system", NULL, 1, 1000, RRD_ALGORITHM_INCREMENTAL);
  2033. }
  2034. // ----------------------------------------------------------------------------------------------------------------
  2035. // statsd thread to turn metrics into charts
  2036. usec_t step = statsd.update_every * USEC_PER_SEC;
  2037. heartbeat_t hb;
  2038. heartbeat_init(&hb);
  2039. while(!netdata_exit) {
  2040. usec_t hb_dt = heartbeat_next(&hb, step);
  2041. statsd_flush_index_metrics(&statsd.gauges, statsd_flush_gauge);
  2042. statsd_flush_index_metrics(&statsd.counters, statsd_flush_counter);
  2043. statsd_flush_index_metrics(&statsd.meters, statsd_flush_meter);
  2044. statsd_flush_index_metrics(&statsd.timers, statsd_flush_timer);
  2045. statsd_flush_index_metrics(&statsd.histograms, statsd_flush_histogram);
  2046. statsd_flush_index_metrics(&statsd.sets, statsd_flush_set);
  2047. statsd_update_all_app_charts();
  2048. getrusage(RUSAGE_THREAD, &thread);
  2049. if(unlikely(netdata_exit))
  2050. break;
  2051. if(likely(hb_dt)) {
  2052. rrdset_next(st_metrics);
  2053. rrdset_next(st_useful_metrics);
  2054. rrdset_next(st_events);
  2055. rrdset_next(st_reads);
  2056. rrdset_next(st_bytes);
  2057. rrdset_next(st_packets);
  2058. rrdset_next(st_tcp_connects);
  2059. rrdset_next(st_tcp_connected);
  2060. rrdset_next(st_pcharts);
  2061. rrdset_next(stcpu_thread);
  2062. for(i = 0; i < statsd.threads ;i++)
  2063. rrdset_next(statsd.collection_threads_status[i].st_cpu);
  2064. }
  2065. rrddim_set_by_pointer(st_metrics, rd_metrics_gauge, (collected_number)statsd.gauges.metrics);
  2066. rrddim_set_by_pointer(st_metrics, rd_metrics_counter, (collected_number)statsd.counters.metrics);
  2067. rrddim_set_by_pointer(st_metrics, rd_metrics_timer, (collected_number)statsd.timers.metrics);
  2068. rrddim_set_by_pointer(st_metrics, rd_metrics_meter, (collected_number)statsd.meters.metrics);
  2069. rrddim_set_by_pointer(st_metrics, rd_metrics_histogram, (collected_number)statsd.histograms.metrics);
  2070. rrddim_set_by_pointer(st_metrics, rd_metrics_set, (collected_number)statsd.sets.metrics);
  2071. rrdset_done(st_metrics);
  2072. rrddim_set_by_pointer(st_useful_metrics, rd_useful_metrics_gauge, (collected_number)statsd.gauges.useful);
  2073. rrddim_set_by_pointer(st_useful_metrics, rd_useful_metrics_counter, (collected_number)statsd.counters.useful);
  2074. rrddim_set_by_pointer(st_useful_metrics, rd_useful_metrics_timer, (collected_number)statsd.timers.useful);
  2075. rrddim_set_by_pointer(st_useful_metrics, rd_useful_metrics_meter, (collected_number)statsd.meters.useful);
  2076. rrddim_set_by_pointer(st_useful_metrics, rd_useful_metrics_histogram, (collected_number)statsd.histograms.useful);
  2077. rrddim_set_by_pointer(st_useful_metrics, rd_useful_metrics_set, (collected_number)statsd.sets.useful);
  2078. rrdset_done(st_useful_metrics);
  2079. rrddim_set_by_pointer(st_events, rd_events_gauge, (collected_number)statsd.gauges.events);
  2080. rrddim_set_by_pointer(st_events, rd_events_counter, (collected_number)statsd.counters.events);
  2081. rrddim_set_by_pointer(st_events, rd_events_timer, (collected_number)statsd.timers.events);
  2082. rrddim_set_by_pointer(st_events, rd_events_meter, (collected_number)statsd.meters.events);
  2083. rrddim_set_by_pointer(st_events, rd_events_histogram, (collected_number)statsd.histograms.events);
  2084. rrddim_set_by_pointer(st_events, rd_events_set, (collected_number)statsd.sets.events);
  2085. rrddim_set_by_pointer(st_events, rd_events_unknown, (collected_number)statsd.unknown_types);
  2086. rrddim_set_by_pointer(st_events, rd_events_errors, (collected_number)statsd.socket_errors);
  2087. rrdset_done(st_events);
  2088. rrddim_set_by_pointer(st_reads, rd_reads_tcp, (collected_number)statsd.tcp_socket_reads);
  2089. rrddim_set_by_pointer(st_reads, rd_reads_udp, (collected_number)statsd.udp_socket_reads);
  2090. rrdset_done(st_reads);
  2091. rrddim_set_by_pointer(st_bytes, rd_bytes_tcp, (collected_number)statsd.tcp_bytes_read);
  2092. rrddim_set_by_pointer(st_bytes, rd_bytes_udp, (collected_number)statsd.udp_bytes_read);
  2093. rrdset_done(st_bytes);
  2094. rrddim_set_by_pointer(st_packets, rd_packets_tcp, (collected_number)statsd.tcp_packets_received);
  2095. rrddim_set_by_pointer(st_packets, rd_packets_udp, (collected_number)statsd.udp_packets_received);
  2096. rrdset_done(st_packets);
  2097. rrddim_set_by_pointer(st_tcp_connects, rd_tcp_connects, (collected_number)statsd.tcp_socket_connects);
  2098. rrddim_set_by_pointer(st_tcp_connects, rd_tcp_disconnects, (collected_number)statsd.tcp_socket_disconnects);
  2099. rrdset_done(st_tcp_connects);
  2100. rrddim_set_by_pointer(st_tcp_connected, rd_tcp_connected, (collected_number)statsd.tcp_socket_connected);
  2101. rrdset_done(st_tcp_connected);
  2102. rrddim_set_by_pointer(st_pcharts, rd_pcharts, (collected_number)statsd.private_charts);
  2103. rrdset_done(st_pcharts);
  2104. rrddim_set_by_pointer(stcpu_thread, rd_user, thread.ru_utime.tv_sec * 1000000ULL + thread.ru_utime.tv_usec);
  2105. rrddim_set_by_pointer(stcpu_thread, rd_system, thread.ru_stime.tv_sec * 1000000ULL + thread.ru_stime.tv_usec);
  2106. rrdset_done(stcpu_thread);
  2107. for(i = 0; i < statsd.threads ;i++) {
  2108. rrddim_set_by_pointer(statsd.collection_threads_status[i].st_cpu, statsd.collection_threads_status[i].rd_user, statsd.collection_threads_status[i].rusage.ru_utime.tv_sec * 1000000ULL + statsd.collection_threads_status[i].rusage.ru_utime.tv_usec);
  2109. rrddim_set_by_pointer(statsd.collection_threads_status[i].st_cpu, statsd.collection_threads_status[i].rd_system, statsd.collection_threads_status[i].rusage.ru_stime.tv_sec * 1000000ULL + statsd.collection_threads_status[i].rusage.ru_stime.tv_usec);
  2110. rrdset_done(statsd.collection_threads_status[i].st_cpu);
  2111. }
  2112. }
  2113. cleanup: ; // added semi-colon to prevent older gcc error: label at end of compound statement
  2114. netdata_thread_cleanup_pop(1);
  2115. return NULL;
  2116. }