/* * Functions dedicated to statistics output and the stats socket * * Copyright 2000-2012 Willy Tarreau * Copyright 2007-2009 Krzysztof Piotr Oledzki * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* status codes available for the stats admin page (strictly 4 chars length) */ const char *stat_status_codes[STAT_STATUS_SIZE] = { [STAT_STATUS_DENY] = "DENY", [STAT_STATUS_DONE] = "DONE", [STAT_STATUS_ERRP] = "ERRP", [STAT_STATUS_EXCD] = "EXCD", [STAT_STATUS_NONE] = "NONE", [STAT_STATUS_PART] = "PART", [STAT_STATUS_UNKN] = "UNKN", [STAT_STATUS_IVAL] = "IVAL", }; /* These are the field names for each INF_* field position. Please pay attention * to always use the exact same name except that the strings for new names must * be lower case or CamelCase while the enum entries must be upper case. */ const struct name_desc info_fields[INF_TOTAL_FIELDS] = { [INF_NAME] = { .name = "Name", .desc = "Product name" }, [INF_VERSION] = { .name = "Version", .desc = "Product version" }, [INF_RELEASE_DATE] = { .name = "Release_date", .desc = "Date of latest source code update" }, [INF_NBTHREAD] = { .name = "Nbthread", .desc = "Number of started threads (global.nbthread)" }, [INF_NBPROC] = { .name = "Nbproc", .desc = "Number of started worker processes (global.nbproc)" }, [INF_PROCESS_NUM] = { .name = "Process_num", .desc = "Relative worker process number (1..Nbproc)" }, [INF_PID] = { .name = "Pid", .desc = "This worker process identifier for the system" }, [INF_UPTIME] = { .name = "Uptime", .desc = "How long ago this worker process was started (days+hours+minutes+seconds)" }, [INF_UPTIME_SEC] = { .name = "Uptime_sec", .desc = "How long ago this worker process was started (seconds)" }, [INF_MEMMAX_MB] = { .name = "Memmax_MB", .desc = "Worker process's hard limit on memory usage in MB (-m on command line)" }, [INF_POOL_ALLOC_MB] = { .name = "PoolAlloc_MB", .desc = "Amount of memory allocated in pools (in MB)" }, [INF_POOL_USED_MB] = { .name = "PoolUsed_MB", .desc = "Amount of pool memory currently used (in MB)" }, [INF_POOL_FAILED] = { .name = "PoolFailed", .desc = "Number of failed pool allocations since this worker was started" }, [INF_ULIMIT_N] = { .name = "Ulimit-n", .desc = "Hard limit on the number of per-process file descriptors" }, [INF_MAXSOCK] = { .name = "Maxsock", .desc = "Hard limit on the number of per-process sockets" }, [INF_MAXCONN] = { .name = "Maxconn", .desc = "Hard limit on the number of per-process connections (configured or imposed by Ulimit-n)" }, [INF_HARD_MAXCONN] = { .name = "Hard_maxconn", .desc = "Hard limit on the number of per-process connections (imposed by Memmax_MB or Ulimit-n)" }, [INF_CURR_CONN] = { .name = "CurrConns", .desc = "Current number of connections on this worker process" }, [INF_CUM_CONN] = { .name = "CumConns", .desc = "Total number of connections on this worker process since started" }, [INF_CUM_REQ] = { .name = "CumReq", .desc = "Total number of requests on this worker process since started" }, [INF_MAX_SSL_CONNS] = { .name = "MaxSslConns", .desc = "Hard limit on the number of per-process SSL endpoints (front+back), 0=unlimited" }, [INF_CURR_SSL_CONNS] = { .name = "CurrSslConns", .desc = "Current number of SSL endpoints on this worker process (front+back)" }, [INF_CUM_SSL_CONNS] = { .name = "CumSslConns", .desc = "Total number of SSL endpoints on this worker process since started (front+back)" }, [INF_MAXPIPES] = { .name = "Maxpipes", .desc = "Hard limit on the number of pipes for splicing, 0=unlimited" }, [INF_PIPES_USED] = { .name = "PipesUsed", .desc = "Current number of pipes in use in this worker process" }, [INF_PIPES_FREE] = { .name = "PipesFree", .desc = "Current number of allocated and available pipes in this worker process" }, [INF_CONN_RATE] = { .name = "ConnRate", .desc = "Number of front connections created on this worker process over the last second" }, [INF_CONN_RATE_LIMIT] = { .name = "ConnRateLimit", .desc = "Hard limit for ConnRate (global.maxconnrate)" }, [INF_MAX_CONN_RATE] = { .name = "MaxConnRate", .desc = "Highest ConnRate reached on this worker process since started (in connections per second)" }, [INF_SESS_RATE] = { .name = "SessRate", .desc = "Number of sessions created on this worker process over the last second" }, [INF_SESS_RATE_LIMIT] = { .name = "SessRateLimit", .desc = "Hard limit for SessRate (global.maxsessrate)" }, [INF_MAX_SESS_RATE] = { .name = "MaxSessRate", .desc = "Highest SessRate reached on this worker process since started (in sessions per second)" }, [INF_SSL_RATE] = { .name = "SslRate", .desc = "Number of SSL connections created on this worker process over the last second" }, [INF_SSL_RATE_LIMIT] = { .name = "SslRateLimit", .desc = "Hard limit for SslRate (global.maxsslrate)" }, [INF_MAX_SSL_RATE] = { .name = "MaxSslRate", .desc = "Highest SslRate reached on this worker process since started (in connections per second)" }, [INF_SSL_FRONTEND_KEY_RATE] = { .name = "SslFrontendKeyRate", .desc = "Number of SSL keys created on frontends in this worker process over the last second" }, [INF_SSL_FRONTEND_MAX_KEY_RATE] = { .name = "SslFrontendMaxKeyRate", .desc = "Highest SslFrontendKeyRate reached on this worker process since started (in SSL keys per second)" }, [INF_SSL_FRONTEND_SESSION_REUSE_PCT] = { .name = "SslFrontendSessionReuse_pct", .desc = "Percent of frontend SSL connections which did not require a new key" }, [INF_SSL_BACKEND_KEY_RATE] = { .name = "SslBackendKeyRate", .desc = "Number of SSL keys created on backends in this worker process over the last second" }, [INF_SSL_BACKEND_MAX_KEY_RATE] = { .name = "SslBackendMaxKeyRate", .desc = "Highest SslBackendKeyRate reached on this worker process since started (in SSL keys per second)" }, [INF_SSL_CACHE_LOOKUPS] = { .name = "SslCacheLookups", .desc = "Total number of SSL session ID lookups in the SSL session cache on this worker since started" }, [INF_SSL_CACHE_MISSES] = { .name = "SslCacheMisses", .desc = "Total number of SSL session ID lookups that didn't find a session in the SSL session cache on this worker since started" }, [INF_COMPRESS_BPS_IN] = { .name = "CompressBpsIn", .desc = "Number of bytes submitted to the HTTP compressor in this worker process over the last second" }, [INF_COMPRESS_BPS_OUT] = { .name = "CompressBpsOut", .desc = "Number of bytes emitted by the HTTP compressor in this worker process over the last second" }, [INF_COMPRESS_BPS_RATE_LIM] = { .name = "CompressBpsRateLim", .desc = "Limit of CompressBpsOut beyond which HTTP compression is automatically disabled" }, [INF_ZLIB_MEM_USAGE] = { .name = "ZlibMemUsage", .desc = "Amount of memory currently used by HTTP compression on the current worker process (in bytes)" }, [INF_MAX_ZLIB_MEM_USAGE] = { .name = "MaxZlibMemUsage", .desc = "Limit on the amount of memory used by HTTP compression above which it is automatically disabled (in bytes, see global.maxzlibmem)" }, [INF_TASKS] = { .name = "Tasks", .desc = "Total number of tasks in the current worker process (active + sleeping)" }, [INF_RUN_QUEUE] = { .name = "Run_queue", .desc = "Total number of active tasks+tasklets in the current worker process" }, [INF_IDLE_PCT] = { .name = "Idle_pct", .desc = "Percentage of last second spent waiting in the current worker thread" }, [INF_NODE] = { .name = "node", .desc = "Node name (global.node)" }, [INF_DESCRIPTION] = { .name = "description", .desc = "Node description (global.description)" }, [INF_STOPPING] = { .name = "Stopping", .desc = "1 if the worker process is currently stopping, otherwise zero" }, [INF_JOBS] = { .name = "Jobs", .desc = "Current number of active jobs on the current worker process (frontend connections, master connections, listeners)" }, [INF_UNSTOPPABLE_JOBS] = { .name = "Unstoppable Jobs", .desc = "Current number of unstoppable jobs on the current worker process (master connections)" }, [INF_LISTENERS] = { .name = "Listeners", .desc = "Current number of active listeners on the current worker process" }, [INF_ACTIVE_PEERS] = { .name = "ActivePeers", .desc = "Current number of verified active peers connections on the current worker process" }, [INF_CONNECTED_PEERS] = { .name = "ConnectedPeers", .desc = "Current number of peers having passed the connection step on the current worker process" }, [INF_DROPPED_LOGS] = { .name = "DroppedLogs", .desc = "Total number of dropped logs for current worker process since started" }, [INF_BUSY_POLLING] = { .name = "BusyPolling", .desc = "1 if busy-polling is currently in use on the worker process, otherwise zero (config.busy-polling)" }, [INF_FAILED_RESOLUTIONS] = { .name = "FailedResolutions", .desc = "Total number of failed DNS resolutions in current worker process since started" }, [INF_TOTAL_BYTES_OUT] = { .name = "TotalBytesOut", .desc = "Total number of bytes emitted by current worker process since started" }, [INF_BYTES_OUT_RATE] = { .name = "BytesOutRate", .desc = "Number of bytes emitted by current worker process over the last second" }, }; const struct name_desc stat_fields[ST_F_TOTAL_FIELDS] = { [ST_F_PXNAME] = { .name = "pxname", .desc = "Proxy name" }, [ST_F_SVNAME] = { .name = "svname", .desc = "Server name" }, [ST_F_QCUR] = { .name = "qcur", .desc = "Current number of connections waiting in the server of backend queue" }, [ST_F_QMAX] = { .name = "qmax", .desc = "Highest value of qcur encountered since process started" }, [ST_F_SCUR] = { .name = "scur", .desc = "Current number of sessions on the frontend, backend or server" }, [ST_F_SMAX] = { .name = "smax", .desc = "Highest value of scur encountered since process started" }, [ST_F_SLIM] = { .name = "slim", .desc = "Frontend/listener/server's maxconn, backend's fullconn" }, [ST_F_STOT] = { .name = "stot", .desc = "Total number of sessions since process started" }, [ST_F_BIN] = { .name = "bin", .desc = "Total number of request bytes since process started" }, [ST_F_BOUT] = { .name = "bout", .desc = "Total number of response bytes since process started" }, [ST_F_DREQ] = { .name = "dreq", .desc = "Total number of denied requests since process started" }, [ST_F_DRESP] = { .name = "dresp", .desc = "Total number of denied responses since process started" }, [ST_F_EREQ] = { .name = "ereq", .desc = "Total number of invalid requests since process started" }, [ST_F_ECON] = { .name = "econ", .desc = "Total number of failed connections to server since the worker process started" }, [ST_F_ERESP] = { .name = "eresp", .desc = "Total number of invalid responses since the worker process started" }, [ST_F_WRETR] = { .name = "wretr", .desc = "Total number of server connection retries since the worker process started" }, [ST_F_WREDIS] = { .name = "wredis", .desc = "Total number of server redispatches due to connection failures since the worker process started" }, [ST_F_STATUS] = { .name = "status", .desc = "Frontend/listen status: OPEN/WAITING/FULL/STOP; backend: UP/DOWN; server: last check status" }, [ST_F_WEIGHT] = { .name = "weight", .desc = "Server weight, or sum of active servers' weights for a backend" }, [ST_F_ACT] = { .name = "act", .desc = "Total number of active UP servers with a non-zero weight" }, [ST_F_BCK] = { .name = "bck", .desc = "Total number of backup UP servers with a non-zero weight" }, [ST_F_CHKFAIL] = { .name = "chkfail", .desc = "Total number of failed individual health checks per server/backend, since the worker process started" }, [ST_F_CHKDOWN] = { .name = "chkdown", .desc = "Total number of failed checks causing UP to DOWN server transitions, per server/backend, since the worker process started" }, [ST_F_LASTCHG] = { .name = "lastchg", .desc = "How long ago the last server state changed, in seconds" }, [ST_F_DOWNTIME] = { .name = "downtime", .desc = "Total time spent in DOWN state, for server or backend" }, [ST_F_QLIMIT] = { .name = "qlimit", .desc = "Limit on the number of connections in queue, for servers only (maxqueue argument)" }, [ST_F_PID] = { .name = "pid", .desc = "Relative worker process number (1..nbproc)" }, [ST_F_IID] = { .name = "iid", .desc = "Frontend or Backend numeric identifier ('id' setting)" }, [ST_F_SID] = { .name = "sid", .desc = "Server numeric identifier ('id' setting)" }, [ST_F_THROTTLE] = { .name = "throttle", .desc = "Throttling ratio applied to a server's maxconn and weight during the slowstart period (0 to 100%)" }, [ST_F_LBTOT] = { .name = "lbtot", .desc = "Total number of requests routed by load balancing since the worker process started (ignores queue pop and stickiness)" }, [ST_F_TRACKED] = { .name = "tracked", .desc = "Name of the other server this server tracks for its state" }, [ST_F_TYPE] = { .name = "type", .desc = "Type of the object (Listener, Frontend, Backend, Server)" }, [ST_F_RATE] = { .name = "rate", .desc = "Total number of sessions processed by this object over the last second (sessions for listeners/frontends, requests for backends/servers)" }, [ST_F_RATE_LIM] = { .name = "rate_lim", .desc = "Limit on the number of sessions accepted in a second (frontend only, 'rate-limit sessions' setting)" }, [ST_F_RATE_MAX] = { .name = "rate_max", .desc = "Highest value of 'rate' observed since the worker process started" }, [ST_F_CHECK_STATUS] = { .name = "check_status", .desc = "Status report of the server's latest health check, prefixed with '*' if a check is currently in progress" }, [ST_F_CHECK_CODE] = { .name = "check_code", .desc = "HTTP/SMTP/LDAP status code reported by the latest server health check" }, [ST_F_CHECK_DURATION] = { .name = "check_duration", .desc = "Total duration of the latest server health check, in milliseconds" }, [ST_F_HRSP_1XX] = { .name = "hrsp_1xx", .desc = "Total number of HTTP responses with status 100-199 returned by this object since the worker process started" }, [ST_F_HRSP_2XX] = { .name = "hrsp_2xx", .desc = "Total number of HTTP responses with status 200-299 returned by this object since the worker process started" }, [ST_F_HRSP_3XX] = { .name = "hrsp_3xx", .desc = "Total number of HTTP responses with status 300-399 returned by this object since the worker process started" }, [ST_F_HRSP_4XX] = { .name = "hrsp_4xx", .desc = "Total number of HTTP responses with status 400-499 returned by this object since the worker process started" }, [ST_F_HRSP_5XX] = { .name = "hrsp_5xx", .desc = "Total number of HTTP responses with status 500-599 returned by this object since the worker process started" }, [ST_F_HRSP_OTHER] = { .name = "hrsp_other", .desc = "Total number of HTTP responses with status <100, >599 returned by this object since the worker process started (error -1 included)" }, [ST_F_HANAFAIL] = { .name = "hanafail", .desc = "Total number of failed checks caused by an 'on-error' directive after an 'observe' condition matched" }, [ST_F_REQ_RATE] = { .name = "req_rate", .desc = "Number of HTTP requests processed over the last second on this object" }, [ST_F_REQ_RATE_MAX] = { .name = "req_rate_max", .desc = "Highest value of 'req_rate' observed since the worker process started" }, [ST_F_REQ_TOT] = { .name = "req_tot", .desc = "Total number of HTTP requests processed by this object since the worker process started" }, [ST_F_CLI_ABRT] = { .name = "cli_abrt", .desc = "Total number of requests or connections aborted by the client since the worker process started" }, [ST_F_SRV_ABRT] = { .name = "srv_abrt", .desc = "Total number of requests or connections aborted by the server since the worker process started" }, [ST_F_COMP_IN] = { .name = "comp_in", .desc = "Total number of bytes submitted to the HTTP compressor for this object since the worker process started" }, [ST_F_COMP_OUT] = { .name = "comp_out", .desc = "Total number of bytes emitted by the HTTP compressor for this object since the worker process started" }, [ST_F_COMP_BYP] = { .name = "comp_byp", .desc = "Total number of bytes that bypassed HTTP compression for this object since the worker process started (CPU/memory/bandwidth limitation)" }, [ST_F_COMP_RSP] = { .name = "comp_rsp", .desc = "Total number of HTTP responses that were compressed for this object since the worker process started" }, [ST_F_LASTSESS] = { .name = "lastsess", .desc = "How long ago some traffic was seen on this object on this worker process, in seconds" }, [ST_F_LAST_CHK] = { .name = "last_chk", .desc = "Short description of the latest health check report for this server (see also check_desc)" }, [ST_F_LAST_AGT] = { .name = "last_agt", .desc = "Short description of the latest agent check report for this server (see also agent_desc)" }, [ST_F_QTIME] = { .name = "qtime", .desc = "Time spent in the queue, in milliseconds, averaged over the 1024 last requests (backend/server)" }, [ST_F_CTIME] = { .name = "ctime", .desc = "Time spent waiting for a connection to complete, in milliseconds, averaged over the 1024 last requests (backend/server)" }, [ST_F_RTIME] = { .name = "rtime", .desc = "Time spent waiting for a server response, in milliseconds, averaged over the 1024 last requests (backend/server)" }, [ST_F_TTIME] = { .name = "ttime", .desc = "Total request+response time (request+queue+connect+response+processing), in milliseconds, averaged over the 1024 last requests (backend/server)" }, [ST_F_AGENT_STATUS] = { .name = "agent_status", .desc = "Status report of the server's latest agent check, prefixed with '*' if a check is currently in progress" }, [ST_F_AGENT_CODE] = { .name = "agent_code", .desc = "Status code reported by the latest server agent check" }, [ST_F_AGENT_DURATION] = { .name = "agent_duration", .desc = "Total duration of the latest server agent check, in milliseconds" }, [ST_F_CHECK_DESC] = { .name = "check_desc", .desc = "Textual description of the latest health check report for this server" }, [ST_F_AGENT_DESC] = { .name = "agent_desc", .desc = "Textual description of the latest agent check report for this server" }, [ST_F_CHECK_RISE] = { .name = "check_rise", .desc = "Number of successful health checks before declaring a server UP (server 'rise' setting)" }, [ST_F_CHECK_FALL] = { .name = "check_fall", .desc = "Number of failed health checks before declaring a server DOWN (server 'fall' setting)" }, [ST_F_CHECK_HEALTH] = { .name = "check_health", .desc = "Current server health check level (0..fall-1=DOWN, fall..rise-1=UP)" }, [ST_F_AGENT_RISE] = { .name = "agent_rise", .desc = "Number of successful agent checks before declaring a server UP (server 'rise' setting)" }, [ST_F_AGENT_FALL] = { .name = "agent_fall", .desc = "Number of failed agent checks before declaring a server DOWN (server 'fall' setting)" }, [ST_F_AGENT_HEALTH] = { .name = "agent_health", .desc = "Current server agent check level (0..fall-1=DOWN, fall..rise-1=UP)" }, [ST_F_ADDR] = { .name = "addr", .desc = "Server's address:port, shown only if show-legends is set, or at levels oper/admin for the CLI" }, [ST_F_COOKIE] = { .name = "cookie", .desc = "Backend's cookie name or Server's cookie value, shown only if show-legends is set, or at levels oper/admin for the CLI" }, [ST_F_MODE] = { .name = "mode", .desc = "'mode' setting (tcp/http/health/cli)" }, [ST_F_ALGO] = { .name = "algo", .desc = "Backend's load balancing algorithm, shown only if show-legends is set, or at levels oper/admin for the CLI" }, [ST_F_CONN_RATE] = { .name = "conn_rate", .desc = "Number of new connections accepted over the last second on the frontend for this worker process" }, [ST_F_CONN_RATE_MAX] = { .name = "conn_rate_max", .desc = "Highest value of 'conn_rate' observed since the worker process started" }, [ST_F_CONN_TOT] = { .name = "conn_tot", .desc = "Total number of new connections accepted on this frontend since the worker process started" }, [ST_F_INTERCEPTED] = { .name = "intercepted", .desc = "Total number of HTTP requests intercepted on the frontend (redirects/stats/services) since the worker process started" }, [ST_F_DCON] = { .name = "dcon", .desc = "Total number of incoming connections blocked on a listener/frontend by a tcp-request connection rule since the worker process started" }, [ST_F_DSES] = { .name = "dses", .desc = "Total number of incoming sessions blocked on a listener/frontend by a tcp-request connection rule since the worker process started" }, [ST_F_WREW] = { .name = "wrew", .desc = "Total number of failed HTTP header rewrites since the worker process started" }, [ST_F_CONNECT] = { .name = "connect", .desc = "Total number of outgoing connection attempts on this backend/server since the worker process started" }, [ST_F_REUSE] = { .name = "reuse", .desc = "Total number of reused connection on this backend/server since the worker process started" }, [ST_F_CACHE_LOOKUPS] = { .name = "cache_lookups", .desc = "Total number of HTTP requests looked up in the cache on this frontend/backend since the worker process started" }, [ST_F_CACHE_HITS] = { .name = "cache_hits", .desc = "Total number of HTTP requests not found in the cache on this frontend/backend since the worker process started" }, [ST_F_SRV_ICUR] = { .name = "srv_icur", .desc = "Current number of idle connections available for reuse on this server" }, [ST_F_SRV_ILIM] = { .name = "src_ilim", .desc = "Limit on the number of available idle connections on this server (server 'pool_max_conn' directive)" }, }; /* one line of info */ static THREAD_LOCAL struct field info[INF_TOTAL_FIELDS]; /* one line of stats */ static THREAD_LOCAL struct field stats[ST_F_TOTAL_FIELDS]; static void stats_dump_json_schema(struct buffer *out); static int stats_putchk(struct channel *chn, struct htx *htx, struct buffer *chk) { if (htx) { if (chk->data >= channel_htx_recv_max(chn, htx)) return 0; if (!htx_add_data_atonce(htx, ist2(chk->area, chk->data))) return 0; channel_add_input(chn, chk->data); chk->data = 0; } else { if (ci_putchk(chn, chk) == -1) return 0; } return 1; } static const char *stats_scope_ptr(struct appctx *appctx, struct stream_interface *si) { struct channel *req = si_oc(si); struct htx *htx = htxbuf(&req->buf); struct htx_blk *blk; struct ist uri; blk = htx_get_head_blk(htx); BUG_ON(htx_get_blk_type(blk) != HTX_BLK_REQ_SL); ALREADY_CHECKED(blk); uri = htx_sl_req_uri(htx_get_blk_ptr(htx, blk)); return uri.ptr + appctx->ctx.stats.scope_str; } /* * http_stats_io_handler() * -> stats_dump_stat_to_buffer() // same as above, but used for CSV or HTML * -> stats_dump_csv_header() // emits the CSV headers (same as above) * -> stats_dump_json_header() // emits the JSON headers (same as above) * -> stats_dump_html_head() // emits the HTML headers * -> stats_dump_html_info() // emits the equivalent of "show info" at the top * -> stats_dump_proxy_to_buffer() // same as above, valid for CSV and HTML * -> stats_dump_html_px_hdr() * -> stats_dump_fe_stats() * -> stats_dump_li_stats() * -> stats_dump_sv_stats() * -> stats_dump_be_stats() * -> stats_dump_html_px_end() * -> stats_dump_html_end() // emits HTML trailer * -> stats_dump_json_end() // emits JSON trailer */ /* Dumps the stats CSV header to the trash buffer which. The caller is responsible * for clearing it if needed. * NOTE: Some tools happen to rely on the field position instead of its name, * so please only append new fields at the end, never in the middle. */ static void stats_dump_csv_header() { int field; chunk_appendf(&trash, "# "); for (field = 0; field < ST_F_TOTAL_FIELDS; field++) chunk_appendf(&trash, "%s,", stat_fields[field].name); chunk_appendf(&trash, "\n"); } /* Emits a stats field without any surrounding element and properly encoded to * resist CSV output. Returns non-zero on success, 0 if the buffer is full. */ int stats_emit_raw_data_field(struct buffer *out, const struct field *f) { switch (field_format(f, 0)) { case FF_EMPTY: return 1; case FF_S32: return chunk_appendf(out, "%d", f->u.s32); case FF_U32: return chunk_appendf(out, "%u", f->u.u32); case FF_S64: return chunk_appendf(out, "%lld", (long long)f->u.s64); case FF_U64: return chunk_appendf(out, "%llu", (unsigned long long)f->u.u64); case FF_FLT: return chunk_appendf(out, "%f", f->u.flt); case FF_STR: return csv_enc_append(field_str(f, 0), 1, out) != NULL; default: return chunk_appendf(out, "[INCORRECT_FIELD_TYPE_%08x]", f->type); } } /* Emits a stats field prefixed with its type. No CSV encoding is prepared, the * output is supposed to be used on its own line. Returns non-zero on success, 0 * if the buffer is full. */ int stats_emit_typed_data_field(struct buffer *out, const struct field *f) { switch (field_format(f, 0)) { case FF_EMPTY: return 1; case FF_S32: return chunk_appendf(out, "s32:%d", f->u.s32); case FF_U32: return chunk_appendf(out, "u32:%u", f->u.u32); case FF_S64: return chunk_appendf(out, "s64:%lld", (long long)f->u.s64); case FF_U64: return chunk_appendf(out, "u64:%llu", (unsigned long long)f->u.u64); case FF_FLT: return chunk_appendf(out, "flt:%f", f->u.flt); case FF_STR: return chunk_appendf(out, "str:%s", field_str(f, 0)); default: return chunk_appendf(out, "%08x:?", f->type); } } /* Limit JSON integer values to the range [-(2**53)+1, (2**53)-1] as per * the recommendation for interoperable integers in section 6 of RFC 7159. */ #define JSON_INT_MAX ((1ULL << 53) - 1) #define JSON_INT_MIN (0 - JSON_INT_MAX) /* Emits a stats field value and its type in JSON. * Returns non-zero on success, 0 on error. */ int stats_emit_json_data_field(struct buffer *out, const struct field *f) { int old_len; char buf[20]; const char *type, *value = buf, *quote = ""; switch (field_format(f, 0)) { case FF_EMPTY: return 1; case FF_S32: type = "\"s32\""; snprintf(buf, sizeof(buf), "%d", f->u.s32); break; case FF_U32: type = "\"u32\""; snprintf(buf, sizeof(buf), "%u", f->u.u32); break; case FF_S64: type = "\"s64\""; if (f->u.s64 < JSON_INT_MIN || f->u.s64 > JSON_INT_MAX) return 0; type = "\"s64\""; snprintf(buf, sizeof(buf), "%lld", (long long)f->u.s64); break; case FF_U64: if (f->u.u64 > JSON_INT_MAX) return 0; type = "\"u64\""; snprintf(buf, sizeof(buf), "%llu", (unsigned long long) f->u.u64); break; case FF_FLT: type = "\"flt\""; snprintf(buf, sizeof(buf), "%f", f->u.flt); break; case FF_STR: type = "\"str\""; value = field_str(f, 0); quote = "\""; break; default: snprintf(buf, sizeof(buf), "%u", f->type); type = buf; value = "unknown"; quote = "\""; break; } old_len = out->data; chunk_appendf(out, ",\"value\":{\"type\":%s,\"value\":%s%s%s}", type, quote, value, quote); return !(old_len == out->data); } /* Emits an encoding of the field type on 3 characters followed by a delimiter. * Returns non-zero on success, 0 if the buffer is full. */ int stats_emit_field_tags(struct buffer *out, const struct field *f, char delim) { char origin, nature, scope; switch (field_origin(f, 0)) { case FO_METRIC: origin = 'M'; break; case FO_STATUS: origin = 'S'; break; case FO_KEY: origin = 'K'; break; case FO_CONFIG: origin = 'C'; break; case FO_PRODUCT: origin = 'P'; break; default: origin = '?'; break; } switch (field_nature(f, 0)) { case FN_GAUGE: nature = 'G'; break; case FN_LIMIT: nature = 'L'; break; case FN_MIN: nature = 'm'; break; case FN_MAX: nature = 'M'; break; case FN_RATE: nature = 'R'; break; case FN_COUNTER: nature = 'C'; break; case FN_DURATION: nature = 'D'; break; case FN_AGE: nature = 'A'; break; case FN_TIME: nature = 'T'; break; case FN_NAME: nature = 'N'; break; case FN_OUTPUT: nature = 'O'; break; case FN_AVG: nature = 'a'; break; default: nature = '?'; break; } switch (field_scope(f, 0)) { case FS_PROCESS: scope = 'P'; break; case FS_SERVICE: scope = 'S'; break; case FS_SYSTEM: scope = 's'; break; case FS_CLUSTER: scope = 'C'; break; default: scope = '?'; break; } return chunk_appendf(out, "%c%c%c%c", origin, nature, scope, delim); } /* Emits an encoding of the field type as JSON. * Returns non-zero on success, 0 if the buffer is full. */ int stats_emit_json_field_tags(struct buffer *out, const struct field *f) { const char *origin, *nature, *scope; int old_len; switch (field_origin(f, 0)) { case FO_METRIC: origin = "Metric"; break; case FO_STATUS: origin = "Status"; break; case FO_KEY: origin = "Key"; break; case FO_CONFIG: origin = "Config"; break; case FO_PRODUCT: origin = "Product"; break; default: origin = "Unknown"; break; } switch (field_nature(f, 0)) { case FN_GAUGE: nature = "Gauge"; break; case FN_LIMIT: nature = "Limit"; break; case FN_MIN: nature = "Min"; break; case FN_MAX: nature = "Max"; break; case FN_RATE: nature = "Rate"; break; case FN_COUNTER: nature = "Counter"; break; case FN_DURATION: nature = "Duration"; break; case FN_AGE: nature = "Age"; break; case FN_TIME: nature = "Time"; break; case FN_NAME: nature = "Name"; break; case FN_OUTPUT: nature = "Output"; break; case FN_AVG: nature = "Avg"; break; default: nature = "Unknown"; break; } switch (field_scope(f, 0)) { case FS_PROCESS: scope = "Process"; break; case FS_SERVICE: scope = "Service"; break; case FS_SYSTEM: scope = "System"; break; case FS_CLUSTER: scope = "Cluster"; break; default: scope = "Unknown"; break; } old_len = out->data; chunk_appendf(out, "\"tags\":{" "\"origin\":\"%s\"," "\"nature\":\"%s\"," "\"scope\":\"%s\"" "}", origin, nature, scope); return !(old_len == out->data); } /* Dump all fields from into using CSV format */ static int stats_dump_fields_csv(struct buffer *out, const struct field *stats, unsigned int flags) { int field; for (field = 0; field < ST_F_TOTAL_FIELDS; field++) { if (!stats_emit_raw_data_field(out, &stats[field])) return 0; if (!chunk_strcat(out, ",")) return 0; } chunk_strcat(out, "\n"); return 1; } /* Dump all fields from into using a typed "field:desc:type:value" format */ static int stats_dump_fields_typed(struct buffer *out, const struct field *stats, unsigned int flags) { int field; for (field = 0; field < ST_F_TOTAL_FIELDS; field++) { if (!stats[field].type) continue; chunk_appendf(out, "%c.%u.%u.%d.%s.%u:", stats[ST_F_TYPE].u.u32 == STATS_TYPE_FE ? 'F' : stats[ST_F_TYPE].u.u32 == STATS_TYPE_BE ? 'B' : stats[ST_F_TYPE].u.u32 == STATS_TYPE_SO ? 'L' : stats[ST_F_TYPE].u.u32 == STATS_TYPE_SV ? 'S' : '?', stats[ST_F_IID].u.u32, stats[ST_F_SID].u.u32, field, stat_fields[field].name, stats[ST_F_PID].u.u32); if (!stats_emit_field_tags(out, &stats[field], ':')) return 0; if (!stats_emit_typed_data_field(out, &stats[field])) return 0; if ((flags & STAT_SHOW_FDESC) && !chunk_appendf(out, ":\"%s\"", stat_fields[field].desc)) return 0; if (!chunk_strcat(out, "\n")) return 0; } return 1; } /* Dump all fields from into using the "show info json" format */ static int stats_dump_json_info_fields(struct buffer *out, const struct field *info, unsigned int flags) { int field; int started = 0; if (!chunk_strcat(out, "[")) return 0; for (field = 0; field < INF_TOTAL_FIELDS; field++) { int old_len; if (!field_format(info, field)) continue; if (started && !chunk_strcat(out, ",")) goto err; started = 1; old_len = out->data; chunk_appendf(out, "{\"field\":{\"pos\":%d,\"name\":\"%s\"}," "\"processNum\":%u,", field, info_fields[field].name, info[INF_PROCESS_NUM].u.u32); if (old_len == out->data) goto err; if (!stats_emit_json_field_tags(out, &info[field])) goto err; if (!stats_emit_json_data_field(out, &info[field])) goto err; if (!chunk_strcat(out, "}")) goto err; } if (!chunk_strcat(out, "]")) goto err; return 1; err: chunk_reset(out); chunk_appendf(out, "{\"errorStr\":\"output buffer too short\"}"); return 0; } /* Dump all fields from into using a typed "field:desc:type:value" format */ static int stats_dump_fields_json(struct buffer *out, const struct field *stats, unsigned int flags) { int field; int started = 0; if ((flags & STAT_STARTED) && !chunk_strcat(out, ",")) return 0; if (!chunk_strcat(out, "[")) return 0; for (field = 0; field < ST_F_TOTAL_FIELDS; field++) { const char *obj_type; int old_len; if (!stats[field].type) continue; if (started && !chunk_strcat(out, ",")) goto err; started = 1; switch (stats[ST_F_TYPE].u.u32) { case STATS_TYPE_FE: obj_type = "Frontend"; break; case STATS_TYPE_BE: obj_type = "Backend"; break; case STATS_TYPE_SO: obj_type = "Listener"; break; case STATS_TYPE_SV: obj_type = "Server"; break; default: obj_type = "Unknown"; break; } old_len = out->data; chunk_appendf(out, "{" "\"objType\":\"%s\"," "\"proxyId\":%d," "\"id\":%d," "\"field\":{\"pos\":%d,\"name\":\"%s\"}," "\"processNum\":%u,", obj_type, stats[ST_F_IID].u.u32, stats[ST_F_SID].u.u32, field, stat_fields[field].name, stats[ST_F_PID].u.u32); if (old_len == out->data) goto err; if (!stats_emit_json_field_tags(out, &stats[field])) goto err; if (!stats_emit_json_data_field(out, &stats[field])) goto err; if (!chunk_strcat(out, "}")) goto err; } if (!chunk_strcat(out, "]")) goto err; return 1; err: chunk_reset(out); if (flags & STAT_STARTED) chunk_strcat(out, ","); chunk_appendf(out, "{\"errorStr\":\"output buffer too short\"}"); return 0; } /* Dump all fields from into using the HTML format. A column is * reserved for the checkbox is STAT_ADMIN is set in . Some extra info * are provided if STAT_SHLGNDS is present in . */ static int stats_dump_fields_html(struct buffer *out, const struct field *stats, unsigned int flags) { struct buffer src; if (stats[ST_F_TYPE].u.u32 == STATS_TYPE_FE) { chunk_appendf(out, /* name, queue */ ""); if (flags & STAT_ADMIN) { /* Column sub-heading for Enable or Disable server */ chunk_appendf(out, ""); } chunk_appendf(out, "" "" "Frontend" "" "", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_PXNAME)); chunk_appendf(out, /* sessions rate : current */ "%s
" "" "" "", U2H(stats[ST_F_RATE].u.u32), U2H(stats[ST_F_CONN_RATE].u.u32), U2H(stats[ST_F_RATE].u.u32)); if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) chunk_appendf(out, "", U2H(stats[ST_F_REQ_RATE].u.u32)); chunk_appendf(out, "
Current connection rate:%s/s
Current session rate:%s/s
Current request rate:%s/s
" /* sessions rate : max */ "%s
" "" "" "", U2H(stats[ST_F_RATE_MAX].u.u32), U2H(stats[ST_F_CONN_RATE_MAX].u.u32), U2H(stats[ST_F_RATE_MAX].u.u32)); if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) chunk_appendf(out, "", U2H(stats[ST_F_REQ_RATE_MAX].u.u32)); chunk_appendf(out, "
Max connection rate:%s/s
Max session rate:%s/s
Max request rate:%s/s
" /* sessions rate : limit */ "%s", LIM2A(stats[ST_F_RATE_LIM].u.u32, "-")); chunk_appendf(out, /* sessions: current, max, limit, total */ "%s%s%s" "%s
" "" "" "", U2H(stats[ST_F_SCUR].u.u32), U2H(stats[ST_F_SMAX].u.u32), U2H(stats[ST_F_SLIM].u.u32), U2H(stats[ST_F_STOT].u.u64), U2H(stats[ST_F_CONN_TOT].u.u64), U2H(stats[ST_F_STOT].u.u64)); /* http response (via hover): 1xx, 2xx, 3xx, 4xx, 5xx, other */ if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) { chunk_appendf(out, "" "" "" "" "" "" "" "" "" "" "" "" "", U2H(stats[ST_F_REQ_TOT].u.u64), U2H(stats[ST_F_HRSP_1XX].u.u64), U2H(stats[ST_F_HRSP_2XX].u.u64), U2H(stats[ST_F_COMP_RSP].u.u64), stats[ST_F_HRSP_2XX].u.u64 ? (int)(100 * stats[ST_F_COMP_RSP].u.u64 / stats[ST_F_HRSP_2XX].u.u64) : 0, U2H(stats[ST_F_HRSP_3XX].u.u64), U2H(stats[ST_F_HRSP_4XX].u.u64), U2H(stats[ST_F_HRSP_5XX].u.u64), U2H(stats[ST_F_HRSP_OTHER].u.u64), U2H(stats[ST_F_INTERCEPTED].u.u64), U2H(stats[ST_F_CACHE_LOOKUPS].u.u64), U2H(stats[ST_F_CACHE_HITS].u.u64), stats[ST_F_CACHE_LOOKUPS].u.u64 ? (int)(100 * stats[ST_F_CACHE_HITS].u.u64 / stats[ST_F_CACHE_LOOKUPS].u.u64) : 0, U2H(stats[ST_F_WREW].u.u64)); } chunk_appendf(out, "
Cum. connections:%s
Cum. sessions:%s
Cum. HTTP requests:%s
- HTTP 1xx responses:%s
- HTTP 2xx responses:%s
  Compressed 2xx:%s(%d%%)
- HTTP 3xx responses:%s
- HTTP 4xx responses:%s
- HTTP 5xx responses:%s
- other responses:%s
Intercepted requests:%s
Cache lookups:%s
Cache hits:%s(%d%%)
Failed hdr rewrites:%s
" /* sessions: lbtot, lastsess */ "" /* bytes : in */ "%s" "", U2H(stats[ST_F_BIN].u.u64)); chunk_appendf(out, /* bytes:out + compression stats (via hover): comp_in, comp_out, comp_byp */ "%s%s
" "" "" "" "" "" "
Response bytes in:%s
Compression in:%s
Compression out:%s(%d%%)
Compression bypass:%s
Total bytes saved:%s(%d%%)
%s", (stats[ST_F_COMP_IN].u.u64 || stats[ST_F_COMP_BYP].u.u64) ? "":"", U2H(stats[ST_F_BOUT].u.u64), U2H(stats[ST_F_BOUT].u.u64), U2H(stats[ST_F_COMP_IN].u.u64), U2H(stats[ST_F_COMP_OUT].u.u64), stats[ST_F_COMP_IN].u.u64 ? (int)(stats[ST_F_COMP_OUT].u.u64 * 100 / stats[ST_F_COMP_IN].u.u64) : 0, U2H(stats[ST_F_COMP_BYP].u.u64), U2H(stats[ST_F_COMP_IN].u.u64 - stats[ST_F_COMP_OUT].u.u64), stats[ST_F_BOUT].u.u64 ? (int)((stats[ST_F_COMP_IN].u.u64 - stats[ST_F_COMP_OUT].u.u64) * 100 / stats[ST_F_BOUT].u.u64) : 0, (stats[ST_F_COMP_IN].u.u64 || stats[ST_F_COMP_BYP].u.u64) ? "":""); chunk_appendf(out, /* denied: req, resp */ "%s%s" /* errors : request, connect, response */ "%s" /* warnings: retries, redispatches */ "" /* server status : reflect frontend status */ "%s" /* rest of server: nothing */ "" "", U2H(stats[ST_F_DREQ].u.u64), U2H(stats[ST_F_DRESP].u.u64), U2H(stats[ST_F_EREQ].u.u64), field_str(stats, ST_F_STATUS)); } else if (stats[ST_F_TYPE].u.u32 == STATS_TYPE_SO) { chunk_appendf(out, ""); if (flags & STAT_ADMIN) { /* Column sub-heading for Enable or Disable server */ chunk_appendf(out, ""); } chunk_appendf(out, /* frontend name, listener name */ "%s" "%s" "", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_SVNAME), (flags & STAT_SHLGNDS)?"":"", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_SVNAME), field_str(stats, ST_F_SVNAME)); if (flags & STAT_SHLGNDS) { chunk_appendf(out, "
"); if (isdigit(*field_str(stats, ST_F_ADDR))) chunk_appendf(out, "IPv4: %s, ", field_str(stats, ST_F_ADDR)); else if (*field_str(stats, ST_F_ADDR) == '[') chunk_appendf(out, "IPv6: %s, ", field_str(stats, ST_F_ADDR)); else if (*field_str(stats, ST_F_ADDR)) chunk_appendf(out, "%s, ", field_str(stats, ST_F_ADDR)); /* id */ chunk_appendf(out, "id: %d
", stats[ST_F_SID].u.u32); } chunk_appendf(out, /* queue */ "%s" /* sessions rate: current, max, limit */ " " /* sessions: current, max, limit, total, lbtot, lastsess */ "%s%s%s" "%s  " /* bytes: in, out */ "%s%s" "", (flags & STAT_SHLGNDS)?"":"", U2H(stats[ST_F_SCUR].u.u32), U2H(stats[ST_F_SMAX].u.u32), U2H(stats[ST_F_SLIM].u.u32), U2H(stats[ST_F_STOT].u.u64), U2H(stats[ST_F_BIN].u.u64), U2H(stats[ST_F_BOUT].u.u64)); chunk_appendf(out, /* denied: req, resp */ "%s%s" /* errors: request, connect, response */ "%s" /* warnings: retries, redispatches */ "" /* server status: reflect listener status */ "%s" /* rest of server: nothing */ "" "", U2H(stats[ST_F_DREQ].u.u64), U2H(stats[ST_F_DRESP].u.u64), U2H(stats[ST_F_EREQ].u.u64), field_str(stats, ST_F_STATUS)); } else if (stats[ST_F_TYPE].u.u32 == STATS_TYPE_SV) { const char *style; /* determine the style to use depending on the server's state, * its health and weight. There isn't a 1-to-1 mapping between * state and styles for the cases where the server is (still) * up. The reason is that we don't want to report nolb and * drain with the same color. */ if (strcmp(field_str(stats, ST_F_STATUS), "DOWN") == 0 || strcmp(field_str(stats, ST_F_STATUS), "DOWN (agent)") == 0) { style = "down"; } else if (strcmp(field_str(stats, ST_F_STATUS), "DOWN ") == 0) { style = "going_up"; } else if (strcmp(field_str(stats, ST_F_STATUS), "NOLB ") == 0) { style = "going_down"; } else if (strcmp(field_str(stats, ST_F_STATUS), "NOLB") == 0) { style = "nolb"; } else if (strcmp(field_str(stats, ST_F_STATUS), "no check") == 0) { style = "no_check"; } else if (!stats[ST_F_CHKFAIL].type || stats[ST_F_CHECK_HEALTH].u.u32 == stats[ST_F_CHECK_RISE].u.u32 + stats[ST_F_CHECK_FALL].u.u32 - 1) { /* no check or max health = UP */ if (stats[ST_F_WEIGHT].u.u32) style = "up"; else style = "draining"; } else { style = "going_down"; } if (memcmp(field_str(stats, ST_F_STATUS), "MAINT", 5) == 0) chunk_appendf(out, ""); else chunk_appendf(out, "", (stats[ST_F_BCK].u.u32) ? "backup" : "active", style); if (flags & STAT_ADMIN) chunk_appendf(out, "", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_SVNAME)); chunk_appendf(out, "%s" "%s" "", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_SVNAME), (flags & STAT_SHLGNDS) ? "" : "", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_SVNAME), field_str(stats, ST_F_SVNAME)); if (flags & STAT_SHLGNDS) { chunk_appendf(out, "
"); if (isdigit(*field_str(stats, ST_F_ADDR))) chunk_appendf(out, "IPv4: %s, ", field_str(stats, ST_F_ADDR)); else if (*field_str(stats, ST_F_ADDR) == '[') chunk_appendf(out, "IPv6: %s, ", field_str(stats, ST_F_ADDR)); else if (*field_str(stats, ST_F_ADDR)) chunk_appendf(out, "%s, ", field_str(stats, ST_F_ADDR)); /* id */ chunk_appendf(out, "id: %d", stats[ST_F_SID].u.u32); /* cookie */ if (stats[ST_F_COOKIE].type) { chunk_appendf(out, ", cookie: '"); chunk_initstr(&src, field_str(stats, ST_F_COOKIE)); chunk_htmlencode(out, &src); chunk_appendf(out, "'"); } chunk_appendf(out, "
"); } chunk_appendf(out, /* queue : current, max, limit */ "%s%s%s%s" /* sessions rate : current, max, limit */ "%s%s" "", (flags & STAT_SHLGNDS) ? "" : "", U2H(stats[ST_F_QCUR].u.u32), U2H(stats[ST_F_QMAX].u.u32), LIM2A(stats[ST_F_QLIMIT].u.u32, "-"), U2H(stats[ST_F_RATE].u.u32), U2H(stats[ST_F_RATE_MAX].u.u32)); chunk_appendf(out, /* sessions: current, max, limit, total */ "%s
" "" "" "" "" "" "
Current active connections:%s
Current idle connections:%s
Active connections limit:%s
Idle connections limit:%s
" "%s%s" "%s
" "" "", U2H(stats[ST_F_SCUR].u.u32), U2H(stats[ST_F_SCUR].u.u32), U2H(stats[ST_F_SRV_ICUR].u.u32), LIM2A(stats[ST_F_SLIM].u.u32, "-"), stats[ST_F_SRV_ILIM].type ? U2H(stats[ST_F_SRV_ILIM].u.u32) : "-", U2H(stats[ST_F_SMAX].u.u32), LIM2A(stats[ST_F_SLIM].u.u32, "-"), U2H(stats[ST_F_STOT].u.u64), U2H(stats[ST_F_STOT].u.u64)); /* http response (via hover): 1xx, 2xx, 3xx, 4xx, 5xx, other */ if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) { unsigned long long tot; tot = stats[ST_F_HRSP_OTHER].u.u64; tot += stats[ST_F_HRSP_1XX].u.u64; tot += stats[ST_F_HRSP_2XX].u.u64; tot += stats[ST_F_HRSP_3XX].u.u64; tot += stats[ST_F_HRSP_4XX].u.u64; tot += stats[ST_F_HRSP_5XX].u.u64; chunk_appendf(out, "" "" "" "" "" "" "" "" "" "" "", U2H(stats[ST_F_CONNECT].u.u64), U2H(stats[ST_F_REUSE].u.u64), (stats[ST_F_CONNECT].u.u64 + stats[ST_F_REUSE].u.u64) ? (int)(100 * stats[ST_F_REUSE].u.u64 / (stats[ST_F_CONNECT].u.u64 + stats[ST_F_REUSE].u.u64)) : 0, U2H(tot), U2H(stats[ST_F_HRSP_1XX].u.u64), tot ? (int)(100 * stats[ST_F_HRSP_1XX].u.u64 / tot) : 0, U2H(stats[ST_F_HRSP_2XX].u.u64), tot ? (int)(100 * stats[ST_F_HRSP_2XX].u.u64 / tot) : 0, U2H(stats[ST_F_HRSP_3XX].u.u64), tot ? (int)(100 * stats[ST_F_HRSP_3XX].u.u64 / tot) : 0, U2H(stats[ST_F_HRSP_4XX].u.u64), tot ? (int)(100 * stats[ST_F_HRSP_4XX].u.u64 / tot) : 0, U2H(stats[ST_F_HRSP_5XX].u.u64), tot ? (int)(100 * stats[ST_F_HRSP_5XX].u.u64 / tot) : 0, U2H(stats[ST_F_HRSP_OTHER].u.u64), tot ? (int)(100 * stats[ST_F_HRSP_OTHER].u.u64 / tot) : 0, U2H(stats[ST_F_WREW].u.u64)); } chunk_appendf(out, ""); chunk_appendf(out, "", U2H(stats[ST_F_QTIME].u.u32)); chunk_appendf(out, "", U2H(stats[ST_F_CTIME].u.u32)); if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) chunk_appendf(out, "", U2H(stats[ST_F_RTIME].u.u32)); chunk_appendf(out, "", U2H(stats[ST_F_TTIME].u.u32)); chunk_appendf(out, "
Cum. sessions:%s
New connections:%s
Reused connections:%s(%d%%)
Cum. HTTP responses:%s
- HTTP 1xx responses:%s(%d%%)
- HTTP 2xx responses:%s(%d%%)
- HTTP 3xx responses:%s(%d%%)
- HTTP 4xx responses:%s(%d%%)
- HTTP 5xx responses:%s(%d%%)
- other responses:%s(%d%%)
Failed hdr rewrites:%s
Avg over last 1024 success. conn.
- Queue time:%sms
- Connect time:%sms
- Response time:%sms
- Total time:%sms
" /* sessions: lbtot, last */ "%s%s", U2H(stats[ST_F_LBTOT].u.u64), human_time(stats[ST_F_LASTSESS].u.s32, 1)); chunk_appendf(out, /* bytes : in, out */ "%s%s" /* denied: req, resp */ "%s" /* errors : request, connect */ "%s" /* errors : response */ "%s
Connection resets during transfers: %lld client, %lld server
" /* warnings: retries, redispatches */ "%lld%lld" "", U2H(stats[ST_F_BIN].u.u64), U2H(stats[ST_F_BOUT].u.u64), U2H(stats[ST_F_DRESP].u.u64), U2H(stats[ST_F_ECON].u.u64), U2H(stats[ST_F_ERESP].u.u64), (long long)stats[ST_F_CLI_ABRT].u.u64, (long long)stats[ST_F_SRV_ABRT].u.u64, (long long)stats[ST_F_WRETR].u.u64, (long long)stats[ST_F_WREDIS].u.u64); /* status, last change */ chunk_appendf(out, ""); /* FIXME!!!! * LASTCHG should contain the last change for *this* server and must be computed * properly above, as was done below, ie: this server if maint, otherwise ref server * if tracking. Note that ref is either local or remote depending on tracking. */ if (memcmp(field_str(stats, ST_F_STATUS), "MAINT", 5) == 0) { chunk_appendf(out, "%s MAINT", human_time(stats[ST_F_LASTCHG].u.u32, 1)); } else if (memcmp(field_str(stats, ST_F_STATUS), "no check", 5) == 0) { chunk_strcat(out, "no check"); } else { chunk_appendf(out, "%s %s", human_time(stats[ST_F_LASTCHG].u.u32, 1), field_str(stats, ST_F_STATUS)); if (memcmp(field_str(stats, ST_F_STATUS), "DOWN", 4) == 0) { if (stats[ST_F_CHECK_HEALTH].u.u32) chunk_strcat(out, " ↑"); } else if (stats[ST_F_CHECK_HEALTH].u.u32 < stats[ST_F_CHECK_RISE].u.u32 + stats[ST_F_CHECK_FALL].u.u32 - 1) chunk_strcat(out, " ↓"); } if (memcmp(field_str(stats, ST_F_STATUS), "DOWN", 4) == 0 && stats[ST_F_AGENT_STATUS].type && !stats[ST_F_AGENT_HEALTH].u.u32) { chunk_appendf(out, " %s", field_str(stats, ST_F_AGENT_STATUS)); if (stats[ST_F_AGENT_CODE].type) chunk_appendf(out, "/%d", stats[ST_F_AGENT_CODE].u.u32); if (stats[ST_F_AGENT_DURATION].type) chunk_appendf(out, " in %lums", (long)stats[ST_F_AGENT_DURATION].u.u64); chunk_appendf(out, "
%s", field_str(stats, ST_F_AGENT_DESC)); if (*field_str(stats, ST_F_LAST_AGT)) { chunk_appendf(out, ": "); chunk_initstr(&src, field_str(stats, ST_F_LAST_AGT)); chunk_htmlencode(out, &src); } chunk_appendf(out, "
"); } else if (stats[ST_F_CHECK_STATUS].type) { chunk_appendf(out, " %s", field_str(stats, ST_F_CHECK_STATUS)); if (stats[ST_F_CHECK_CODE].type) chunk_appendf(out, "/%d", stats[ST_F_CHECK_CODE].u.u32); if (stats[ST_F_CHECK_DURATION].type) chunk_appendf(out, " in %lums", (long)stats[ST_F_CHECK_DURATION].u.u64); chunk_appendf(out, "
%s", field_str(stats, ST_F_CHECK_DESC)); if (*field_str(stats, ST_F_LAST_CHK)) { chunk_appendf(out, ": "); chunk_initstr(&src, field_str(stats, ST_F_LAST_CHK)); chunk_htmlencode(out, &src); } chunk_appendf(out, "
"); } else chunk_appendf(out, ""); chunk_appendf(out, /* weight */ "%d" /* act, bck */ "%s%s" "", stats[ST_F_WEIGHT].u.u32, stats[ST_F_BCK].u.u32 ? "-" : "Y", stats[ST_F_BCK].u.u32 ? "Y" : "-"); /* check failures: unique, fatal, down time */ if (strcmp(field_str(stats, ST_F_STATUS), "MAINT (resolution)") == 0) { chunk_appendf(out, "resolution"); } else if (stats[ST_F_CHKFAIL].type) { chunk_appendf(out, "%lld", (long long)stats[ST_F_CHKFAIL].u.u64); if (stats[ST_F_HANAFAIL].type) chunk_appendf(out, "/%lld", (long long)stats[ST_F_HANAFAIL].u.u64); chunk_appendf(out, "
Failed Health Checks%s
" "%lld%s" "", stats[ST_F_HANAFAIL].type ? "/Health Analyses" : "", (long long)stats[ST_F_CHKDOWN].u.u64, human_time(stats[ST_F_DOWNTIME].u.u32, 1)); } else if (strcmp(field_str(stats, ST_F_STATUS), "MAINT") != 0 && field_format(stats, ST_F_TRACKED) == FF_STR) { /* tracking a server (hence inherited maint would appear as "MAINT (via...)" */ chunk_appendf(out, "via %s", field_str(stats, ST_F_TRACKED), field_str(stats, ST_F_TRACKED)); } else chunk_appendf(out, ""); /* throttle */ if (stats[ST_F_THROTTLE].type) chunk_appendf(out, "%d %%\n", stats[ST_F_THROTTLE].u.u32); else chunk_appendf(out, "-\n"); } else if (stats[ST_F_TYPE].u.u32 == STATS_TYPE_BE) { chunk_appendf(out, ""); if (flags & STAT_ADMIN) { /* Column sub-heading for Enable or Disable server */ chunk_appendf(out, ""); } chunk_appendf(out, "" /* name */ "%s" "Backend" "", (flags & STAT_SHLGNDS)?"":"", field_str(stats, ST_F_PXNAME), field_str(stats, ST_F_PXNAME)); if (flags & STAT_SHLGNDS) { /* balancing */ chunk_appendf(out, "
balancing: %s", field_str(stats, ST_F_ALGO)); /* cookie */ if (stats[ST_F_COOKIE].type) { chunk_appendf(out, ", cookie: '"); chunk_initstr(&src, field_str(stats, ST_F_COOKIE)); chunk_htmlencode(out, &src); chunk_appendf(out, "'"); } chunk_appendf(out, "
"); } chunk_appendf(out, "%s" /* queue : current, max */ "%s%s" /* sessions rate : current, max, limit */ "%s%s" "", (flags & STAT_SHLGNDS)?"":"", U2H(stats[ST_F_QCUR].u.u32), U2H(stats[ST_F_QMAX].u.u32), U2H(stats[ST_F_RATE].u.u32), U2H(stats[ST_F_RATE_MAX].u.u32)); chunk_appendf(out, /* sessions: current, max, limit, total */ "%s%s%s" "%s
" "" "", U2H(stats[ST_F_SCUR].u.u32), U2H(stats[ST_F_SMAX].u.u32), U2H(stats[ST_F_SLIM].u.u32), U2H(stats[ST_F_STOT].u.u64), U2H(stats[ST_F_STOT].u.u64)); /* http response (via hover): 1xx, 2xx, 3xx, 4xx, 5xx, other */ if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) { chunk_appendf(out, "" "" "" "" "" "" "" "" "" "" "" "" "" "" "", U2H(stats[ST_F_CONNECT].u.u64), U2H(stats[ST_F_REUSE].u.u64), (stats[ST_F_CONNECT].u.u64 + stats[ST_F_REUSE].u.u64) ? (int)(100 * stats[ST_F_REUSE].u.u64 / (stats[ST_F_CONNECT].u.u64 + stats[ST_F_REUSE].u.u64)) : 0, U2H(stats[ST_F_REQ_TOT].u.u64), U2H(stats[ST_F_HRSP_1XX].u.u64), U2H(stats[ST_F_HRSP_2XX].u.u64), U2H(stats[ST_F_COMP_RSP].u.u64), stats[ST_F_HRSP_2XX].u.u64 ? (int)(100 * stats[ST_F_COMP_RSP].u.u64 / stats[ST_F_HRSP_2XX].u.u64) : 0, U2H(stats[ST_F_HRSP_3XX].u.u64), U2H(stats[ST_F_HRSP_4XX].u.u64), U2H(stats[ST_F_HRSP_5XX].u.u64), U2H(stats[ST_F_HRSP_OTHER].u.u64), U2H(stats[ST_F_CACHE_LOOKUPS].u.u64), U2H(stats[ST_F_CACHE_HITS].u.u64), stats[ST_F_CACHE_LOOKUPS].u.u64 ? (int)(100 * stats[ST_F_CACHE_HITS].u.u64 / stats[ST_F_CACHE_LOOKUPS].u.u64) : 0, U2H(stats[ST_F_WREW].u.u64)); } chunk_appendf(out, "", U2H(stats[ST_F_QTIME].u.u32)); chunk_appendf(out, "", U2H(stats[ST_F_CTIME].u.u32)); if (strcmp(field_str(stats, ST_F_MODE), "http") == 0) chunk_appendf(out, "", U2H(stats[ST_F_RTIME].u.u32)); chunk_appendf(out, "", U2H(stats[ST_F_TTIME].u.u32)); chunk_appendf(out, "
Cum. sessions:%s
New connections:%s
Reused connections:%s(%d%%)
Cum. HTTP requests:%s
- HTTP 1xx responses:%s
- HTTP 2xx responses:%s
  Compressed 2xx:%s(%d%%)
- HTTP 3xx responses:%s
- HTTP 4xx responses:%s
- HTTP 5xx responses:%s
- other responses:%s
Cache lookups:%s
Cache hits:%s(%d%%)
Failed hdr rewrites:%s
Avg over last 1024 success. conn.
- Queue time:%sms
- Connect time:%sms
- Response time:%sms
- Total time:%sms
" /* sessions: lbtot, last */ "%s%s" /* bytes: in */ "%s" "", U2H(stats[ST_F_LBTOT].u.u64), human_time(stats[ST_F_LASTSESS].u.s32, 1), U2H(stats[ST_F_BIN].u.u64)); chunk_appendf(out, /* bytes:out + compression stats (via hover): comp_in, comp_out, comp_byp */ "%s%s
" "" "" "" "" "" "
Response bytes in:%s
Compression in:%s
Compression out:%s(%d%%)
Compression bypass:%s
Total bytes saved:%s(%d%%)
%s", (stats[ST_F_COMP_IN].u.u64 || stats[ST_F_COMP_BYP].u.u64) ? "":"", U2H(stats[ST_F_BOUT].u.u64), U2H(stats[ST_F_BOUT].u.u64), U2H(stats[ST_F_COMP_IN].u.u64), U2H(stats[ST_F_COMP_OUT].u.u64), stats[ST_F_COMP_IN].u.u64 ? (int)(stats[ST_F_COMP_OUT].u.u64 * 100 / stats[ST_F_COMP_IN].u.u64) : 0, U2H(stats[ST_F_COMP_BYP].u.u64), U2H(stats[ST_F_COMP_IN].u.u64 - stats[ST_F_COMP_OUT].u.u64), stats[ST_F_BOUT].u.u64 ? (int)((stats[ST_F_COMP_IN].u.u64 - stats[ST_F_COMP_OUT].u.u64) * 100 / stats[ST_F_BOUT].u.u64) : 0, (stats[ST_F_COMP_IN].u.u64 || stats[ST_F_COMP_BYP].u.u64) ? "":""); chunk_appendf(out, /* denied: req, resp */ "%s%s" /* errors : request, connect */ "%s" /* errors : response */ "%s
Connection resets during transfers: %lld client, %lld server
" /* warnings: retries, redispatches */ "%lld%lld" /* backend status: reflect backend status (up/down): we display UP * if the backend has known working servers or if it has no server at * all (eg: for stats). Then we display the total weight, number of * active and backups. */ "%s %s %d" "%d%d" "", U2H(stats[ST_F_DREQ].u.u64), U2H(stats[ST_F_DRESP].u.u64), U2H(stats[ST_F_ECON].u.u64), U2H(stats[ST_F_ERESP].u.u64), (long long)stats[ST_F_CLI_ABRT].u.u64, (long long)stats[ST_F_SRV_ABRT].u.u64, (long long)stats[ST_F_WRETR].u.u64, (long long)stats[ST_F_WREDIS].u.u64, human_time(stats[ST_F_LASTCHG].u.u32, 1), strcmp(field_str(stats, ST_F_STATUS), "DOWN") ? field_str(stats, ST_F_STATUS) : "DOWN", stats[ST_F_WEIGHT].u.u32, stats[ST_F_ACT].u.u32, stats[ST_F_BCK].u.u32); chunk_appendf(out, /* rest of backend: nothing, down transitions, total downtime, throttle */ " %d" "%s" "" "", stats[ST_F_CHKDOWN].u.u32, stats[ST_F_DOWNTIME].type ? human_time(stats[ST_F_DOWNTIME].u.u32, 1) : " "); } return 1; } static int stats_dump_one_line(const struct field *stats, struct proxy *px, struct appctx *appctx) { int ret; if (appctx->ctx.stats.flags & STAT_FMT_HTML) ret = stats_dump_fields_html(&trash, stats, appctx->ctx.stats.flags); else if (appctx->ctx.stats.flags & STAT_FMT_TYPED) ret = stats_dump_fields_typed(&trash, stats, appctx->ctx.stats.flags); else if (appctx->ctx.stats.flags & STAT_FMT_JSON) ret = stats_dump_fields_json(&trash, stats, appctx->ctx.stats.flags); else ret = stats_dump_fields_csv(&trash, stats, appctx->ctx.stats.flags); if (ret) appctx->ctx.stats.flags |= STAT_STARTED; return ret; } /* Fill with the frontend statistics. is * preallocated array of length . The length of the array * must be at least ST_F_TOTAL_FIELDS. If this length is less then * this value, the function returns 0, otherwise, it returns 1. */ int stats_fill_fe_stats(struct proxy *px, struct field *stats, int len) { if (len < ST_F_TOTAL_FIELDS) return 0; memset(stats, 0, sizeof(*stats) * len); stats[ST_F_PXNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, px->id); stats[ST_F_SVNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, "FRONTEND"); stats[ST_F_MODE] = mkf_str(FO_CONFIG|FS_SERVICE, proxy_mode_str(px->mode)); stats[ST_F_SCUR] = mkf_u32(0, px->feconn); stats[ST_F_SMAX] = mkf_u32(FN_MAX, px->fe_counters.conn_max); stats[ST_F_SLIM] = mkf_u32(FO_CONFIG|FN_LIMIT, px->maxconn); stats[ST_F_STOT] = mkf_u64(FN_COUNTER, px->fe_counters.cum_sess); stats[ST_F_BIN] = mkf_u64(FN_COUNTER, px->fe_counters.bytes_in); stats[ST_F_BOUT] = mkf_u64(FN_COUNTER, px->fe_counters.bytes_out); stats[ST_F_DREQ] = mkf_u64(FN_COUNTER, px->fe_counters.denied_req); stats[ST_F_DRESP] = mkf_u64(FN_COUNTER, px->fe_counters.denied_resp); stats[ST_F_EREQ] = mkf_u64(FN_COUNTER, px->fe_counters.failed_req); stats[ST_F_DCON] = mkf_u64(FN_COUNTER, px->fe_counters.denied_conn); stats[ST_F_DSES] = mkf_u64(FN_COUNTER, px->fe_counters.denied_sess); stats[ST_F_STATUS] = mkf_str(FO_STATUS, px->state == PR_STREADY ? "OPEN" : px->state == PR_STFULL ? "FULL" : "STOP"); stats[ST_F_PID] = mkf_u32(FO_KEY, relative_pid); stats[ST_F_IID] = mkf_u32(FO_KEY|FS_SERVICE, px->uuid); stats[ST_F_SID] = mkf_u32(FO_KEY|FS_SERVICE, 0); stats[ST_F_TYPE] = mkf_u32(FO_CONFIG|FS_SERVICE, STATS_TYPE_FE); stats[ST_F_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&px->fe_sess_per_sec)); stats[ST_F_RATE_LIM] = mkf_u32(FO_CONFIG|FN_LIMIT, px->fe_sps_lim); stats[ST_F_RATE_MAX] = mkf_u32(FN_MAX, px->fe_counters.sps_max); stats[ST_F_WREW] = mkf_u64(FN_COUNTER, px->fe_counters.failed_rewrites); /* http response: 1xx, 2xx, 3xx, 4xx, 5xx, other */ if (px->mode == PR_MODE_HTTP) { stats[ST_F_HRSP_1XX] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.rsp[1]); stats[ST_F_HRSP_2XX] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.rsp[2]); stats[ST_F_HRSP_3XX] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.rsp[3]); stats[ST_F_HRSP_4XX] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.rsp[4]); stats[ST_F_HRSP_5XX] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.rsp[5]); stats[ST_F_HRSP_OTHER] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.rsp[0]); stats[ST_F_INTERCEPTED] = mkf_u64(FN_COUNTER, px->fe_counters.intercepted_req); stats[ST_F_CACHE_LOOKUPS] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.cache_lookups); stats[ST_F_CACHE_HITS] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.cache_hits); } /* requests : req_rate, req_rate_max, req_tot, */ stats[ST_F_REQ_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&px->fe_req_per_sec)); stats[ST_F_REQ_RATE_MAX] = mkf_u32(FN_MAX, px->fe_counters.p.http.rps_max); stats[ST_F_REQ_TOT] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.cum_req); /* compression: in, out, bypassed, responses */ stats[ST_F_COMP_IN] = mkf_u64(FN_COUNTER, px->fe_counters.comp_in); stats[ST_F_COMP_OUT] = mkf_u64(FN_COUNTER, px->fe_counters.comp_out); stats[ST_F_COMP_BYP] = mkf_u64(FN_COUNTER, px->fe_counters.comp_byp); stats[ST_F_COMP_RSP] = mkf_u64(FN_COUNTER, px->fe_counters.p.http.comp_rsp); /* connections : conn_rate, conn_rate_max, conn_tot, conn_max */ stats[ST_F_CONN_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&px->fe_conn_per_sec)); stats[ST_F_CONN_RATE_MAX] = mkf_u32(FN_MAX, px->fe_counters.cps_max); stats[ST_F_CONN_TOT] = mkf_u64(FN_COUNTER, px->fe_counters.cum_conn); return 1; } /* Dumps a frontend's line to the trash for the current proxy and uses * the state from stream interface . The caller is responsible for clearing * the trash if needed. Returns non-zero if it emits anything, zero otherwise. */ static int stats_dump_fe_stats(struct stream_interface *si, struct proxy *px) { struct appctx *appctx = __objt_appctx(si->end); if (!(px->cap & PR_CAP_FE)) return 0; if ((appctx->ctx.stats.flags & STAT_BOUND) && !(appctx->ctx.stats.type & (1 << STATS_TYPE_FE))) return 0; if (!stats_fill_fe_stats(px, stats, ST_F_TOTAL_FIELDS)) return 0; return stats_dump_one_line(stats, px, appctx); } /* Fill with the listener statistics. is * preallocated array of length . The length of the array * must be at least ST_F_TOTAL_FIELDS. If this length is less * then this value, the function returns 0, otherwise, it * returns 1. can take the value STAT_SHLGNDS. */ int stats_fill_li_stats(struct proxy *px, struct listener *l, int flags, struct field *stats, int len) { struct buffer *out = get_trash_chunk(); if (len < ST_F_TOTAL_FIELDS) return 0; if (!l->counters) return 0; chunk_reset(out); memset(stats, 0, sizeof(*stats) * len); stats[ST_F_PXNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, px->id); stats[ST_F_SVNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, l->name); stats[ST_F_MODE] = mkf_str(FO_CONFIG|FS_SERVICE, proxy_mode_str(px->mode)); stats[ST_F_SCUR] = mkf_u32(0, l->nbconn); stats[ST_F_SMAX] = mkf_u32(FN_MAX, l->counters->conn_max); stats[ST_F_SLIM] = mkf_u32(FO_CONFIG|FN_LIMIT, l->maxconn); stats[ST_F_STOT] = mkf_u64(FN_COUNTER, l->counters->cum_conn); stats[ST_F_BIN] = mkf_u64(FN_COUNTER, l->counters->bytes_in); stats[ST_F_BOUT] = mkf_u64(FN_COUNTER, l->counters->bytes_out); stats[ST_F_DREQ] = mkf_u64(FN_COUNTER, l->counters->denied_req); stats[ST_F_DRESP] = mkf_u64(FN_COUNTER, l->counters->denied_resp); stats[ST_F_EREQ] = mkf_u64(FN_COUNTER, l->counters->failed_req); stats[ST_F_DCON] = mkf_u64(FN_COUNTER, l->counters->denied_conn); stats[ST_F_DSES] = mkf_u64(FN_COUNTER, l->counters->denied_sess); stats[ST_F_STATUS] = mkf_str(FO_STATUS, (!l->maxconn || l->nbconn < l->maxconn) ? (l->state == LI_LIMITED) ? "WAITING" : "OPEN" : "FULL"); stats[ST_F_PID] = mkf_u32(FO_KEY, relative_pid); stats[ST_F_IID] = mkf_u32(FO_KEY|FS_SERVICE, px->uuid); stats[ST_F_SID] = mkf_u32(FO_KEY|FS_SERVICE, l->luid); stats[ST_F_TYPE] = mkf_u32(FO_CONFIG|FS_SERVICE, STATS_TYPE_SO); stats[ST_F_WREW] = mkf_u64(FN_COUNTER, l->counters->failed_rewrites); if (flags & STAT_SHLGNDS) { char str[INET6_ADDRSTRLEN]; int port; port = get_host_port(&l->addr); switch (addr_to_str(&l->addr, str, sizeof(str))) { case AF_INET: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, chunk_newstr(out)); chunk_appendf(out, "%s:%d", str, port); break; case AF_INET6: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, chunk_newstr(out)); chunk_appendf(out, "[%s]:%d", str, port); break; case AF_UNIX: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, "unix"); break; case -1: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, chunk_newstr(out)); chunk_strcat(out, strerror(errno)); break; default: /* address family not supported */ break; } } return 1; } /* Dumps a line for listener and proxy to the trash and uses the state * from stream interface . The caller is responsible for clearing the trash * if needed. Returns non-zero if it emits anything, zero otherwise. */ static int stats_dump_li_stats(struct stream_interface *si, struct proxy *px, struct listener *l) { struct appctx *appctx = __objt_appctx(si->end); if (!stats_fill_li_stats(px, l, appctx->ctx.stats.flags, stats, ST_F_TOTAL_FIELDS)) return 0; return stats_dump_one_line(stats, px, appctx); } enum srv_stats_state { SRV_STATS_STATE_DOWN = 0, SRV_STATS_STATE_DOWN_AGENT, SRV_STATS_STATE_GOING_UP, SRV_STATS_STATE_UP_GOING_DOWN, SRV_STATS_STATE_UP, SRV_STATS_STATE_NOLB_GOING_DOWN, SRV_STATS_STATE_NOLB, SRV_STATS_STATE_DRAIN_GOING_DOWN, SRV_STATS_STATE_DRAIN, SRV_STATS_STATE_DRAIN_AGENT, SRV_STATS_STATE_NO_CHECK, SRV_STATS_STATE_COUNT, /* Must be last */ }; static const char *srv_hlt_st[SRV_STATS_STATE_COUNT] = { [SRV_STATS_STATE_DOWN] = "DOWN", [SRV_STATS_STATE_DOWN_AGENT] = "DOWN (agent)", [SRV_STATS_STATE_GOING_UP] = "DOWN %d/%d", [SRV_STATS_STATE_UP_GOING_DOWN] = "UP %d/%d", [SRV_STATS_STATE_UP] = "UP", [SRV_STATS_STATE_NOLB_GOING_DOWN] = "NOLB %d/%d", [SRV_STATS_STATE_NOLB] = "NOLB", [SRV_STATS_STATE_DRAIN_GOING_DOWN] = "DRAIN %d/%d", [SRV_STATS_STATE_DRAIN] = "DRAIN", [SRV_STATS_STATE_DRAIN_AGENT] = "DRAIN (agent)", [SRV_STATS_STATE_NO_CHECK] = "no check" }; /* Fill with the server statistics. is * preallocated array of length . The length of the array * must be at least ST_F_TOTAL_FIELDS. If this length is less * then this value, the function returns 0, otherwise, it * returns 1. can take the value STAT_SHLGNDS. */ int stats_fill_sv_stats(struct proxy *px, struct server *sv, int flags, struct field *stats, int len) { struct server *via, *ref; char str[INET6_ADDRSTRLEN]; struct buffer *out = get_trash_chunk(); enum srv_stats_state state; char *fld_status; if (len < ST_F_TOTAL_FIELDS) return 0; memset(stats, 0, sizeof(*stats) * len); /* we have "via" which is the tracked server as described in the configuration, * and "ref" which is the checked server and the end of the chain. */ via = sv->track ? sv->track : sv; ref = via; while (ref->track) ref = ref->track; if (sv->cur_state == SRV_ST_RUNNING || sv->cur_state == SRV_ST_STARTING) { if ((ref->check.state & CHK_ST_ENABLED) && (ref->check.health < ref->check.rise + ref->check.fall - 1)) { state = SRV_STATS_STATE_UP_GOING_DOWN; } else { state = SRV_STATS_STATE_UP; } if (sv->cur_admin & SRV_ADMF_DRAIN) { if (ref->agent.state & CHK_ST_ENABLED) state = SRV_STATS_STATE_DRAIN_AGENT; else if (state == SRV_STATS_STATE_UP_GOING_DOWN) state = SRV_STATS_STATE_DRAIN_GOING_DOWN; else state = SRV_STATS_STATE_DRAIN; } if (state == SRV_STATS_STATE_UP && !(ref->check.state & CHK_ST_ENABLED)) { state = SRV_STATS_STATE_NO_CHECK; } } else if (sv->cur_state == SRV_ST_STOPPING) { if ((!(sv->check.state & CHK_ST_ENABLED) && !sv->track) || (ref->check.health == ref->check.rise + ref->check.fall - 1)) { state = SRV_STATS_STATE_NOLB; } else { state = SRV_STATS_STATE_NOLB_GOING_DOWN; } } else { /* stopped */ if ((ref->agent.state & CHK_ST_ENABLED) && !ref->agent.health) { state = SRV_STATS_STATE_DOWN_AGENT; } else if ((ref->check.state & CHK_ST_ENABLED) && !ref->check.health) { state = SRV_STATS_STATE_DOWN; /* DOWN */ } else if ((ref->agent.state & CHK_ST_ENABLED) || (ref->check.state & CHK_ST_ENABLED)) { state = SRV_STATS_STATE_GOING_UP; } else { state = SRV_STATS_STATE_DOWN; /* DOWN, unchecked */ } } chunk_reset(out); stats[ST_F_PXNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, px->id); stats[ST_F_SVNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, sv->id); stats[ST_F_MODE] = mkf_str(FO_CONFIG|FS_SERVICE, proxy_mode_str(px->mode)); stats[ST_F_QCUR] = mkf_u32(0, sv->nbpend); stats[ST_F_QMAX] = mkf_u32(FN_MAX, sv->counters.nbpend_max); stats[ST_F_SCUR] = mkf_u32(0, sv->cur_sess); stats[ST_F_SMAX] = mkf_u32(FN_MAX, sv->counters.cur_sess_max); if (sv->maxconn) stats[ST_F_SLIM] = mkf_u32(FO_CONFIG|FN_LIMIT, sv->maxconn); stats[ST_F_SRV_ICUR] = mkf_u32(0, sv->curr_idle_conns); if (sv->max_idle_conns != -1) stats[ST_F_SRV_ILIM] = mkf_u32(FO_CONFIG|FN_LIMIT, sv->max_idle_conns); stats[ST_F_STOT] = mkf_u64(FN_COUNTER, sv->counters.cum_sess); stats[ST_F_BIN] = mkf_u64(FN_COUNTER, sv->counters.bytes_in); stats[ST_F_BOUT] = mkf_u64(FN_COUNTER, sv->counters.bytes_out); stats[ST_F_DRESP] = mkf_u64(FN_COUNTER, sv->counters.failed_secu); stats[ST_F_ECON] = mkf_u64(FN_COUNTER, sv->counters.failed_conns); stats[ST_F_ERESP] = mkf_u64(FN_COUNTER, sv->counters.failed_resp); stats[ST_F_WRETR] = mkf_u64(FN_COUNTER, sv->counters.retries); stats[ST_F_WREDIS] = mkf_u64(FN_COUNTER, sv->counters.redispatches); stats[ST_F_WREW] = mkf_u64(FN_COUNTER, sv->counters.failed_rewrites); stats[ST_F_CONNECT] = mkf_u64(FN_COUNTER, sv->counters.connect); stats[ST_F_REUSE] = mkf_u64(FN_COUNTER, sv->counters.reuse); /* status */ fld_status = chunk_newstr(out); if (sv->cur_admin & SRV_ADMF_RMAINT) chunk_appendf(out, "MAINT (resolution)"); else if (sv->cur_admin & SRV_ADMF_IMAINT) chunk_appendf(out, "MAINT (via %s/%s)", via->proxy->id, via->id); else if (sv->cur_admin & SRV_ADMF_MAINT) chunk_appendf(out, "MAINT"); else chunk_appendf(out, srv_hlt_st[state], (ref->cur_state != SRV_ST_STOPPED) ? (ref->check.health - ref->check.rise + 1) : (ref->check.health), (ref->cur_state != SRV_ST_STOPPED) ? (ref->check.fall) : (ref->check.rise)); stats[ST_F_STATUS] = mkf_str(FO_STATUS, fld_status); stats[ST_F_LASTCHG] = mkf_u32(FN_AGE, now.tv_sec - sv->last_change); stats[ST_F_WEIGHT] = mkf_u32(FN_AVG, (sv->cur_eweight * px->lbprm.wmult + px->lbprm.wdiv - 1) / px->lbprm.wdiv); stats[ST_F_ACT] = mkf_u32(FO_STATUS, (sv->flags & SRV_F_BACKUP) ? 0 : 1); stats[ST_F_BCK] = mkf_u32(FO_STATUS, (sv->flags & SRV_F_BACKUP) ? 1 : 0); /* check failures: unique, fatal; last change, total downtime */ if (sv->check.state & CHK_ST_ENABLED) { stats[ST_F_CHKFAIL] = mkf_u64(FN_COUNTER, sv->counters.failed_checks); stats[ST_F_CHKDOWN] = mkf_u64(FN_COUNTER, sv->counters.down_trans); stats[ST_F_DOWNTIME] = mkf_u32(FN_COUNTER, srv_downtime(sv)); } if (sv->maxqueue) stats[ST_F_QLIMIT] = mkf_u32(FO_CONFIG|FS_SERVICE, sv->maxqueue); stats[ST_F_PID] = mkf_u32(FO_KEY, relative_pid); stats[ST_F_IID] = mkf_u32(FO_KEY|FS_SERVICE, px->uuid); stats[ST_F_SID] = mkf_u32(FO_KEY|FS_SERVICE, sv->puid); if (sv->cur_state == SRV_ST_STARTING && !server_is_draining(sv)) stats[ST_F_THROTTLE] = mkf_u32(FN_AVG, server_throttle_rate(sv)); stats[ST_F_LBTOT] = mkf_u64(FN_COUNTER, sv->counters.cum_lbconn); if (sv->track) { char *fld_track = chunk_newstr(out); chunk_appendf(out, "%s/%s", sv->track->proxy->id, sv->track->id); stats[ST_F_TRACKED] = mkf_str(FO_CONFIG|FN_NAME|FS_SERVICE, fld_track); } stats[ST_F_TYPE] = mkf_u32(FO_CONFIG|FS_SERVICE, STATS_TYPE_SV); stats[ST_F_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&sv->sess_per_sec)); stats[ST_F_RATE_MAX] = mkf_u32(FN_MAX, sv->counters.sps_max); if ((sv->check.state & (CHK_ST_ENABLED|CHK_ST_PAUSED)) == CHK_ST_ENABLED) { const char *fld_chksts; fld_chksts = chunk_newstr(out); chunk_strcat(out, "* "); // for check in progress chunk_strcat(out, get_check_status_info(sv->check.status)); if (!(sv->check.state & CHK_ST_INPROGRESS)) fld_chksts += 2; // skip "* " stats[ST_F_CHECK_STATUS] = mkf_str(FN_OUTPUT, fld_chksts); if (sv->check.status >= HCHK_STATUS_L57DATA) stats[ST_F_CHECK_CODE] = mkf_u32(FN_OUTPUT, sv->check.code); if (sv->check.status >= HCHK_STATUS_CHECKED) stats[ST_F_CHECK_DURATION] = mkf_u64(FN_DURATION, sv->check.duration); stats[ST_F_CHECK_DESC] = mkf_str(FN_OUTPUT, get_check_status_description(sv->check.status)); stats[ST_F_LAST_CHK] = mkf_str(FN_OUTPUT, sv->check.desc); stats[ST_F_CHECK_RISE] = mkf_u32(FO_CONFIG|FS_SERVICE, ref->check.rise); stats[ST_F_CHECK_FALL] = mkf_u32(FO_CONFIG|FS_SERVICE, ref->check.fall); stats[ST_F_CHECK_HEALTH] = mkf_u32(FO_CONFIG|FS_SERVICE, ref->check.health); } if ((sv->agent.state & (CHK_ST_ENABLED|CHK_ST_PAUSED)) == CHK_ST_ENABLED) { const char *fld_chksts; fld_chksts = chunk_newstr(out); chunk_strcat(out, "* "); // for check in progress chunk_strcat(out, get_check_status_info(sv->agent.status)); if (!(sv->agent.state & CHK_ST_INPROGRESS)) fld_chksts += 2; // skip "* " stats[ST_F_AGENT_STATUS] = mkf_str(FN_OUTPUT, fld_chksts); if (sv->agent.status >= HCHK_STATUS_L57DATA) stats[ST_F_AGENT_CODE] = mkf_u32(FN_OUTPUT, sv->agent.code); if (sv->agent.status >= HCHK_STATUS_CHECKED) stats[ST_F_AGENT_DURATION] = mkf_u64(FN_DURATION, sv->agent.duration); stats[ST_F_AGENT_DESC] = mkf_str(FN_OUTPUT, get_check_status_description(sv->agent.status)); stats[ST_F_LAST_AGT] = mkf_str(FN_OUTPUT, sv->agent.desc); stats[ST_F_AGENT_RISE] = mkf_u32(FO_CONFIG|FS_SERVICE, sv->agent.rise); stats[ST_F_AGENT_FALL] = mkf_u32(FO_CONFIG|FS_SERVICE, sv->agent.fall); stats[ST_F_AGENT_HEALTH] = mkf_u32(FO_CONFIG|FS_SERVICE, sv->agent.health); } /* http response: 1xx, 2xx, 3xx, 4xx, 5xx, other */ if (px->mode == PR_MODE_HTTP) { stats[ST_F_HRSP_1XX] = mkf_u64(FN_COUNTER, sv->counters.p.http.rsp[1]); stats[ST_F_HRSP_2XX] = mkf_u64(FN_COUNTER, sv->counters.p.http.rsp[2]); stats[ST_F_HRSP_3XX] = mkf_u64(FN_COUNTER, sv->counters.p.http.rsp[3]); stats[ST_F_HRSP_4XX] = mkf_u64(FN_COUNTER, sv->counters.p.http.rsp[4]); stats[ST_F_HRSP_5XX] = mkf_u64(FN_COUNTER, sv->counters.p.http.rsp[5]); stats[ST_F_HRSP_OTHER] = mkf_u64(FN_COUNTER, sv->counters.p.http.rsp[0]); } if (ref->observe) stats[ST_F_HANAFAIL] = mkf_u64(FN_COUNTER, sv->counters.failed_hana); stats[ST_F_CLI_ABRT] = mkf_u64(FN_COUNTER, sv->counters.cli_aborts); stats[ST_F_SRV_ABRT] = mkf_u64(FN_COUNTER, sv->counters.srv_aborts); stats[ST_F_LASTSESS] = mkf_s32(FN_AGE, srv_lastsession(sv)); stats[ST_F_QTIME] = mkf_u32(FN_AVG, swrate_avg(sv->counters.q_time, TIME_STATS_SAMPLES)); stats[ST_F_CTIME] = mkf_u32(FN_AVG, swrate_avg(sv->counters.c_time, TIME_STATS_SAMPLES)); stats[ST_F_RTIME] = mkf_u32(FN_AVG, swrate_avg(sv->counters.d_time, TIME_STATS_SAMPLES)); stats[ST_F_TTIME] = mkf_u32(FN_AVG, swrate_avg(sv->counters.t_time, TIME_STATS_SAMPLES)); if (flags & STAT_SHLGNDS) { switch (addr_to_str(&sv->addr, str, sizeof(str))) { case AF_INET: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, chunk_newstr(out)); chunk_appendf(out, "%s:%d", str, sv->svc_port); break; case AF_INET6: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, chunk_newstr(out)); chunk_appendf(out, "[%s]:%d", str, sv->svc_port); break; case AF_UNIX: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, "unix"); break; case -1: stats[ST_F_ADDR] = mkf_str(FO_CONFIG|FS_SERVICE, chunk_newstr(out)); chunk_strcat(out, strerror(errno)); break; default: /* address family not supported */ break; } if (sv->cookie) stats[ST_F_COOKIE] = mkf_str(FO_CONFIG|FN_NAME|FS_SERVICE, sv->cookie); } return 1; } /* Dumps a line for server and proxy to the trash and uses the state * from stream interface , and server state . The caller is * responsible for clearing the trash if needed. Returns non-zero if it emits * anything, zero otherwise. */ static int stats_dump_sv_stats(struct stream_interface *si, struct proxy *px, struct server *sv) { struct appctx *appctx = __objt_appctx(si->end); if (!stats_fill_sv_stats(px, sv, appctx->ctx.stats.flags, stats, ST_F_TOTAL_FIELDS)) return 0; return stats_dump_one_line(stats, px, appctx); } /* Fill with the backend statistics. is * preallocated array of length . The length of the array * must be at least ST_F_TOTAL_FIELDS. If this length is less * then this value, the function returns 0, otherwise, it * returns 1. can take the value STAT_SHLGNDS. */ int stats_fill_be_stats(struct proxy *px, int flags, struct field *stats, int len) { if (len < ST_F_TOTAL_FIELDS) return 0; memset(stats, 0, sizeof(*stats) * len); stats[ST_F_PXNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, px->id); stats[ST_F_SVNAME] = mkf_str(FO_KEY|FN_NAME|FS_SERVICE, "BACKEND"); stats[ST_F_MODE] = mkf_str(FO_CONFIG|FS_SERVICE, proxy_mode_str(px->mode)); stats[ST_F_QCUR] = mkf_u32(0, px->nbpend); stats[ST_F_QMAX] = mkf_u32(FN_MAX, px->be_counters.nbpend_max); stats[ST_F_SCUR] = mkf_u32(0, px->beconn); stats[ST_F_SMAX] = mkf_u32(FN_MAX, px->be_counters.conn_max); stats[ST_F_SLIM] = mkf_u32(FO_CONFIG|FN_LIMIT, px->fullconn); stats[ST_F_STOT] = mkf_u64(FN_COUNTER, px->be_counters.cum_conn); stats[ST_F_BIN] = mkf_u64(FN_COUNTER, px->be_counters.bytes_in); stats[ST_F_BOUT] = mkf_u64(FN_COUNTER, px->be_counters.bytes_out); stats[ST_F_DREQ] = mkf_u64(FN_COUNTER, px->be_counters.denied_req); stats[ST_F_DRESP] = mkf_u64(FN_COUNTER, px->be_counters.denied_resp); stats[ST_F_ECON] = mkf_u64(FN_COUNTER, px->be_counters.failed_conns); stats[ST_F_ERESP] = mkf_u64(FN_COUNTER, px->be_counters.failed_resp); stats[ST_F_WRETR] = mkf_u64(FN_COUNTER, px->be_counters.retries); stats[ST_F_WREDIS] = mkf_u64(FN_COUNTER, px->be_counters.redispatches); stats[ST_F_WREW] = mkf_u64(FN_COUNTER, px->be_counters.failed_rewrites); stats[ST_F_CONNECT] = mkf_u64(FN_COUNTER, px->be_counters.connect); stats[ST_F_REUSE] = mkf_u64(FN_COUNTER, px->be_counters.reuse); stats[ST_F_STATUS] = mkf_str(FO_STATUS, (px->lbprm.tot_weight > 0 || !px->srv) ? "UP" : "DOWN"); stats[ST_F_WEIGHT] = mkf_u32(FN_AVG, (px->lbprm.tot_weight * px->lbprm.wmult + px->lbprm.wdiv - 1) / px->lbprm.wdiv); stats[ST_F_ACT] = mkf_u32(0, px->srv_act); stats[ST_F_BCK] = mkf_u32(0, px->srv_bck); stats[ST_F_CHKDOWN] = mkf_u64(FN_COUNTER, px->down_trans); stats[ST_F_LASTCHG] = mkf_u32(FN_AGE, now.tv_sec - px->last_change); if (px->srv) stats[ST_F_DOWNTIME] = mkf_u32(FN_COUNTER, be_downtime(px)); stats[ST_F_PID] = mkf_u32(FO_KEY, relative_pid); stats[ST_F_IID] = mkf_u32(FO_KEY|FS_SERVICE, px->uuid); stats[ST_F_SID] = mkf_u32(FO_KEY|FS_SERVICE, 0); stats[ST_F_LBTOT] = mkf_u64(FN_COUNTER, px->be_counters.cum_lbconn); stats[ST_F_TYPE] = mkf_u32(FO_CONFIG|FS_SERVICE, STATS_TYPE_BE); stats[ST_F_RATE] = mkf_u32(0, read_freq_ctr(&px->be_sess_per_sec)); stats[ST_F_RATE_MAX] = mkf_u32(0, px->be_counters.sps_max); if (flags & STAT_SHLGNDS) { if (px->cookie_name) stats[ST_F_COOKIE] = mkf_str(FO_CONFIG|FN_NAME|FS_SERVICE, px->cookie_name); stats[ST_F_ALGO] = mkf_str(FO_CONFIG|FS_SERVICE, backend_lb_algo_str(px->lbprm.algo & BE_LB_ALGO)); } /* http response: 1xx, 2xx, 3xx, 4xx, 5xx, other */ if (px->mode == PR_MODE_HTTP) { stats[ST_F_REQ_TOT] = mkf_u64(FN_COUNTER, px->be_counters.p.http.cum_req); stats[ST_F_HRSP_1XX] = mkf_u64(FN_COUNTER, px->be_counters.p.http.rsp[1]); stats[ST_F_HRSP_2XX] = mkf_u64(FN_COUNTER, px->be_counters.p.http.rsp[2]); stats[ST_F_HRSP_3XX] = mkf_u64(FN_COUNTER, px->be_counters.p.http.rsp[3]); stats[ST_F_HRSP_4XX] = mkf_u64(FN_COUNTER, px->be_counters.p.http.rsp[4]); stats[ST_F_HRSP_5XX] = mkf_u64(FN_COUNTER, px->be_counters.p.http.rsp[5]); stats[ST_F_HRSP_OTHER] = mkf_u64(FN_COUNTER, px->be_counters.p.http.rsp[0]); stats[ST_F_CACHE_LOOKUPS] = mkf_u64(FN_COUNTER, px->be_counters.p.http.cache_lookups); stats[ST_F_CACHE_HITS] = mkf_u64(FN_COUNTER, px->be_counters.p.http.cache_hits); } stats[ST_F_CLI_ABRT] = mkf_u64(FN_COUNTER, px->be_counters.cli_aborts); stats[ST_F_SRV_ABRT] = mkf_u64(FN_COUNTER, px->be_counters.srv_aborts); /* compression: in, out, bypassed, responses */ stats[ST_F_COMP_IN] = mkf_u64(FN_COUNTER, px->be_counters.comp_in); stats[ST_F_COMP_OUT] = mkf_u64(FN_COUNTER, px->be_counters.comp_out); stats[ST_F_COMP_BYP] = mkf_u64(FN_COUNTER, px->be_counters.comp_byp); stats[ST_F_COMP_RSP] = mkf_u64(FN_COUNTER, px->be_counters.p.http.comp_rsp); stats[ST_F_LASTSESS] = mkf_s32(FN_AGE, be_lastsession(px)); stats[ST_F_QTIME] = mkf_u32(FN_AVG, swrate_avg(px->be_counters.q_time, TIME_STATS_SAMPLES)); stats[ST_F_CTIME] = mkf_u32(FN_AVG, swrate_avg(px->be_counters.c_time, TIME_STATS_SAMPLES)); stats[ST_F_RTIME] = mkf_u32(FN_AVG, swrate_avg(px->be_counters.d_time, TIME_STATS_SAMPLES)); stats[ST_F_TTIME] = mkf_u32(FN_AVG, swrate_avg(px->be_counters.t_time, TIME_STATS_SAMPLES)); return 1; } /* Dumps a line for backend to the trash for and uses the state from stream * interface . The caller is responsible for clearing the trash if needed. * Returns non-zero if it emits anything, zero otherwise. */ static int stats_dump_be_stats(struct stream_interface *si, struct proxy *px) { struct appctx *appctx = __objt_appctx(si->end); if (!(px->cap & PR_CAP_BE)) return 0; if ((appctx->ctx.stats.flags & STAT_BOUND) && !(appctx->ctx.stats.type & (1 << STATS_TYPE_BE))) return 0; if (!stats_fill_be_stats(px, appctx->ctx.stats.flags, stats, ST_F_TOTAL_FIELDS)) return 0; return stats_dump_one_line(stats, px, appctx); } /* Dumps the HTML table header for proxy to the trash for and uses the state from * stream interface and per-uri parameters . The caller is responsible * for clearing the trash if needed. */ static void stats_dump_html_px_hdr(struct stream_interface *si, struct proxy *px) { struct appctx *appctx = __objt_appctx(si->end); char scope_txt[STAT_SCOPE_TXT_MAXLEN + sizeof STAT_SCOPE_PATTERN]; if (px->cap & PR_CAP_BE && px->srv && (appctx->ctx.stats.flags & STAT_ADMIN)) { /* A form to enable/disable this proxy servers */ /* scope_txt = search pattern + search query, appctx->ctx.stats.scope_len is always <= STAT_SCOPE_TXT_MAXLEN */ scope_txt[0] = 0; if (appctx->ctx.stats.scope_len) { const char *scope_ptr = stats_scope_ptr(appctx, si); strcpy(scope_txt, STAT_SCOPE_PATTERN); memcpy(scope_txt + strlen(STAT_SCOPE_PATTERN), scope_ptr, appctx->ctx.stats.scope_len); scope_txt[strlen(STAT_SCOPE_PATTERN) + appctx->ctx.stats.scope_len] = 0; } chunk_appendf(&trash, "
"); } /* print a new table */ chunk_appendf(&trash, "\n" "" "" "" "\n" "
"); chunk_appendf(&trash, "%s" "%s", px->id, (appctx->ctx.stats.flags & STAT_SHLGNDS) ? "":"", px->id, px->id); if (appctx->ctx.stats.flags & STAT_SHLGNDS) { /* cap, mode, id */ chunk_appendf(&trash, "
cap: %s, mode: %s, id: %d", proxy_cap_str(px->cap), proxy_mode_str(px->mode), px->uuid); chunk_appendf(&trash, "
"); } chunk_appendf(&trash, "%s		%s
\n" "\n" "", (appctx->ctx.stats.flags & STAT_SHLGNDS) ? "":"", px->desc ? "desc" : "empty", px->desc ? px->desc : ""); if ((px->cap & PR_CAP_BE) && px->srv && (appctx->ctx.stats.flags & STAT_ADMIN)) { /* Column heading for Enable or Disable server */ chunk_appendf(&trash, "", px->id, px->id); } chunk_appendf(&trash, "" "" "" "" "" "" "\n" "" "" "" "" "" "" "" "" "\n" ""); } /* Dumps the HTML table trailer for proxy to the trash for and uses the state from * stream interface . The caller is responsible for clearing the trash if needed. */ static void stats_dump_html_px_end(struct stream_interface *si, struct proxy *px) { struct appctx *appctx = __objt_appctx(si->end); chunk_appendf(&trash, "
QueueSession rateSessionsBytesDeniedErrorsWarningsServer
CurMaxLimitCurMaxLimitCurMaxLimitTotalLbTotLastInOutReqRespReqConnRespRetrRedisStatusLastChkWghtActBckChkDwnDwntmeThrtle
"); if ((px->cap & PR_CAP_BE) && px->srv && (appctx->ctx.stats.flags & STAT_ADMIN)) { /* close the form used to enable/disable this proxy servers */ chunk_appendf(&trash, "Choose the action to perform on the checked servers : " "" "" " " "
", px->uuid); } chunk_appendf(&trash, "

\n"); } /* * Dumps statistics for a proxy. The output is sent to the stream interface's * input buffer. Returns 0 if it had to stop dumping data because of lack of * buffer space, or non-zero if everything completed. This function is used * both by the CLI and the HTTP entry points, and is able to dump the output * in HTML or CSV formats. If the later, must be NULL. */ int stats_dump_proxy_to_buffer(struct stream_interface *si, struct htx *htx, struct proxy *px, struct uri_auth *uri) { struct appctx *appctx = __objt_appctx(si->end); struct stream *s = si_strm(si); struct channel *rep = si_ic(si); struct server *sv, *svs; /* server and server-state, server-state=server or server->track */ struct listener *l; chunk_reset(&trash); switch (appctx->ctx.stats.px_st) { case STAT_PX_ST_INIT: /* we are on a new proxy */ if (uri && uri->scope) { /* we have a limited scope, we have to check the proxy name */ struct stat_scope *scope; int len; len = strlen(px->id); scope = uri->scope; while (scope) { /* match exact proxy name */ if (scope->px_len == len && !memcmp(px->id, scope->px_id, len)) break; /* match '.' which means 'self' proxy */ if (!strcmp(scope->px_id, ".") && px == s->be) break; scope = scope->next; } /* proxy name not found : don't dump anything */ if (scope == NULL) return 1; } /* if the user has requested a limited output and the proxy * name does not match, skip it. */ if (appctx->ctx.stats.scope_len) { const char *scope_ptr = stats_scope_ptr(appctx, si); if (strnistr(px->id, strlen(px->id), scope_ptr, appctx->ctx.stats.scope_len) == NULL) return 1; } if ((appctx->ctx.stats.flags & STAT_BOUND) && (appctx->ctx.stats.iid != -1) && (px->uuid != appctx->ctx.stats.iid)) return 1; appctx->ctx.stats.px_st = STAT_PX_ST_TH; /* fall through */ case STAT_PX_ST_TH: if (appctx->ctx.stats.flags & STAT_FMT_HTML) { stats_dump_html_px_hdr(si, px); if (!stats_putchk(rep, htx, &trash)) goto full; } appctx->ctx.stats.px_st = STAT_PX_ST_FE; /* fall through */ case STAT_PX_ST_FE: /* print the frontend */ if (stats_dump_fe_stats(si, px)) { if (!stats_putchk(rep, htx, &trash)) goto full; } appctx->ctx.stats.l = px->conf.listeners.n; appctx->ctx.stats.px_st = STAT_PX_ST_LI; /* fall through */ case STAT_PX_ST_LI: /* stats.l has been initialized above */ for (; appctx->ctx.stats.l != &px->conf.listeners; appctx->ctx.stats.l = l->by_fe.n) { if (htx) { if (htx_almost_full(htx)) goto full; } else { if (buffer_almost_full(&rep->buf)) goto full; } l = LIST_ELEM(appctx->ctx.stats.l, struct listener *, by_fe); if (!l->counters) continue; if (appctx->ctx.stats.flags & STAT_BOUND) { if (!(appctx->ctx.stats.type & (1 << STATS_TYPE_SO))) break; if (appctx->ctx.stats.sid != -1 && l->luid != appctx->ctx.stats.sid) continue; } /* print the frontend */ if (stats_dump_li_stats(si, px, l)) { if (!stats_putchk(rep, htx, &trash)) goto full; } } appctx->ctx.stats.sv = px->srv; /* may be NULL */ appctx->ctx.stats.px_st = STAT_PX_ST_SV; /* fall through */ case STAT_PX_ST_SV: /* stats.sv has been initialized above */ for (; appctx->ctx.stats.sv != NULL; appctx->ctx.stats.sv = sv->next) { if (htx) { if (htx_almost_full(htx)) goto full; } else { if (buffer_almost_full(&rep->buf)) goto full; } sv = appctx->ctx.stats.sv; if (appctx->ctx.stats.flags & STAT_BOUND) { if (!(appctx->ctx.stats.type & (1 << STATS_TYPE_SV))) break; if (appctx->ctx.stats.sid != -1 && sv->puid != appctx->ctx.stats.sid) continue; } svs = sv; while (svs->track) svs = svs->track; /* do not report servers which are DOWN and not changing state */ if ((appctx->ctx.stats.flags & STAT_HIDE_DOWN) && ((sv->cur_admin & SRV_ADMF_MAINT) || /* server is in maintenance */ (sv->cur_state == SRV_ST_STOPPED && /* server is down */ (!((svs->agent.state | svs->check.state) & CHK_ST_ENABLED) || ((svs->agent.state & CHK_ST_ENABLED) && !svs->agent.health) || ((svs->check.state & CHK_ST_ENABLED) && !svs->check.health))))) { continue; } if (stats_dump_sv_stats(si, px, sv)) { if (!stats_putchk(rep, htx, &trash)) goto full; } } /* for sv */ appctx->ctx.stats.px_st = STAT_PX_ST_BE; /* fall through */ case STAT_PX_ST_BE: /* print the backend */ if (stats_dump_be_stats(si, px)) { if (!stats_putchk(rep, htx, &trash)) goto full; } appctx->ctx.stats.px_st = STAT_PX_ST_END; /* fall through */ case STAT_PX_ST_END: if (appctx->ctx.stats.flags & STAT_FMT_HTML) { stats_dump_html_px_end(si, px); if (!stats_putchk(rep, htx, &trash)) goto full; } appctx->ctx.stats.px_st = STAT_PX_ST_FIN; /* fall through */ case STAT_PX_ST_FIN: return 1; default: /* unknown state, we should put an abort() here ! */ return 1; } full: si_rx_room_blk(si); return 0; } /* Dumps the HTTP stats head block to the trash for and uses the per-uri * parameters . The caller is responsible for clearing the trash if needed. */ static void stats_dump_html_head(struct appctx *appctx, struct uri_auth *uri) { /* WARNING! This must fit in the first buffer !!! */ chunk_appendf(&trash, "\n" "Statistics Report for " PRODUCT_NAME "%s%s\n" "\n" "\n", (appctx->ctx.stats.flags & STAT_SHNODE) ? " on " : "", (appctx->ctx.stats.flags & STAT_SHNODE) ? (uri->node ? uri->node : global.node) : "" ); } /* Dumps the HTML stats information block to the trash for and uses the state from * stream interface and per-uri parameters . The caller is responsible * for clearing the trash if needed. */ static void stats_dump_html_info(struct stream_interface *si, struct uri_auth *uri) { struct appctx *appctx = __objt_appctx(si->end); unsigned int up = (now.tv_sec - start_date.tv_sec); char scope_txt[STAT_SCOPE_TXT_MAXLEN + sizeof STAT_SCOPE_PATTERN]; const char *scope_ptr = stats_scope_ptr(appctx, si); unsigned long long bps = (unsigned long long)read_freq_ctr(&global.out_32bps) * 32; /* Turn the bytes per second to bits per second and take care of the * usual ethernet overhead in order to help figure how far we are from * interface saturation since it's the only case which usually matters. * For this we count the total size of an Ethernet frame on the wire * including preamble and IFG (1538) for the largest TCP segment it * transports (1448 with TCP timestamps). This is not valid for smaller * packets (under-estimated), but it gives a reasonably accurate * estimation of how far we are from uplink saturation. */ bps = bps * 8 * 1538 / 1448; /* WARNING! this has to fit the first packet too. * We are around 3.5 kB, add adding entries will * become tricky if we want to support 4kB buffers ! */ chunk_appendf(&trash, "

" PRODUCT_NAME "%s

\n" "

Statistics Report for pid %d%s%s%s%s

\n" "
\n" "

> General process information

\n" "" "" "" "
\n" "

pid = %d (process #%d, nbproc = %d, nbthread = %d)
\n" "uptime = %dd %dh%02dm%02ds
\n" "system limits: memmax = %s%s; ulimit-n = %d
\n" "maxsock = %d; maxconn = %d; maxpipes = %d
\n" "current conns = %d; current pipes = %d/%d; conn rate = %d/sec; bit rate = %.3f %cbps
\n" "Running tasks: %d/%d; idle = %d %%
\n" "

\n" "\n" "" "" "\n" "" "" "\n" "" "" "\n" "" "" "\n" "" "\n" "" "
 active UP  backup UP
active UP, going down backup UP, going down
active DOWN, going up backup DOWN, going up
active or backup DOWN  not checked
active or backup DOWN for maintenance (MAINT)  
active or backup SOFT STOPPED for maintenance  
\n" "Note: \"NOLB\"/\"DRAIN\" = UP with load-balancing disabled." "		" "Display option:
    " "", (appctx->ctx.stats.flags & STAT_HIDEVER) ? "" : (stats_version_string), pid, (appctx->ctx.stats.flags & STAT_SHNODE) ? " on " : "", (appctx->ctx.stats.flags & STAT_SHNODE) ? (uri->node ? uri->node : global.node) : "", (appctx->ctx.stats.flags & STAT_SHDESC) ? ": " : "", (appctx->ctx.stats.flags & STAT_SHDESC) ? (uri->desc ? uri->desc : global.desc) : "", pid, relative_pid, global.nbproc, global.nbthread, up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60), global.rlimit_memmax ? ultoa(global.rlimit_memmax) : "unlimited", global.rlimit_memmax ? " MB" : "", global.rlimit_nofile, global.maxsock, global.maxconn, global.maxpipes, actconn, pipes_used, pipes_used+pipes_free, read_freq_ctr(&global.conn_per_sec), bps >= 1000000000UL ? (bps / 1000000000.0) : bps >= 1000000UL ? (bps / 1000000.0) : (bps / 1000.0), bps >= 1000000000UL ? 'G' : bps >= 1000000UL ? 'M' : 'k', tasks_run_queue_cur, nb_tasks_cur, ti->idle_pct ); /* scope_txt = search query, appctx->ctx.stats.scope_len is always <= STAT_SCOPE_TXT_MAXLEN */ memcpy(scope_txt, scope_ptr, appctx->ctx.stats.scope_len); scope_txt[appctx->ctx.stats.scope_len] = '\0'; chunk_appendf(&trash, "
  • Scope :
    \n", (appctx->ctx.stats.scope_len > 0) ? scope_txt : "", STAT_SCOPE_TXT_MAXLEN); /* scope_txt = search pattern + search query, appctx->ctx.stats.scope_len is always <= STAT_SCOPE_TXT_MAXLEN */ scope_txt[0] = 0; if (appctx->ctx.stats.scope_len) { strcpy(scope_txt, STAT_SCOPE_PATTERN); memcpy(scope_txt + strlen(STAT_SCOPE_PATTERN), scope_ptr, appctx->ctx.stats.scope_len); scope_txt[strlen(STAT_SCOPE_PATTERN) + appctx->ctx.stats.scope_len] = 0; } if (appctx->ctx.stats.flags & STAT_HIDE_DOWN) chunk_appendf(&trash, "
  • Show all servers
    \n", uri->uri_prefix, "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); else chunk_appendf(&trash, "
  • Hide 'DOWN' servers
    \n", uri->uri_prefix, ";up", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); if (uri->refresh > 0) { if (appctx->ctx.stats.flags & STAT_NO_REFRESH) chunk_appendf(&trash, "
  • Enable refresh
    \n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", "", scope_txt); else chunk_appendf(&trash, "
  • Disable refresh
    \n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", ";norefresh", scope_txt); } chunk_appendf(&trash, "
  • Refresh now
    \n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); chunk_appendf(&trash, "
  • CSV export
    \n", uri->uri_prefix, (uri->refresh > 0) ? ";norefresh" : "", scope_txt); chunk_appendf(&trash, "
  • JSON export (schema)
    \n", uri->uri_prefix, (uri->refresh > 0) ? ";norefresh" : "", scope_txt, uri->uri_prefix); chunk_appendf(&trash, "
" "External resources:" "
\n" "" ); if (appctx->ctx.stats.st_code) { switch (appctx->ctx.stats.st_code) { case STAT_STATUS_DONE: chunk_appendf(&trash, "

" "[X] " "Action processed successfully." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; case STAT_STATUS_NONE: chunk_appendf(&trash, "

" "[X] " "Nothing has changed." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; case STAT_STATUS_PART: chunk_appendf(&trash, "

" "[X] " "Action partially processed.
" "Some server names are probably unknown or ambiguous (duplicated names in the backend)." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; case STAT_STATUS_ERRP: chunk_appendf(&trash, "

" "[X] " "Action not processed because of invalid parameters." "
    " "
  • The action is maybe unknown.
    • " "
  • Invalid key parameter (empty or too long).
    • " "
  • The backend name is probably unknown or ambiguous (duplicated names).
    • " "
  • Some server names are probably unknown or ambiguous (duplicated names in the backend).
    • " "
" "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; case STAT_STATUS_EXCD: chunk_appendf(&trash, "

" "[X] " "Action not processed : the buffer couldn't store all the data.
" "You should retry with less servers at a time." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; case STAT_STATUS_DENY: chunk_appendf(&trash, "

" "[X] " "Action denied." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; case STAT_STATUS_IVAL: chunk_appendf(&trash, "

" "[X] " "Invalid requests (unsupported method or chunked encoded request)." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); break; default: chunk_appendf(&trash, "

" "[X] " "Unexpected result." "
\n", uri->uri_prefix, (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); } chunk_appendf(&trash, "

\n"); } } /* Dumps the HTML stats trailer block to the trash. The caller is responsible * for clearing the trash if needed. */ static void stats_dump_html_end() { chunk_appendf(&trash, "\n"); } /* Dumps the stats JSON header to the trash buffer which. The caller is responsible * for clearing it if needed. */ static void stats_dump_json_header() { chunk_strcat(&trash, "["); } /* Dumps the JSON stats trailer block to the trash. The caller is responsible * for clearing the trash if needed. */ static void stats_dump_json_end() { chunk_strcat(&trash, "]"); } /* This function dumps statistics onto the stream interface's read buffer in * either CSV or HTML format. contains some HTML-specific parameters that * are ignored for CSV format (hence may be NULL there). It returns 0 if * it had to stop writing data and an I/O is needed, 1 if the dump is finished * and the stream must be closed, or -1 in case of any error. This function is * used by both the CLI and the HTTP handlers. */ static int stats_dump_stat_to_buffer(struct stream_interface *si, struct htx *htx, struct uri_auth *uri) { struct appctx *appctx = __objt_appctx(si->end); struct channel *rep = si_ic(si); struct proxy *px; chunk_reset(&trash); switch (appctx->st2) { case STAT_ST_INIT: appctx->st2 = STAT_ST_HEAD; /* let's start producing data */ /* fall through */ case STAT_ST_HEAD: if (appctx->ctx.stats.flags & STAT_FMT_HTML) stats_dump_html_head(appctx, uri); else if (appctx->ctx.stats.flags & STAT_JSON_SCHM) stats_dump_json_schema(&trash); else if (appctx->ctx.stats.flags & STAT_FMT_JSON) stats_dump_json_header(); else if (!(appctx->ctx.stats.flags & STAT_FMT_TYPED)) stats_dump_csv_header(); if (!stats_putchk(rep, htx, &trash)) goto full; if (appctx->ctx.stats.flags & STAT_JSON_SCHM) { appctx->st2 = STAT_ST_FIN; return 1; } appctx->st2 = STAT_ST_INFO; /* fall through */ case STAT_ST_INFO: if (appctx->ctx.stats.flags & STAT_FMT_HTML) { stats_dump_html_info(si, uri); if (!stats_putchk(rep, htx, &trash)) goto full; } appctx->ctx.stats.px = proxies_list; appctx->ctx.stats.px_st = STAT_PX_ST_INIT; appctx->st2 = STAT_ST_LIST; /* fall through */ case STAT_ST_LIST: /* dump proxies */ while (appctx->ctx.stats.px) { if (htx) { if (htx_almost_full(htx)) goto full; } else { if (buffer_almost_full(&rep->buf)) goto full; } px = appctx->ctx.stats.px; /* skip the disabled proxies, global frontend and non-networked ones */ if (px->state != PR_STSTOPPED && px->uuid > 0 && (px->cap & (PR_CAP_FE | PR_CAP_BE))) if (stats_dump_proxy_to_buffer(si, htx, px, uri) == 0) return 0; appctx->ctx.stats.px = px->next; appctx->ctx.stats.px_st = STAT_PX_ST_INIT; } /* here, we just have reached the last proxy */ appctx->st2 = STAT_ST_END; /* fall through */ case STAT_ST_END: if (appctx->ctx.stats.flags & (STAT_FMT_HTML|STAT_FMT_JSON)) { if (appctx->ctx.stats.flags & STAT_FMT_HTML) stats_dump_html_end(); else stats_dump_json_end(); if (!stats_putchk(rep, htx, &trash)) goto full; } appctx->st2 = STAT_ST_FIN; /* fall through */ case STAT_ST_FIN: return 1; default: /* unknown state ! */ appctx->st2 = STAT_ST_FIN; return -1; } full: si_rx_room_blk(si); return 0; } /* We reached the stats page through a POST request. The appctx is * expected to have already been allocated by the caller. * Parse the posted data and enable/disable servers if necessary. * Returns 1 if request was parsed or zero if it needs more data. */ static int stats_process_http_post(struct stream_interface *si) { struct stream *s = si_strm(si); struct appctx *appctx = objt_appctx(si->end); struct proxy *px = NULL; struct server *sv = NULL; char key[LINESIZE]; int action = ST_ADM_ACTION_NONE; int reprocess = 0; int total_servers = 0; int altered_servers = 0; char *first_param, *cur_param, *next_param, *end_params; char *st_cur_param = NULL; char *st_next_param = NULL; struct buffer *temp = get_trash_chunk(); struct htx *htx = htxbuf(&s->req.buf); struct htx_blk *blk; /* we need more data */ if (s->txn->req.msg_state < HTTP_MSG_DONE) { /* check if we can receive more */ if (htx_free_data_space(htx) <= global.tune.maxrewrite) { appctx->ctx.stats.st_code = STAT_STATUS_EXCD; goto out; } goto wait; } /* The request was fully received. Copy data */ blk = htx_get_head_blk(htx); while (blk) { enum htx_blk_type type = htx_get_blk_type(blk); if (type == HTX_BLK_EOM || type == HTX_BLK_TLR || type == HTX_BLK_EOT) break; if (type == HTX_BLK_DATA) { struct ist v = htx_get_blk_value(htx, blk); if (!chunk_memcat(temp, v.ptr, v.len)) { appctx->ctx.stats.st_code = STAT_STATUS_EXCD; goto out; } } blk = htx_get_next_blk(htx, blk); } first_param = temp->area; end_params = temp->area + temp->data; cur_param = next_param = end_params; *end_params = '\0'; appctx->ctx.stats.st_code = STAT_STATUS_NONE; /* * Parse the parameters in reverse order to only store the last value. * From the html form, the backend and the action are at the end. */ while (cur_param > first_param) { char *value; int poffset, plen; cur_param--; if ((*cur_param == '&') || (cur_param == first_param)) { reprocess_servers: /* Parse the key */ poffset = (cur_param != first_param ? 1 : 0); plen = next_param - cur_param + (cur_param == first_param ? 1 : 0); if ((plen > 0) && (plen <= sizeof(key))) { strncpy(key, cur_param + poffset, plen); key[plen - 1] = '\0'; } else { appctx->ctx.stats.st_code = STAT_STATUS_ERRP; goto out; } /* Parse the value */ value = key; while (*value != '\0' && *value != '=') { value++; } if (*value == '=') { /* Ok, a value is found, we can mark the end of the key */ *value++ = '\0'; } if (url_decode(key) < 0 || url_decode(value) < 0) break; /* Now we can check the key to see what to do */ if (!px && (strcmp(key, "b") == 0)) { if ((px = proxy_be_by_name(value)) == NULL) { /* the backend name is unknown or ambiguous (duplicate names) */ appctx->ctx.stats.st_code = STAT_STATUS_ERRP; goto out; } } else if (!action && (strcmp(key, "action") == 0)) { if (strcmp(value, "ready") == 0) { action = ST_ADM_ACTION_READY; } else if (strcmp(value, "drain") == 0) { action = ST_ADM_ACTION_DRAIN; } else if (strcmp(value, "maint") == 0) { action = ST_ADM_ACTION_MAINT; } else if (strcmp(value, "shutdown") == 0) { action = ST_ADM_ACTION_SHUTDOWN; } else if (strcmp(value, "dhlth") == 0) { action = ST_ADM_ACTION_DHLTH; } else if (strcmp(value, "ehlth") == 0) { action = ST_ADM_ACTION_EHLTH; } else if (strcmp(value, "hrunn") == 0) { action = ST_ADM_ACTION_HRUNN; } else if (strcmp(value, "hnolb") == 0) { action = ST_ADM_ACTION_HNOLB; } else if (strcmp(value, "hdown") == 0) { action = ST_ADM_ACTION_HDOWN; } else if (strcmp(value, "dagent") == 0) { action = ST_ADM_ACTION_DAGENT; } else if (strcmp(value, "eagent") == 0) { action = ST_ADM_ACTION_EAGENT; } else if (strcmp(value, "arunn") == 0) { action = ST_ADM_ACTION_ARUNN; } else if (strcmp(value, "adown") == 0) { action = ST_ADM_ACTION_ADOWN; } /* else these are the old supported methods */ else if (strcmp(value, "disable") == 0) { action = ST_ADM_ACTION_DISABLE; } else if (strcmp(value, "enable") == 0) { action = ST_ADM_ACTION_ENABLE; } else if (strcmp(value, "stop") == 0) { action = ST_ADM_ACTION_STOP; } else if (strcmp(value, "start") == 0) { action = ST_ADM_ACTION_START; } else { appctx->ctx.stats.st_code = STAT_STATUS_ERRP; goto out; } } else if (strcmp(key, "s") == 0) { if (!(px && action)) { /* * Indicates that we'll need to reprocess the parameters * as soon as backend and action are known */ if (!reprocess) { st_cur_param = cur_param; st_next_param = next_param; } reprocess = 1; } else if ((sv = findserver(px, value)) != NULL) { HA_SPIN_LOCK(SERVER_LOCK, &sv->lock); switch (action) { case ST_ADM_ACTION_DISABLE: if (!(sv->cur_admin & SRV_ADMF_FMAINT)) { altered_servers++; total_servers++; srv_set_admin_flag(sv, SRV_ADMF_FMAINT, "'disable' on stats page"); } break; case ST_ADM_ACTION_ENABLE: if (sv->cur_admin & SRV_ADMF_FMAINT) { altered_servers++; total_servers++; srv_clr_admin_flag(sv, SRV_ADMF_FMAINT); } break; case ST_ADM_ACTION_STOP: if (!(sv->cur_admin & SRV_ADMF_FDRAIN)) { srv_set_admin_flag(sv, SRV_ADMF_FDRAIN, "'stop' on stats page"); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_START: if (sv->cur_admin & SRV_ADMF_FDRAIN) { srv_clr_admin_flag(sv, SRV_ADMF_FDRAIN); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_DHLTH: if (sv->check.state & CHK_ST_CONFIGURED) { sv->check.state &= ~CHK_ST_ENABLED; altered_servers++; total_servers++; } break; case ST_ADM_ACTION_EHLTH: if (sv->check.state & CHK_ST_CONFIGURED) { sv->check.state |= CHK_ST_ENABLED; altered_servers++; total_servers++; } break; case ST_ADM_ACTION_HRUNN: if (!(sv->track)) { sv->check.health = sv->check.rise + sv->check.fall - 1; srv_set_running(sv, "changed from Web interface", NULL); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_HNOLB: if (!(sv->track)) { sv->check.health = sv->check.rise + sv->check.fall - 1; srv_set_stopping(sv, "changed from Web interface", NULL); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_HDOWN: if (!(sv->track)) { sv->check.health = 0; srv_set_stopped(sv, "changed from Web interface", NULL); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_DAGENT: if (sv->agent.state & CHK_ST_CONFIGURED) { sv->agent.state &= ~CHK_ST_ENABLED; altered_servers++; total_servers++; } break; case ST_ADM_ACTION_EAGENT: if (sv->agent.state & CHK_ST_CONFIGURED) { sv->agent.state |= CHK_ST_ENABLED; altered_servers++; total_servers++; } break; case ST_ADM_ACTION_ARUNN: if (sv->agent.state & CHK_ST_ENABLED) { sv->agent.health = sv->agent.rise + sv->agent.fall - 1; srv_set_running(sv, "changed from Web interface", NULL); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_ADOWN: if (sv->agent.state & CHK_ST_ENABLED) { sv->agent.health = 0; srv_set_stopped(sv, "changed from Web interface", NULL); altered_servers++; total_servers++; } break; case ST_ADM_ACTION_READY: srv_adm_set_ready(sv); altered_servers++; total_servers++; break; case ST_ADM_ACTION_DRAIN: srv_adm_set_drain(sv); altered_servers++; total_servers++; break; case ST_ADM_ACTION_MAINT: srv_adm_set_maint(sv); altered_servers++; total_servers++; break; case ST_ADM_ACTION_SHUTDOWN: if (px->state != PR_STSTOPPED) { struct stream *sess, *sess_bck; list_for_each_entry_safe(sess, sess_bck, &sv->actconns, by_srv) if (sess->srv_conn == sv) stream_shutdown(sess, SF_ERR_KILLED); altered_servers++; total_servers++; } break; } HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock); } else { /* the server name is unknown or ambiguous (duplicate names) */ total_servers++; } } if (reprocess && px && action) { /* Now, we know the backend and the action chosen by the user. * We can safely restart from the first server parameter * to reprocess them */ cur_param = st_cur_param; next_param = st_next_param; reprocess = 0; goto reprocess_servers; } next_param = cur_param; } } if (total_servers == 0) { appctx->ctx.stats.st_code = STAT_STATUS_NONE; } else if (altered_servers == 0) { appctx->ctx.stats.st_code = STAT_STATUS_ERRP; } else if (altered_servers == total_servers) { appctx->ctx.stats.st_code = STAT_STATUS_DONE; } else { appctx->ctx.stats.st_code = STAT_STATUS_PART; } out: return 1; wait: appctx->ctx.stats.st_code = STAT_STATUS_NONE; return 0; } static int stats_send_http_headers(struct stream_interface *si, struct htx *htx) { struct stream *s = si_strm(si); struct uri_auth *uri = s->be->uri_auth; struct appctx *appctx = __objt_appctx(si->end); struct htx_sl *sl; unsigned int flags; flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11|HTX_SL_F_XFER_ENC|HTX_SL_F_XFER_LEN|HTX_SL_F_CHNK); sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"), ist("200"), ist("OK")); if (!sl) goto full; sl->info.res.status = 200; if (!htx_add_header(htx, ist("Cache-Control"), ist("no-cache"))) goto full; if (appctx->ctx.stats.flags & STAT_FMT_HTML) { if (!htx_add_header(htx, ist("Content-Type"), ist("text/html"))) goto full; } else if (appctx->ctx.stats.flags & (STAT_FMT_JSON|STAT_JSON_SCHM)) { if (!htx_add_header(htx, ist("Content-Type"), ist("application/json"))) goto full; } else { if (!htx_add_header(htx, ist("Content-Type"), ist("text/plain"))) goto full; } if (uri->refresh > 0 && !(appctx->ctx.stats.flags & STAT_NO_REFRESH)) { const char *refresh = U2A(uri->refresh); if (!htx_add_header(htx, ist("Refresh"), ist2(refresh, strlen(refresh)))) goto full; } if (appctx->ctx.stats.flags & STAT_CHUNKED) { if (!htx_add_header(htx, ist("Transfer-Encoding"), ist("chunked"))) goto full; } if (!htx_add_endof(htx, HTX_BLK_EOH)) goto full; channel_add_input(&s->res, htx->data); return 1; full: htx_reset(htx); si_rx_room_blk(si); return 0; } static int stats_send_http_redirect(struct stream_interface *si, struct htx *htx) { char scope_txt[STAT_SCOPE_TXT_MAXLEN + sizeof STAT_SCOPE_PATTERN]; struct stream *s = si_strm(si); struct uri_auth *uri = s->be->uri_auth; struct appctx *appctx = __objt_appctx(si->end); struct htx_sl *sl; unsigned int flags; /* scope_txt = search pattern + search query, appctx->ctx.stats.scope_len is always <= STAT_SCOPE_TXT_MAXLEN */ scope_txt[0] = 0; if (appctx->ctx.stats.scope_len) { const char *scope_ptr = stats_scope_ptr(appctx, si); strcpy(scope_txt, STAT_SCOPE_PATTERN); memcpy(scope_txt + strlen(STAT_SCOPE_PATTERN), scope_ptr, appctx->ctx.stats.scope_len); scope_txt[strlen(STAT_SCOPE_PATTERN) + appctx->ctx.stats.scope_len] = 0; } /* We don't want to land on the posted stats page because a refresh will * repost the data. We don't want this to happen on accident so we redirect * the browse to the stats page with a GET. */ chunk_printf(&trash, "%s;st=%s%s%s%s", uri->uri_prefix, ((appctx->ctx.stats.st_code > STAT_STATUS_INIT) && (appctx->ctx.stats.st_code < STAT_STATUS_SIZE) && stat_status_codes[appctx->ctx.stats.st_code]) ? stat_status_codes[appctx->ctx.stats.st_code] : stat_status_codes[STAT_STATUS_UNKN], (appctx->ctx.stats.flags & STAT_HIDE_DOWN) ? ";up" : "", (appctx->ctx.stats.flags & STAT_NO_REFRESH) ? ";norefresh" : "", scope_txt); flags = (HTX_SL_F_IS_RESP|HTX_SL_F_VER_11|HTX_SL_F_XFER_LEN|HTX_SL_F_CHNK); sl = htx_add_stline(htx, HTX_BLK_RES_SL, flags, ist("HTTP/1.1"), ist("303"), ist("See Other")); if (!sl) goto full; sl->info.res.status = 303; if (!htx_add_header(htx, ist("Cache-Control"), ist("no-cache")) || !htx_add_header(htx, ist("Content-Type"), ist("text/plain")) || !htx_add_header(htx, ist("Content-Length"), ist("0")) || !htx_add_header(htx, ist("Location"), ist2(trash.area, trash.data))) goto full; if (!htx_add_endof(htx, HTX_BLK_EOH)) goto full; channel_add_input(&s->res, htx->data); return 1; full: htx_reset(htx); si_rx_room_blk(si); return 0; } /* This I/O handler runs as an applet embedded in a stream interface. It is * used to send HTTP stats over a TCP socket. The mechanism is very simple. * appctx->st0 contains the operation in progress (dump, done). The handler * automatically unregisters itself once transfer is complete. */ static void http_stats_io_handler(struct appctx *appctx) { struct stream_interface *si = appctx->owner; struct stream *s = si_strm(si); struct channel *req = si_oc(si); struct channel *res = si_ic(si); struct htx *req_htx, *res_htx; res_htx = htx_from_buf(&res->buf); if (unlikely(si->state == SI_ST_DIS || si->state == SI_ST_CLO)) goto out; /* Check if the input buffer is avalaible. */ if (!b_size(&res->buf)) { si_rx_room_blk(si); goto out; } /* check that the output is not closed */ if (res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_SHUTR)) appctx->st0 = STAT_HTTP_END; /* all states are processed in sequence */ if (appctx->st0 == STAT_HTTP_HEAD) { if (stats_send_http_headers(si, res_htx)) { if (s->txn->meth == HTTP_METH_HEAD) appctx->st0 = STAT_HTTP_DONE; else appctx->st0 = STAT_HTTP_DUMP; } } if (appctx->st0 == STAT_HTTP_DUMP) { if (stats_dump_stat_to_buffer(si, res_htx, s->be->uri_auth)) appctx->st0 = STAT_HTTP_DONE; } if (appctx->st0 == STAT_HTTP_POST) { if (stats_process_http_post(si)) appctx->st0 = STAT_HTTP_LAST; else if (req->flags & CF_SHUTR) appctx->st0 = STAT_HTTP_DONE; } if (appctx->st0 == STAT_HTTP_LAST) { if (stats_send_http_redirect(si, res_htx)) appctx->st0 = STAT_HTTP_DONE; } if (appctx->st0 == STAT_HTTP_DONE) { /* Don't add TLR because mux-h1 will take care of it */ if (!htx_add_endof(res_htx, HTX_BLK_EOM)) { si_rx_room_blk(si); goto out; } channel_add_input(&s->res, 1); appctx->st0 = STAT_HTTP_END; } if (appctx->st0 == STAT_HTTP_END) { if (!(res->flags & CF_SHUTR)) { res->flags |= CF_READ_NULL; si_shutr(si); } /* eat the whole request */ if (co_data(req)) { req_htx = htx_from_buf(&req->buf); co_htx_skip(req, req_htx, co_data(req)); htx_to_buf(req_htx, &req->buf); } } out: /* we have left the request in the buffer for the case where we * process a POST, and this automatically re-enables activity on * read. It's better to indicate that we want to stop reading when * we're sending, so that we know there's at most one direction * deciding to wake the applet up. It saves it from looping when * emitting large blocks into small TCP windows. */ htx_to_buf(res_htx, &res->buf); if (!channel_is_empty(res)) si_stop_get(si); } /* Dump all fields from into using the "show info" format (name: value) */ static int stats_dump_info_fields(struct buffer *out, const struct field *info, unsigned int flags) { int field; for (field = 0; field < INF_TOTAL_FIELDS; field++) { if (!field_format(info, field)) continue; if (!chunk_appendf(out, "%s: ", info_fields[field].name)) return 0; if (!stats_emit_raw_data_field(out, &info[field])) return 0; if ((flags & STAT_SHOW_FDESC) && !chunk_appendf(out, ":\"%s\"", info_fields[field].desc)) return 0; if (!chunk_strcat(out, "\n")) return 0; } return 1; } /* Dump all fields from into using the "show info typed" format */ static int stats_dump_typed_info_fields(struct buffer *out, const struct field *info, unsigned int flags) { int field; for (field = 0; field < INF_TOTAL_FIELDS; field++) { if (!field_format(info, field)) continue; if (!chunk_appendf(out, "%d.%s.%u:", field, info_fields[field].name, info[INF_PROCESS_NUM].u.u32)) return 0; if (!stats_emit_field_tags(out, &info[field], ':')) return 0; if (!stats_emit_typed_data_field(out, &info[field])) return 0; if ((flags & STAT_SHOW_FDESC) && !chunk_appendf(out, ":\"%s\"", info_fields[field].desc)) return 0; if (!chunk_strcat(out, "\n")) return 0; } return 1; } /* Fill with HAProxy global info. is preallocated * array of length . The length of the aray must be * INF_TOTAL_FIELDS. If this length is less then this value, the * function returns 0, otherwise, it returns 1. */ int stats_fill_info(struct field *info, int len) { unsigned int up = (now.tv_sec - start_date.tv_sec); struct buffer *out = get_trash_chunk(); #ifdef USE_OPENSSL int ssl_sess_rate = read_freq_ctr(&global.ssl_per_sec); int ssl_key_rate = read_freq_ctr(&global.ssl_fe_keys_per_sec); int ssl_reuse = 0; if (ssl_key_rate < ssl_sess_rate) { /* count the ssl reuse ratio and avoid overflows in both directions */ ssl_reuse = 100 - (100 * ssl_key_rate + (ssl_sess_rate - 1) / 2) / ssl_sess_rate; } #endif if (len < INF_TOTAL_FIELDS) return 0; chunk_reset(out); memset(info, 0, sizeof(*info) * len); info[INF_NAME] = mkf_str(FO_PRODUCT|FN_OUTPUT|FS_SERVICE, PRODUCT_NAME); info[INF_VERSION] = mkf_str(FO_PRODUCT|FN_OUTPUT|FS_SERVICE, haproxy_version); info[INF_RELEASE_DATE] = mkf_str(FO_PRODUCT|FN_OUTPUT|FS_SERVICE, haproxy_date); info[INF_NBTHREAD] = mkf_u32(FO_CONFIG|FS_SERVICE, global.nbthread); info[INF_NBPROC] = mkf_u32(FO_CONFIG|FS_SERVICE, global.nbproc); info[INF_PROCESS_NUM] = mkf_u32(FO_KEY, relative_pid); info[INF_PID] = mkf_u32(FO_STATUS, pid); info[INF_UPTIME] = mkf_str(FN_DURATION, chunk_newstr(out)); chunk_appendf(out, "%ud %uh%02um%02us", up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60)); info[INF_UPTIME_SEC] = mkf_u32(FN_DURATION, up); info[INF_MEMMAX_MB] = mkf_u32(FO_CONFIG|FN_LIMIT, global.rlimit_memmax); info[INF_POOL_ALLOC_MB] = mkf_u32(0, (unsigned)(pool_total_allocated() / 1048576L)); info[INF_POOL_USED_MB] = mkf_u32(0, (unsigned)(pool_total_used() / 1048576L)); info[INF_POOL_FAILED] = mkf_u32(FN_COUNTER, pool_total_failures()); info[INF_ULIMIT_N] = mkf_u32(FO_CONFIG|FN_LIMIT, global.rlimit_nofile); info[INF_MAXSOCK] = mkf_u32(FO_CONFIG|FN_LIMIT, global.maxsock); info[INF_MAXCONN] = mkf_u32(FO_CONFIG|FN_LIMIT, global.maxconn); info[INF_HARD_MAXCONN] = mkf_u32(FO_CONFIG|FN_LIMIT, global.hardmaxconn); info[INF_CURR_CONN] = mkf_u32(0, actconn); info[INF_CUM_CONN] = mkf_u32(FN_COUNTER, totalconn); info[INF_CUM_REQ] = mkf_u32(FN_COUNTER, global.req_count); #ifdef USE_OPENSSL info[INF_MAX_SSL_CONNS] = mkf_u32(FN_MAX, global.maxsslconn); info[INF_CURR_SSL_CONNS] = mkf_u32(0, sslconns); info[INF_CUM_SSL_CONNS] = mkf_u32(FN_COUNTER, totalsslconns); #endif info[INF_MAXPIPES] = mkf_u32(FO_CONFIG|FN_LIMIT, global.maxpipes); info[INF_PIPES_USED] = mkf_u32(0, pipes_used); info[INF_PIPES_FREE] = mkf_u32(0, pipes_free); info[INF_CONN_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&global.conn_per_sec)); info[INF_CONN_RATE_LIMIT] = mkf_u32(FO_CONFIG|FN_LIMIT, global.cps_lim); info[INF_MAX_CONN_RATE] = mkf_u32(FN_MAX, global.cps_max); info[INF_SESS_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&global.sess_per_sec)); info[INF_SESS_RATE_LIMIT] = mkf_u32(FO_CONFIG|FN_LIMIT, global.sps_lim); info[INF_MAX_SESS_RATE] = mkf_u32(FN_RATE, global.sps_max); #ifdef USE_OPENSSL info[INF_SSL_RATE] = mkf_u32(FN_RATE, ssl_sess_rate); info[INF_SSL_RATE_LIMIT] = mkf_u32(FO_CONFIG|FN_LIMIT, global.ssl_lim); info[INF_MAX_SSL_RATE] = mkf_u32(FN_MAX, global.ssl_max); info[INF_SSL_FRONTEND_KEY_RATE] = mkf_u32(0, ssl_key_rate); info[INF_SSL_FRONTEND_MAX_KEY_RATE] = mkf_u32(FN_MAX, global.ssl_fe_keys_max); info[INF_SSL_FRONTEND_SESSION_REUSE_PCT] = mkf_u32(0, ssl_reuse); info[INF_SSL_BACKEND_KEY_RATE] = mkf_u32(FN_RATE, read_freq_ctr(&global.ssl_be_keys_per_sec)); info[INF_SSL_BACKEND_MAX_KEY_RATE] = mkf_u32(FN_MAX, global.ssl_be_keys_max); info[INF_SSL_CACHE_LOOKUPS] = mkf_u32(FN_COUNTER, global.shctx_lookups); info[INF_SSL_CACHE_MISSES] = mkf_u32(FN_COUNTER, global.shctx_misses); #endif info[INF_COMPRESS_BPS_IN] = mkf_u32(FN_RATE, read_freq_ctr(&global.comp_bps_in)); info[INF_COMPRESS_BPS_OUT] = mkf_u32(FN_RATE, read_freq_ctr(&global.comp_bps_out)); info[INF_COMPRESS_BPS_RATE_LIM] = mkf_u32(FO_CONFIG|FN_LIMIT, global.comp_rate_lim); #ifdef USE_ZLIB info[INF_ZLIB_MEM_USAGE] = mkf_u32(0, zlib_used_memory); info[INF_MAX_ZLIB_MEM_USAGE] = mkf_u32(FO_CONFIG|FN_LIMIT, global.maxzlibmem); #endif info[INF_TASKS] = mkf_u32(0, nb_tasks_cur); info[INF_RUN_QUEUE] = mkf_u32(0, tasks_run_queue_cur); info[INF_IDLE_PCT] = mkf_u32(FN_AVG, ti->idle_pct); info[INF_NODE] = mkf_str(FO_CONFIG|FN_OUTPUT|FS_SERVICE, global.node); if (global.desc) info[INF_DESCRIPTION] = mkf_str(FO_CONFIG|FN_OUTPUT|FS_SERVICE, global.desc); info[INF_STOPPING] = mkf_u32(0, stopping); info[INF_JOBS] = mkf_u32(0, jobs); info[INF_UNSTOPPABLE_JOBS] = mkf_u32(0, unstoppable_jobs); info[INF_LISTENERS] = mkf_u32(0, listeners); info[INF_ACTIVE_PEERS] = mkf_u32(0, active_peers); info[INF_CONNECTED_PEERS] = mkf_u32(0, connected_peers); info[INF_DROPPED_LOGS] = mkf_u32(0, dropped_logs); info[INF_BUSY_POLLING] = mkf_u32(0, !!(global.tune.options & GTUNE_BUSY_POLLING)); info[INF_FAILED_RESOLUTIONS] = mkf_u32(0, dns_failed_resolutions); info[INF_TOTAL_BYTES_OUT] = mkf_u64(0, global.out_bytes); info[INF_BYTES_OUT_RATE] = mkf_u64(FN_RATE, (unsigned long long)read_freq_ctr(&global.out_32bps) * 32); return 1; } /* This function dumps information onto the stream interface's read buffer. * It returns 0 as long as it does not complete, non-zero upon completion. * No state is used. */ static int stats_dump_info_to_buffer(struct stream_interface *si) { struct appctx *appctx = __objt_appctx(si->end); if (!stats_fill_info(info, INF_TOTAL_FIELDS)) return 0; chunk_reset(&trash); if (appctx->ctx.stats.flags & STAT_FMT_TYPED) stats_dump_typed_info_fields(&trash, info, appctx->ctx.stats.flags); else if (appctx->ctx.stats.flags & STAT_FMT_JSON) stats_dump_json_info_fields(&trash, info, appctx->ctx.stats.flags); else stats_dump_info_fields(&trash, info, appctx->ctx.stats.flags); if (ci_putchk(si_ic(si), &trash) == -1) { si_rx_room_blk(si); return 0; } return 1; } /* This function dumps the schema onto the stream interface's read buffer. * It returns 0 as long as it does not complete, non-zero upon completion. * No state is used. * * Integer values bouned to the range [-(2**53)+1, (2**53)-1] as * per the recommendation for interoperable integers in section 6 of RFC 7159. */ static void stats_dump_json_schema(struct buffer *out) { int old_len = out->data; chunk_strcat(out, "{" "\"$schema\":\"http://json-schema.org/draft-04/schema#\"," "\"oneOf\":[" "{" "\"title\":\"Info\"," "\"type\":\"array\"," "\"items\":{" "\"properties\":{" "\"title\":\"InfoItem\"," "\"type\":\"object\"," "\"field\":{\"$ref\":\"#/definitions/field\"}," "\"processNum\":{\"$ref\":\"#/definitions/processNum\"}," "\"tags\":{\"$ref\":\"#/definitions/tags\"}," "\"value\":{\"$ref\":\"#/definitions/typedValue\"}" "}," "\"required\":[\"field\",\"processNum\",\"tags\"," "\"value\"]" "}" "}," "{" "\"title\":\"Stat\"," "\"type\":\"array\"," "\"items\":{" "\"title\":\"InfoItem\"," "\"type\":\"object\"," "\"properties\":{" "\"objType\":{" "\"enum\":[\"Frontend\",\"Backend\",\"Listener\"," "\"Server\",\"Unknown\"]" "}," "\"proxyId\":{" "\"type\":\"integer\"," "\"minimum\":0" "}," "\"id\":{" "\"type\":\"integer\"," "\"minimum\":0" "}," "\"field\":{\"$ref\":\"#/definitions/field\"}," "\"processNum\":{\"$ref\":\"#/definitions/processNum\"}," "\"tags\":{\"$ref\":\"#/definitions/tags\"}," "\"typedValue\":{\"$ref\":\"#/definitions/typedValue\"}" "}," "\"required\":[\"objType\",\"proxyId\",\"id\"," "\"field\",\"processNum\",\"tags\"," "\"value\"]" "}" "}," "{" "\"title\":\"Error\"," "\"type\":\"object\"," "\"properties\":{" "\"errorStr\":{" "\"type\":\"string\"" "}," "\"required\":[\"errorStr\"]" "}" "}" "]," "\"definitions\":{" "\"field\":{" "\"type\":\"object\"," "\"pos\":{" "\"type\":\"integer\"," "\"minimum\":0" "}," "\"name\":{" "\"type\":\"string\"" "}," "\"required\":[\"pos\",\"name\"]" "}," "\"processNum\":{" "\"type\":\"integer\"," "\"minimum\":1" "}," "\"tags\":{" "\"type\":\"object\"," "\"origin\":{" "\"type\":\"string\"," "\"enum\":[\"Metric\",\"Status\",\"Key\"," "\"Config\",\"Product\",\"Unknown\"]" "}," "\"nature\":{" "\"type\":\"string\"," "\"enum\":[\"Gauge\",\"Limit\",\"Min\",\"Max\"," "\"Rate\",\"Counter\",\"Duration\"," "\"Age\",\"Time\",\"Name\",\"Output\"," "\"Avg\", \"Unknown\"]" "}," "\"scope\":{" "\"type\":\"string\"," "\"enum\":[\"Cluster\",\"Process\",\"Service\"," "\"System\",\"Unknown\"]" "}," "\"required\":[\"origin\",\"nature\",\"scope\"]" "}," "\"typedValue\":{" "\"type\":\"object\"," "\"oneOf\":[" "{\"$ref\":\"#/definitions/typedValue/definitions/s32Value\"}," "{\"$ref\":\"#/definitions/typedValue/definitions/s64Value\"}," "{\"$ref\":\"#/definitions/typedValue/definitions/u32Value\"}," "{\"$ref\":\"#/definitions/typedValue/definitions/u64Value\"}," "{\"$ref\":\"#/definitions/typedValue/definitions/strValue\"}" "]," "\"definitions\":{" "\"s32Value\":{" "\"properties\":{" "\"type\":{" "\"type\":\"string\"," "\"enum\":[\"s32\"]" "}," "\"value\":{" "\"type\":\"integer\"," "\"minimum\":-2147483648," "\"maximum\":2147483647" "}" "}," "\"required\":[\"type\",\"value\"]" "}," "\"s64Value\":{" "\"properties\":{" "\"type\":{" "\"type\":\"string\"," "\"enum\":[\"s64\"]" "}," "\"value\":{" "\"type\":\"integer\"," "\"minimum\":-9007199254740991," "\"maximum\":9007199254740991" "}" "}," "\"required\":[\"type\",\"value\"]" "}," "\"u32Value\":{" "\"properties\":{" "\"type\":{" "\"type\":\"string\"," "\"enum\":[\"u32\"]" "}," "\"value\":{" "\"type\":\"integer\"," "\"minimum\":0," "\"maximum\":4294967295" "}" "}," "\"required\":[\"type\",\"value\"]" "}," "\"u64Value\":{" "\"properties\":{" "\"type\":{" "\"type\":\"string\"," "\"enum\":[\"u64\"]" "}," "\"value\":{" "\"type\":\"integer\"," "\"minimum\":0," "\"maximum\":9007199254740991" "}" "}," "\"required\":[\"type\",\"value\"]" "}," "\"strValue\":{" "\"properties\":{" "\"type\":{" "\"type\":\"string\"," "\"enum\":[\"str\"]" "}," "\"value\":{\"type\":\"string\"}" "}," "\"required\":[\"type\",\"value\"]" "}," "\"unknownValue\":{" "\"properties\":{" "\"type\":{" "\"type\":\"integer\"," "\"minimum\":0" "}," "\"value\":{" "\"type\":\"string\"," "\"enum\":[\"unknown\"]" "}" "}," "\"required\":[\"type\",\"value\"]" "}" "}" "}" "}" "}"); if (old_len == out->data) { chunk_reset(out); chunk_appendf(out, "{\"errorStr\":\"output buffer too short\"}"); } } /* This function dumps the schema onto the stream interface's read buffer. * It returns 0 as long as it does not complete, non-zero upon completion. * No state is used. */ static int stats_dump_json_schema_to_buffer(struct stream_interface *si) { chunk_reset(&trash); stats_dump_json_schema(&trash); if (ci_putchk(si_ic(si), &trash) == -1) { si_rx_room_blk(si); return 0; } return 1; } static int cli_parse_clear_counters(char **args, char *payload, struct appctx *appctx, void *private) { struct proxy *px; struct server *sv; struct listener *li; int clrall = 0; if (strcmp(args[2], "all") == 0) clrall = 1; /* check permissions */ if (!cli_has_level(appctx, ACCESS_LVL_OPER) || (clrall && !cli_has_level(appctx, ACCESS_LVL_ADMIN))) return 1; for (px = proxies_list; px; px = px->next) { if (clrall) { memset(&px->be_counters, 0, sizeof(px->be_counters)); memset(&px->fe_counters, 0, sizeof(px->fe_counters)); } else { px->be_counters.conn_max = 0; px->be_counters.p.http.rps_max = 0; px->be_counters.sps_max = 0; px->be_counters.cps_max = 0; px->be_counters.nbpend_max = 0; px->fe_counters.conn_max = 0; px->fe_counters.p.http.rps_max = 0; px->fe_counters.sps_max = 0; px->fe_counters.cps_max = 0; } for (sv = px->srv; sv; sv = sv->next) if (clrall) memset(&sv->counters, 0, sizeof(sv->counters)); else { sv->counters.cur_sess_max = 0; sv->counters.nbpend_max = 0; sv->counters.sps_max = 0; } list_for_each_entry(li, &px->conf.listeners, by_fe) if (li->counters) { if (clrall) memset(li->counters, 0, sizeof(*li->counters)); else li->counters->conn_max = 0; } } global.cps_max = 0; global.sps_max = 0; global.ssl_max = 0; global.ssl_fe_keys_max = 0; global.ssl_be_keys_max = 0; memset(activity, 0, sizeof(activity)); return 1; } static int cli_parse_show_info(char **args, char *payload, struct appctx *appctx, void *private) { int arg = 2; appctx->ctx.stats.scope_str = 0; appctx->ctx.stats.scope_len = 0; appctx->ctx.stats.flags = 0; while (*args[arg]) { if (strcmp(args[arg], "typed") == 0) appctx->ctx.stats.flags = (appctx->ctx.stats.flags & ~STAT_FMT_MASK) | STAT_FMT_TYPED; else if (strcmp(args[arg], "json") == 0) appctx->ctx.stats.flags = (appctx->ctx.stats.flags & ~STAT_FMT_MASK) | STAT_FMT_JSON; else if (strcmp(args[arg], "desc") == 0) appctx->ctx.stats.flags |= STAT_SHOW_FDESC; arg++; } return 0; } static int cli_parse_show_stat(char **args, char *payload, struct appctx *appctx, void *private) { int arg = 2; appctx->ctx.stats.scope_str = 0; appctx->ctx.stats.scope_len = 0; appctx->ctx.stats.flags = STAT_SHNODE | STAT_SHDESC; if ((strm_li(si_strm(appctx->owner))->bind_conf->level & ACCESS_LVL_MASK) >= ACCESS_LVL_OPER) appctx->ctx.stats.flags |= STAT_SHLGNDS; if (*args[arg] && *args[arg+1] && *args[arg+2]) { struct proxy *px; px = proxy_find_by_name(args[arg], 0, 0); if (px) appctx->ctx.stats.iid = px->uuid; else appctx->ctx.stats.iid = atoi(args[arg]); if (!appctx->ctx.stats.iid) return cli_err(appctx, "No such proxy.\n"); appctx->ctx.stats.flags |= STAT_BOUND; appctx->ctx.stats.type = atoi(args[arg+1]); appctx->ctx.stats.sid = atoi(args[arg+2]); arg += 3; } while (*args[arg]) { if (strcmp(args[arg], "typed") == 0) appctx->ctx.stats.flags = (appctx->ctx.stats.flags & ~STAT_FMT_MASK) | STAT_FMT_TYPED; else if (strcmp(args[arg], "json") == 0) appctx->ctx.stats.flags = (appctx->ctx.stats.flags & ~STAT_FMT_MASK) | STAT_FMT_JSON; else if (strcmp(args[arg], "desc") == 0) appctx->ctx.stats.flags |= STAT_SHOW_FDESC; arg++; } return 0; } static int cli_io_handler_dump_info(struct appctx *appctx) { return stats_dump_info_to_buffer(appctx->owner); } /* This I/O handler runs as an applet embedded in a stream interface. It is * used to send raw stats over a socket. */ static int cli_io_handler_dump_stat(struct appctx *appctx) { return stats_dump_stat_to_buffer(appctx->owner, NULL, NULL); } static int cli_io_handler_dump_json_schema(struct appctx *appctx) { return stats_dump_json_schema_to_buffer(appctx->owner); } /* register cli keywords */ static struct cli_kw_list cli_kws = {{ },{ { { "clear", "counters", NULL }, "clear counters : clear max statistics counters (add 'all' for all counters)", cli_parse_clear_counters, NULL, NULL }, { { "show", "info", NULL }, "show info : report information about the running process [desc|json|typed]*", cli_parse_show_info, cli_io_handler_dump_info, NULL }, { { "show", "stat", NULL }, "show stat : report counters for each proxy and server [desc|json|typed]*", cli_parse_show_stat, cli_io_handler_dump_stat, NULL }, { { "show", "schema", "json", NULL }, "show schema json : report schema used for stats", NULL, cli_io_handler_dump_json_schema, NULL }, {{},} }}; INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws); struct applet http_stats_applet = { .obj_type = OBJ_TYPE_APPLET, .name = "", /* used for logging */ .fct = http_stats_io_handler, .release = NULL, }; /* * Local variables: * c-indent-level: 8 * c-basic-offset: 8 * End: */