Asterisk - The Open Source Telephony Project  21.4.1
Data Structures | Macros | Enumerations | Functions
res_prometheus.h File Reference

Asterisk Prometheus Metrics. More...

#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/stringfields.h"

Go to the source code of this file.

Data Structures

struct  prometheus_callback
 Defines a callback that will be invoked when the HTTP route is called. More...
 
struct  prometheus_general_config
 Prometheus general configuration. More...
 
struct  prometheus_label
 A label that further defines a metric. More...
 
struct  prometheus_metric
 An actual, honest to god, metric. More...
 
struct  prometheus_metrics_provider
 A function table for a metrics provider. More...
 

Macros

#define PROMETHEUS_MAX_LABEL_LENGTH   128
 How long a label value can be.
 
#define PROMETHEUS_MAX_LABELS   8
 How many labels a single metric can have.
 
#define PROMETHEUS_MAX_NAME_LENGTH   64
 How long a label name can be.
 
#define PROMETHEUS_MAX_VALUE_LENGTH   32
 How large of a value we can store.
 
#define PROMETHEUS_METRIC_SET_LABEL(metric, label, n, v)
 Convenience macro for setting a label / value in a metric. More...
 
#define PROMETHEUS_METRIC_STATIC_INITIALIZATION(mtype, n, h, cb)
 Convenience macro for initializing a metric on the stack. More...
 

Enumerations

enum  prometheus_metric_allocation_strategy { PROMETHEUS_METRIC_ALLOCD = 0, PROMETHEUS_METRIC_MALLOCD }
 How the metric was allocated. More...
 
enum  prometheus_metric_type { PROMETHEUS_METRIC_COUNTER = 0, PROMETHEUS_METRIC_GAUGE }
 Prometheus metric type. More...
 

Functions

int prometheus_callback_register (struct prometheus_callback *callback)
 
void prometheus_callback_unregister (struct prometheus_callback *callback)
 Remove a registered callback. More...
 
struct prometheus_metricprometheus_counter_create (const char *name, const char *help)
 Create a malloc'd counter metric. More...
 
struct prometheus_metricprometheus_gauge_create (const char *name, const char *help)
 Create a malloc'd gauge metric. More...
 
void * prometheus_general_config_alloc (void)
 Allocate a new configuration object. More...
 
struct prometheus_general_configprometheus_general_config_get (void)
 Retrieve the current configuration of the module. More...
 
void prometheus_general_config_set (struct prometheus_general_config *config)
 Set the configuration for the module. More...
 
void prometheus_metric_free (struct prometheus_metric *metric)
 Destroy a metric and all its children. More...
 
int prometheus_metric_register (struct prometheus_metric *metric)
 
int prometheus_metric_registered_count (void)
 
void prometheus_metric_to_string (struct prometheus_metric *metric, struct ast_str **output)
 Convert a metric (and its children) into Prometheus compatible text. More...
 
int prometheus_metric_unregister (struct prometheus_metric *metric)
 Remove a registered metric. More...
 
void prometheus_metrics_provider_register (const struct prometheus_metrics_provider *provider)
 Register a metrics provider. More...
 

Detailed Description

Asterisk Prometheus Metrics.

This module provides the base APIs and functionality for exposing a metrics route in Asterisk's HTTP server suitable for consumption by a Prometheus server. It does not provide any metrics itself.

Definition in file res_prometheus.h.

Macro Definition Documentation

#define PROMETHEUS_METRIC_SET_LABEL (   metric,
  label,
  n,
 
)
Value:
do { \
ast_assert((label) < PROMETHEUS_MAX_LABELS); \
ast_copy_string((metric)->labels[(label)].name, (n), sizeof((metric)->labels[(label)].name)); \
ast_copy_string((metric)->labels[(label)].value, (v), sizeof((metric)->labels[(label)].value)); \
} while (0)
#define PROMETHEUS_MAX_LABELS
How many labels a single metric can have.
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425

Convenience macro for setting a label / value in a metric.

When creating nested metrics, it's helpful to set their label after they have been declared but before they have been registered. This macro acts as a convenience function to set the labels properly on a declared metric.

Note
Setting labels after registration will lead to a "bad time"

Example Usage:

1 PROMETHEUS_METRIC_SET_LABEL(
2  test_gauge_child_two, 0, "key_one", "value_two");
3 PROMETHEUS_METRIC_SET_LABEL(
4  test_gauge_child_two, 1, "key_two", "value_two");
Parameters
metricThe metric to set the label on
labelPosition of the label to set
nName of the label
vValue of the label

Definition at line 313 of file res_prometheus.h.

Referenced by prometheus_config_post_apply().

#define PROMETHEUS_METRIC_STATIC_INITIALIZATION (   mtype,
  n,
  h,
  cb 
)

Convenience macro for initializing a metric on the stack.

When initializing a metric on the stack, various fields have to be provided to initialize the metric correctly. This macro can be used to simplify the process.

Example Usage:

1 struct prometheus_metric test_counter_one =
2  PROMETHEUS_METRIC_STATIC_INITIALIZATION(
3  PROMETHEUS_METRIC_COUNTER,
4  "test_counter_one",
5  "A test counter",
6  NULL);
7 struct prometheus_metric test_counter_two =
8  PROMETHEUS_METRIC_STATIC_INITIALIZATION(
9  PROMETHEUS_METRIC_COUNTER,
10  "test_counter_two",
11  "A test counter",
12  metric_values_get_counter_value_cb);
Parameters
mtypeThe metric type. See prometheus_metric_type
nName of the metric
hHelp text for the metric
cbCallback function. Optional; may be NULL

Definition at line 281 of file res_prometheus.h.

Enumeration Type Documentation

How the metric was allocated.

Note
Clearly, you don't want to get this wrong.
Enumerator
PROMETHEUS_METRIC_ALLOCD 

The metric was allocated on the stack.

PROMETHEUS_METRIC_MALLOCD 

The metric was allocated on the heap.

Definition at line 138 of file res_prometheus.h.

138  {
139  /*!
140  * \brief The metric was allocated on the stack
141  */
143  /*!
144  * \brief The metric was allocated on the heap
145  */
147 };
The metric was allocated on the stack.
The metric was allocated on the heap.

Prometheus metric type.

Note
Clearly, at some point, we should support summaries and histograms. As an initial implementation, counters / gauges give us quite a bit of functionality.
Enumerator
PROMETHEUS_METRIC_COUNTER 

A metric whose value always goes up.

PROMETHEUS_METRIC_GAUGE 

A metric whose value can bounce around like a jackrabbit.

Definition at line 122 of file res_prometheus.h.

122  {
123  /*!
124  * \brief A metric whose value always goes up
125  */
127  /*!
128  * \brief A metric whose value can bounce around like a jackrabbit
129  */
131 };
A metric whose value always goes up.
A metric whose value can bounce around like a jackrabbit.

Function Documentation

int prometheus_callback_register ( struct prometheus_callback callback)

Register a metric callback

Parameters
callbackThe callback to register
Return values
0success
-1error

Definition at line 535 of file res_prometheus.c.

References AST_VECTOR_APPEND, prometheus_callback::callback_fn, lock, prometheus_callback::name, SCOPED_MUTEX, and scrape_lock.

Referenced by bridge_metrics_init(), channel_metrics_init(), and endpoint_metrics_init().

536 {
538 
539  if (!callback || !callback->callback_fn || ast_strlen_zero(callback->name)) {
540  return -1;
541  }
542 
543  AST_VECTOR_APPEND(&callbacks, callback);
544 
545  return 0;
546 }
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
Definition: vector.h:256
const char * name
The name of our callback (always useful for debugging)
void(* callback_fn)(struct ast_str **output)
The callback function to invoke.
ast_mutex_t lock
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
static ast_mutex_t scrape_lock
Lock that protects data structures during an HTTP scrape.
void prometheus_callback_unregister ( struct prometheus_callback callback)

Remove a registered callback.

Parameters
callbackThe callback to unregister

Definition at line 548 of file res_prometheus.c.

References AST_VECTOR_GET, AST_VECTOR_REMOVE, AST_VECTOR_SIZE, lock, prometheus_callback::name, SCOPED_MUTEX, and scrape_lock.

549 {
551  int i;
552 
553  for (i = 0; i < AST_VECTOR_SIZE(&callbacks); i++) {
554  struct prometheus_callback *entry = AST_VECTOR_GET(&callbacks, i);
555 
556  if (!strcmp(callback->name, entry->name)) {
557  AST_VECTOR_REMOVE(&callbacks, i, 1);
558  return;
559  }
560  }
561 }
const char * name
The name of our callback (always useful for debugging)
ast_mutex_t lock
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
static ast_mutex_t scrape_lock
Lock that protects data structures during an HTTP scrape.
#define AST_VECTOR_GET(vec, idx)
Get an element from a vector.
Definition: vector.h:680
Definition: search.h:40
#define AST_VECTOR_REMOVE(vec, idx, preserve_ordered)
Remove an element from a vector by index.
Definition: vector.h:412
Defines a callback that will be invoked when the HTTP route is called.
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition: vector.h:609
struct prometheus_metric* prometheus_counter_create ( const char *  name,
const char *  help 
)

Create a malloc'd counter metric.

Note
The metric must be registered after creation
Parameters
nameThe name of the metric
helpHelp text for the metric
Return values
prometheus_metricon success
NULLon error

Definition at line 452 of file res_prometheus.c.

References PROMETHEUS_METRIC_COUNTER, and prometheus_metric::type.

453 {
454  struct prometheus_metric *metric;
455 
456  metric = prometheus_metric_create(name, help);
457  if (!metric) {
458  return NULL;
459  }
461 
462  return metric;
463 }
An actual, honest to god, metric.
A metric whose value always goes up.
enum prometheus_metric_type type
What type of metric we are.
const char * help
Pointer to a static string defining this metric's help text.
char name[PROMETHEUS_MAX_NAME_LENGTH]
Our metric name.
struct prometheus_metric* prometheus_gauge_create ( const char *  name,
const char *  help 
)

Create a malloc'd gauge metric.

Note
The metric must be registered after creation
Parameters
nameThe name of the metric
helpHelp text for the metric
Return values
prometheus_metricon success
NULLon error

Definition at line 439 of file res_prometheus.c.

References PROMETHEUS_METRIC_GAUGE, and prometheus_metric::type.

440 {
441  struct prometheus_metric *metric;
442 
443  metric = prometheus_metric_create(name, help);
444  if (!metric) {
445  return NULL;
446  }
447  metric->type = PROMETHEUS_METRIC_GAUGE;
448 
449  return metric;
450 }
An actual, honest to god, metric.
enum prometheus_metric_type type
What type of metric we are.
const char * help
Pointer to a static string defining this metric's help text.
char name[PROMETHEUS_MAX_NAME_LENGTH]
Our metric name.
A metric whose value can bounce around like a jackrabbit.
void* prometheus_general_config_alloc ( void  )

Allocate a new configuration object.

The returned object is an AO2 ref counted object

Return values
NULLon error
configon success

Definition at line 726 of file res_prometheus.c.

References ast_string_field_init.

Referenced by module_config_alloc().

727 {
728  struct prometheus_general_config *config;
729 
730  config = ao2_alloc(sizeof(*config), prometheus_general_config_dtor);
731  if (!config || ast_string_field_init(config, 32)) {
732  return NULL;
733  }
734 
735  return config;
736 }
Prometheus general configuration.
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
struct prometheus_general_config* prometheus_general_config_get ( void  )

Retrieve the current configuration of the module.

config is an AO2 ref counted object

Note
This should primarily be done for testing purposes.
Return values
NULLon error
configon success

Definition at line 738 of file res_prometheus.c.

References ao2_bump, ao2_global_obj_ref, and RAII_VAR.

739 {
740  RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(global_config), ao2_cleanup);
741 
742  if (!mod_cfg) {
743  return NULL;
744  }
745  ao2_bump(mod_cfg->general);
746 
747  return mod_cfg->general;
748 }
#define ao2_global_obj_ref(holder)
Get a reference to the object stored in the global holder.
Definition: astobj2.h:918
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
The configuration settings for this module.
Definition: cdr.c:264
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
void prometheus_general_config_set ( struct prometheus_general_config config)

Set the configuration for the module.

This is not a ref-stealing function. The reference count to config will be incremented as a result of calling this method.

Note
This should primarily be done for testing purposes

Definition at line 750 of file res_prometheus.c.

References ao2_global_obj_ref, ao2_replace, prometheus_config_post_apply(), and RAII_VAR.

751 {
752  RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(global_config), ao2_cleanup);
753 
754  if (!mod_cfg) {
755  return;
756  }
757  ao2_replace(mod_cfg->general, config);
759 }
#define ao2_global_obj_ref(holder)
Get a reference to the object stored in the global holder.
Definition: astobj2.h:918
The configuration settings for this module.
Definition: cdr.c:264
#define ao2_replace(dst, src)
Replace one object reference with another cleaning up the original.
Definition: astobj2.h:501
static void prometheus_config_post_apply(void)
Post-apply callback for the config framework.
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
void prometheus_metric_free ( struct prometheus_metric metric)

Destroy a metric and all its children.

Note
If you still want the children, make sure you remove the head of the children list first.
Parameters
metricThe metric to destroy

Definition at line 393 of file res_prometheus.c.

References prometheus_metric::allocation_strategy, AST_LIST_REMOVE_HEAD, prometheus_metric::children, prometheus_metric::lock, PROMETHEUS_METRIC_ALLOCD, and PROMETHEUS_METRIC_MALLOCD.

Referenced by prometheus_metric_unregister().

394 {
395  struct prometheus_metric *child;
396 
397  if (!metric) {
398  return;
399  }
400 
401  while ((child = AST_LIST_REMOVE_HEAD(&metric->children, entry))) {
402  prometheus_metric_free(child);
403  }
404  ast_mutex_destroy(&metric->lock);
405 
407  return;
408  } else if (metric->allocation_strategy == PROMETHEUS_METRIC_MALLOCD) {
409  ast_free(metric);
410  }
411 }
An actual, honest to god, metric.
enum prometheus_metric_allocation_strategy allocation_strategy
How this metric was allocated.
The metric was allocated on the stack.
struct prometheus_metric::@274 children
A list of children metrics.
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
ast_mutex_t lock
A lock protecting the metric value.
Definition: search.h:40
The metric was allocated on the heap.
void prometheus_metric_free(struct prometheus_metric *metric)
Destroy a metric and all its children.
int prometheus_metric_register ( struct prometheus_metric metric)

Register a metric for collection

Parameters
metricThe metric to register
Return values
0success
-1error

Definition at line 288 of file res_prometheus.c.

References ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_SIZE, prometheus_metric::children, lock, prometheus_metric::name, SCOPED_MUTEX, and scrape_lock.

Referenced by prometheus_config_post_apply().

289 {
291  int i;
292 
293  if (!metric) {
294  return -1;
295  }
296 
297  for (i = 0; i < AST_VECTOR_SIZE(&metrics); i++) {
298  struct prometheus_metric *existing = AST_VECTOR_GET(&metrics, i);
299  struct prometheus_metric *child;
300 
301  if (prometheus_metric_cmp(existing, metric)) {
302  ast_log(AST_LOG_NOTICE,
303  "Refusing registration of existing Prometheus metric: %s\n",
304  metric->name);
305  return -1;
306  }
307 
308  AST_LIST_TRAVERSE(&existing->children, child, entry) {
309  if (prometheus_metric_cmp(child, metric)) {
310  ast_log(AST_LOG_NOTICE,
311  "Refusing registration of existing Prometheus metric: %s\n",
312  metric->name);
313  return -1;
314  }
315  }
316 
317  if (!strcmp(metric->name, existing->name)) {
318  ast_debug(3, "Nesting metric '%s' as child (%p) under existing (%p)\n",
319  metric->name, metric, existing);
320  AST_LIST_INSERT_TAIL(&existing->children, metric, entry);
321  return 0;
322  }
323  }
324 
325  ast_debug(3, "Tracking new root metric '%s'\n", metric->name);
326  if (AST_VECTOR_APPEND(&metrics, metric)) {
327  ast_log(AST_LOG_WARNING, "Failed to grow vector to make room for Prometheus metric: %s\n",
328  metric->name);
329  return -1;
330  }
331 
332  return 0;
333 }
An actual, honest to god, metric.
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
Definition: vector.h:256
ast_mutex_t lock
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
struct prometheus_metric::@274 children
A list of children metrics.
#define ast_debug(level,...)
Log a DEBUG message.
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
char name[PROMETHEUS_MAX_NAME_LENGTH]
Our metric name.
static ast_mutex_t scrape_lock
Lock that protects data structures during an HTTP scrape.
#define AST_VECTOR_GET(vec, idx)
Get an element from a vector.
Definition: vector.h:680
Definition: search.h:40
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition: vector.h:609
int prometheus_metric_registered_count ( void  )

The current number of registered metrics

Return values
Thecurrent number of registered metrics

Definition at line 281 of file res_prometheus.c.

References AST_VECTOR_SIZE, lock, SCOPED_MUTEX, and scrape_lock.

282 {
284 
285  return AST_VECTOR_SIZE(&metrics);
286 }
ast_mutex_t lock
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
static ast_mutex_t scrape_lock
Lock that protects data structures during an HTTP scrape.
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition: vector.h:609
void prometheus_metric_to_string ( struct prometheus_metric metric,
struct ast_str **  output 
)

Convert a metric (and its children) into Prometheus compatible text.

Parameters
metricThe metric to convert to a string
[out]outputThe ast_str string to populate with the metric(s)

Definition at line 521 of file res_prometheus.c.

References AST_LIST_TRAVERSE, ast_str_append(), prometheus_metric::children, prometheus_metric::help, prometheus_metric::name, and prometheus_metric::type.

523 {
524  struct prometheus_metric *child;
525 
526  ast_str_append(output, 0, "# HELP %s %s\n", metric->name, metric->help);
527  ast_str_append(output, 0, "# TYPE %s %s\n", metric->name,
528  prometheus_metric_type_to_string(metric->type));
529  prometheus_metric_full_to_string(metric, output);
530  AST_LIST_TRAVERSE(&metric->children, child, entry) {
531  prometheus_metric_full_to_string(child, output);
532  }
533 }
An actual, honest to god, metric.
enum prometheus_metric_type type
What type of metric we are.
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1139
struct prometheus_metric::@274 children
A list of children metrics.
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
const char * help
Pointer to a static string defining this metric's help text.
char name[PROMETHEUS_MAX_NAME_LENGTH]
Our metric name.
Definition: search.h:40
int prometheus_metric_unregister ( struct prometheus_metric metric)

Remove a registered metric.

Parameters
metricThe metric to unregister
Note
Unregistering also destroys the metric, if found
Return values
0The metric was found, unregistered, and disposed of
-1The metric was not found

Definition at line 335 of file res_prometheus.c.

References ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_VECTOR_GET, AST_VECTOR_INSERT_AT, AST_VECTOR_REMOVE, AST_VECTOR_SIZE, prometheus_metric::children, lock, prometheus_metric::name, prometheus_metric_free(), SCOPED_MUTEX, and scrape_lock.

Referenced by prometheus_config_post_apply().

336 {
337  if (!metric) {
338  return -1;
339  }
340 
341  {
343  int i;
344 
345  ast_debug(3, "Removing metric '%s'\n", metric->name);
346  for (i = 0; i < AST_VECTOR_SIZE(&metrics); i++) {
347  struct prometheus_metric *existing = AST_VECTOR_GET(&metrics, i);
348 
349  /*
350  * If this is a complete match, remove the matching metric
351  * and place its children back into the list
352  */
353  if (prometheus_metric_cmp(existing, metric)) {
354  struct prometheus_metric *root;
355 
356  AST_VECTOR_REMOVE(&metrics, i, 1);
357  root = AST_LIST_REMOVE_HEAD(&existing->children, entry);
358  if (root) {
359  struct prometheus_metric *child;
360  AST_LIST_TRAVERSE_SAFE_BEGIN(&existing->children, child, entry) {
362  AST_LIST_INSERT_TAIL(&root->children, child, entry);
363  }
365  AST_VECTOR_INSERT_AT(&metrics, i, root);
366  }
367  prometheus_metric_free(existing);
368  return 0;
369  }
370 
371  /*
372  * Name match, but labels don't match. Find the matching entry with
373  * labels and remove it along with all of its children
374  */
375  if (!strcmp(existing->name, metric->name)) {
376  struct prometheus_metric *child;
377 
378  AST_LIST_TRAVERSE_SAFE_BEGIN(&existing->children, child, entry) {
379  if (prometheus_metric_cmp(child, metric)) {
381  prometheus_metric_free(child);
382  return 0;
383  }
384  }
386  }
387  }
388  }
389 
390  return -1;
391 }
An actual, honest to god, metric.
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition: linkedlists.h:615
ast_mutex_t lock
#define SCOPED_MUTEX(varname, lock)
scoped lock specialization for mutexes
Definition: lock.h:589
struct prometheus_metric::@274 children
A list of children metrics.
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Definition: linkedlists.h:557
#define ast_debug(level,...)
Log a DEBUG message.
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
char name[PROMETHEUS_MAX_NAME_LENGTH]
Our metric name.
static ast_mutex_t scrape_lock
Lock that protects data structures during an HTTP scrape.
#define AST_VECTOR_GET(vec, idx)
Get an element from a vector.
Definition: vector.h:680
#define AST_VECTOR_INSERT_AT(vec, idx, elem)
Insert an element at a specific position in a vector, growing the vector if needed.
Definition: vector.h:338
Definition: search.h:40
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Definition: linkedlists.h:529
void prometheus_metric_free(struct prometheus_metric *metric)
Destroy a metric and all its children.
#define AST_VECTOR_REMOVE(vec, idx, preserve_ordered)
Remove an element from a vector by index.
Definition: vector.h:412
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition: vector.h:609
void prometheus_metrics_provider_register ( const struct prometheus_metrics_provider provider)

Register a metrics provider.

Parameters
providerThe provider function table to register

Definition at line 871 of file res_prometheus.c.

References AST_VECTOR_APPEND.

Referenced by bridge_metrics_init(), channel_metrics_init(), cli_init(), endpoint_metrics_init(), and pjsip_outbound_registration_metrics_init().

872 {
873  AST_VECTOR_APPEND(&providers, provider);
874 }
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
Definition: vector.h:256