mirror of
https://git.haproxy.org/git/haproxy.git/
synced 2026-04-19 20:52:53 +02:00
f05a6735b1
Added the memory pool management and the runtime scope layer that track per-stream OTel spans and contexts during request processing. The pool layer in pool.c manages HAProxy memory pools for the runtime structures used by the filter: scope spans, scope contexts, runtime contexts, and span contexts. Each pool is conditionally compiled via USE_POOL_OTEL_* macros defined in config.h and registered with REGISTER_POOL(). The allocation functions (flt_otel_pool_alloc, flt_otel_pool_strndup, flt_otel_pool_free) transparently fall back to heap allocation when the corresponding pool is not enabled. Trash buffer helpers (flt_otel_trash_alloc, flt_otel_trash_free) provide scratch space using either HAProxy's trash chunk pool or direct heap allocation. The scope layer in scope.c implements the per-stream runtime state. The flt_otel_runtime_context structure is allocated when a stream starts and holds the stream and filter references, hard-error/disabled/logging flags copied from the instrumentation configuration, idle timeout state, a generated UUID, and lists of active scope spans and extracted scope contexts. Scope spans (flt_otel_scope_span) carry the operation name, fetch direction, the OTel span handle, and optional parent references resolved from other spans or extracted contexts. Scope contexts (flt_otel_scope_context) hold an extracted span context obtained from a carrier text map via the tracer. The scope data structures (flt_otel_scope_data) aggregate growable key-value arrays for attributes and baggage, a linked list of named events with their own attribute arrays, and a span status code with description, representing the telemetry collected during a single event execution.
72 lines
2.7 KiB
C
72 lines
2.7 KiB
C
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
|
|
#ifndef _OTEL_POOL_H_
|
|
#define _OTEL_POOL_H_
|
|
|
|
#define FLT_OTEL_POOL_INIT(p,n,s,r) \
|
|
do { \
|
|
if (((r) == FLT_OTEL_RET_OK) && ((p) == NULL)) { \
|
|
(p) = create_pool(n, (s), MEM_F_SHARED); \
|
|
if ((p) == NULL) \
|
|
(r) = FLT_OTEL_RET_ERROR; \
|
|
\
|
|
OTELC_DBG(DEBUG, #p " %p %u", (p), FLT_OTEL_DEREF((p), size, 0)); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define FLT_OTEL_POOL_DESTROY(p) \
|
|
do { \
|
|
if ((p) != NULL) { \
|
|
OTELC_DBG(DEBUG, #p " %p %u", (p), (p)->size); \
|
|
\
|
|
pool_destroy(p); \
|
|
(p) = NULL; \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
extern struct pool_head *pool_head_otel_scope_span __read_mostly;
|
|
extern struct pool_head *pool_head_otel_scope_context __read_mostly;
|
|
extern struct pool_head *pool_head_otel_runtime_context __read_mostly;
|
|
extern struct pool_head *pool_head_otel_span_context __read_mostly;
|
|
|
|
|
|
/* Allocate memory from a pool with optional zeroing. */
|
|
void *flt_otel_pool_alloc(struct pool_head *pool, size_t size, bool flag_clear, char **err);
|
|
|
|
/* Duplicate a string into pool-allocated memory. */
|
|
void *flt_otel_pool_strndup(struct pool_head *pool, const char *s, size_t size, char **err);
|
|
|
|
/* Release pool-allocated memory and clear the pointer. */
|
|
void flt_otel_pool_free(struct pool_head *pool, void **ptr);
|
|
|
|
/* Initialize OTel filter memory pools. */
|
|
int flt_otel_pool_init(void);
|
|
|
|
/* Destroy OTel filter memory pools. */
|
|
void flt_otel_pool_destroy(void);
|
|
|
|
/* Log debug information about OTel filter memory pools. */
|
|
#ifndef DEBUG_OTEL
|
|
# define flt_otel_pool_info() while (0)
|
|
#else
|
|
void flt_otel_pool_info(void);
|
|
#endif
|
|
|
|
/* Allocate a trash buffer with optional zeroing. */
|
|
struct buffer *flt_otel_trash_alloc(bool flag_clear, char **err);
|
|
|
|
/* Release a trash buffer and clear the pointer. */
|
|
void flt_otel_trash_free(struct buffer **ptr);
|
|
|
|
#endif /* _OTEL_POOL_H_ */
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-indent-level: 8
|
|
* c-basic-offset: 8
|
|
* End:
|
|
*
|
|
* vi: noexpandtab shiftwidth=8 tabstop=8
|
|
*/
|