Go to the documentation of this file.
108 #if XMALLOC_STATISTICS
109 static void info_get_mallstat(
int,
int,
int,
void *);
222 i ? (1 << (i - 1)) + 1 : 1,
224 stats.http_read_hist[i],
235 i ? (1 << (i - 1)) + 1 : 1,
237 stats.ftp_read_hist[i],
248 i ? (1 << (i - 1)) + 1 : 1,
250 stats.gopher_read_hist[i],
261 snprintf(buf, 256,
"%-13s %-13s %-12s %-12s",
278 strcat(buf,
"SPECIAL,");
281 strcat(buf,
"REVALIDATE_ALWAYS,");
284 strcat(buf,
"DELAY_SENDING,");
287 strcat(buf,
"RELEASE_REQUEST,");
290 strcat(buf,
"REFRESH_REQUEST,");
293 strcat(buf,
"REVALIDATE_STALE,");
296 strcat(buf,
"DISPATCHED,");
299 strcat(buf,
"PRIVATE,");
302 strcat(buf,
"FWD_HDR_WAIT,");
305 strcat(buf,
"NEGCACHED,");
308 strcat(buf,
"VALIDATED,");
311 strcat(buf,
"BAD_LENGTH,");
314 strcat(buf,
"ABORTED,");
316 if ((t = strrchr(buf,
',')))
364 size_t statCount = 0;
392 sentry->
lock(
"statObjects");
434 #if XMALLOC_STATISTICS
436 info_get_mallstat(
int size,
int number,
int oldnum,
void *data)
454 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
534 stats.up_time = runtime;
535 stats.cpu_time = cputime;
544 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
548 stats.ms_bytes_total = ms.bytes_total;
550 stats.ms_bytes_free = ms.bytes_free;
580 if (WIN32_run_mode == _WIN_SQUID_RUN_MODE_SERVICE) {
583 storeAppendPrintf(sentry,
"Service command line is: %s\n", WIN32_Service_Command_Line);
601 sentry->
append(
"\tNumber of clients accessing cache:\t(client_db off)\n", 52);
604 stats.client_http_requests);
607 stats.icp_pkts_recv);
610 stats.icp_pkts_sent);
613 stats.icp_replies_queued);
618 stats.htcp_pkts_recv);
621 stats.htcp_pkts_sent);
625 double fct =
stats.count > 1 ?
stats.count : 1.0;
627 stats.request_failure_ratio / fct);
629 storeAppendPrintf(sentry,
"\tAverage HTTP requests per minute since start:\t%.1f\n",
630 stats.avg_client_http_requests);
632 storeAppendPrintf(sentry,
"\tAverage ICP messages per minute since start:\t%.1f\n",
633 stats.avg_icp_messages);
636 stats.select_loops,
stats.avg_loop_time / fct);
640 storeAppendPrintf(sentry,
"\tHits as %% of all requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
641 stats.request_hit_ratio5 / fct,
642 stats.request_hit_ratio60 / fct);
644 storeAppendPrintf(sentry,
"\tHits as %% of bytes sent:\t5min: %3.1f%%, 60min: %3.1f%%\n",
645 stats.byte_hit_ratio5 / fct,
646 stats.byte_hit_ratio60 / fct);
648 storeAppendPrintf(sentry,
"\tMemory hits as %% of hit requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
649 stats.request_hit_mem_ratio5 / fct,
650 stats.request_hit_mem_ratio60 / fct);
652 storeAppendPrintf(sentry,
"\tDisk hits as %% of hit requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
653 stats.request_hit_disk_ratio5 / fct,
654 stats.request_hit_disk_ratio60 / fct);
657 stats.store.swap.size / 1024);
659 storeAppendPrintf(sentry,
"\tStorage Swap capacity:\t%4.1f%% used, %4.1f%% free\n",
664 stats.store.mem.size / 1024);
666 storeAppendPrintf(sentry,
"\tStorage Mem capacity:\t%4.1f%% used, %4.1f%% free\n",
671 stats.store.swap.meanObjectSize() / 1024);
674 stats.unlink_requests);
678 fct =
stats.count > 1 ?
stats.count * 1000.0 : 1000.0;
680 stats.http_requests5 / fct,
681 stats.http_requests60 / fct);
684 stats.cache_misses5 / fct,
685 stats.cache_misses60 / fct);
688 stats.cache_hits5 / fct,
689 stats.cache_hits60 / fct);
692 stats.near_hits5 / fct,
693 stats.near_hits60 / fct);
696 stats.not_modified_replies5 / fct,
697 stats.not_modified_replies60 / fct);
700 stats.dns_lookups5 / fct,
701 stats.dns_lookups60 / fct);
703 fct =
stats.count > 1 ?
stats.count * 1000000.0 : 1000000.0;
705 stats.icp_queries5 / fct,
706 stats.icp_queries60 / fct);
729 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
734 stats.ms_bytes_total / 1024);
737 stats.ms_bytes_free / 1024,
744 stats.total_accounted / 1024);
749 stats.gb_saved_count);
751 stats.gb_freed_count);
768 stats.store.swap.open_disk_fd);
772 stats.store.store_entry_count);
774 stats.store.mem_object_count);
776 stats.store.mem.count);
778 stats.store.swap.count);
784 #if XMALLOC_STATISTICS
788 storeAppendPrintf(sentry,
"%12s %15s %6s %12s\n",
"Alloc Size",
"Count",
"Delta",
"Alloc/sec");
789 malloc_statistics(info_get_mallstat, sentry);
799 double p = (i + 1) * 5 / 100.0;
827 double fct =
stats.count > 1 ?
stats.count * 1000.0 : 1000.0;
831 stats.http_requests5[i] / fct,
832 stats.http_requests60[i] / fct);
837 stats.cache_misses5[i] / fct,
838 stats.cache_misses60[i] / fct);
843 stats.cache_hits5[i] / fct,
844 stats.cache_hits60[i] / fct);
849 stats.near_hits5[i] / fct,
850 stats.near_hits60[i] / fct);
855 stats.not_modified_replies5[i] / fct,
856 stats.not_modified_replies60[i] / fct);
861 stats.dns_lookups5[i] / fct,
862 stats.dns_lookups60[i] / fct);
864 fct =
stats.count > 1 ?
stats.count * 1000000.0 : 1000000.0;
868 stats.icp_queries5[i] / fct,
869 stats.icp_queries60[i] / fct);
881 #define XAVG(X) (dt ? (double) (f->X - l->X) / dt : 0.0)
890 assert(minutes > 0 || hours > 0);
894 if (minutes > 0 && hours == 0) {
901 }
else if (minutes == 0 && hours > 0) {
909 debugs(18,
DBG_IMPORTANT,
"ERROR: statAvgDump: Invalid args, minutes=" << minutes <<
", hours=" << hours);
919 stats.client_http_requests =
XAVG(client_http.requests);
920 stats.client_http_hits =
XAVG(client_http.hits);
921 stats.client_http_errors =
XAVG(client_http.errors);
922 stats.client_http_kbytes_in =
XAVG(client_http.kbytes_in.kb);
923 stats.client_http_kbytes_out =
XAVG(client_http.kbytes_out.kb);
956 stats.icp_pkts_sent =
XAVG(icp.pkts_sent);
957 stats.icp_pkts_recv =
XAVG(icp.pkts_recv);
958 stats.icp_queries_sent =
XAVG(icp.queries_sent);
959 stats.icp_replies_sent =
XAVG(icp.replies_sent);
960 stats.icp_queries_recv =
XAVG(icp.queries_recv);
961 stats.icp_replies_recv =
XAVG(icp.replies_recv);
962 stats.icp_replies_queued =
XAVG(icp.replies_queued);
963 stats.icp_query_timeouts =
XAVG(icp.query_timeouts);
964 stats.icp_kbytes_sent =
XAVG(icp.kbytes_sent.kb);
965 stats.icp_kbytes_recv =
XAVG(icp.kbytes_recv.kb);
966 stats.icp_q_kbytes_sent =
XAVG(icp.q_kbytes_sent.kb);
967 stats.icp_r_kbytes_sent =
XAVG(icp.r_kbytes_sent.kb);
968 stats.icp_q_kbytes_recv =
XAVG(icp.q_kbytes_recv.kb);
969 stats.icp_r_kbytes_recv =
XAVG(icp.r_kbytes_recv.kb);
978 stats.unlink_requests =
XAVG(unlink.requests);
988 stats.swap_files_cleaned =
XAVG(swap.files_cleaned);
989 stats.aborted_requests =
XAVG(aborted_requests);
991 stats.hitValidationAttempts =
XAVG(hitValidation.attempts);
992 stats.hitValidationRefusalsDueToLocking =
XAVG(hitValidation.refusalsDueToLocking);
993 stats.hitValidationRefusalsDueToZeroSize =
XAVG(hitValidation.refusalsDueToZeroSize);
994 stats.hitValidationRefusalsDueToTimeLimit =
XAVG(hitValidation.refusalsDueToTimeLimit);
995 stats.hitValidationFailures =
XAVG(hitValidation.failures);
997 stats.syscalls_disk_opens =
XAVG(syscalls.disk.opens);
998 stats.syscalls_disk_closes =
XAVG(syscalls.disk.closes);
999 stats.syscalls_disk_reads =
XAVG(syscalls.disk.reads);
1000 stats.syscalls_disk_writes =
XAVG(syscalls.disk.writes);
1001 stats.syscalls_disk_seeks =
XAVG(syscalls.disk.seeks);
1002 stats.syscalls_disk_unlinks =
XAVG(syscalls.disk.unlinks);
1003 stats.syscalls_sock_accepts =
XAVG(syscalls.sock.accepts);
1004 stats.syscalls_sock_sockets =
XAVG(syscalls.sock.sockets);
1005 stats.syscalls_sock_connects =
XAVG(syscalls.sock.connects);
1006 stats.syscalls_sock_binds =
XAVG(syscalls.sock.binds);
1007 stats.syscalls_sock_closes =
XAVG(syscalls.sock.closes);
1008 stats.syscalls_sock_reads =
XAVG(syscalls.sock.reads);
1009 stats.syscalls_sock_writes =
XAVG(syscalls.sock.writes);
1010 stats.syscalls_sock_recvfroms =
XAVG(syscalls.sock.recvfroms);
1011 stats.syscalls_sock_sendtos =
XAVG(syscalls.sock.sendtos);
1012 stats.syscalls_selects =
XAVG(syscalls.selects);
1014 stats.cpu_time = ct;
1015 stats.wall_time = dt;
1022 (
int)
stats.sample_start_time.tv_sec,
1023 (
int)
stats.sample_start_time.tv_usec,
1026 (
int)
stats.sample_end_time.tv_sec,
1027 (
int)
stats.sample_end_time.tv_usec,
1031 stats.client_http_requests);
1033 stats.client_http_hits);
1035 stats.client_http_errors);
1037 stats.client_http_kbytes_in);
1039 stats.client_http_kbytes_out);
1041 double fct =
stats.count > 1 ?
stats.count : 1.0;
1043 stats.client_http_all_median_svc_time / fct);
1045 stats.client_http_miss_median_svc_time / fct);
1047 stats.client_http_nm_median_svc_time / fct);
1049 stats.client_http_nh_median_svc_time / fct);
1051 stats.client_http_hit_median_svc_time / fct);
1054 stats.server_all_requests);
1056 stats.server_all_errors);
1058 stats.server_all_kbytes_in);
1060 stats.server_all_kbytes_out);
1063 stats.server_http_requests);
1065 stats.server_http_errors);
1067 stats.server_http_kbytes_in);
1069 stats.server_http_kbytes_out);
1072 stats.server_ftp_requests);
1074 stats.server_ftp_errors);
1076 stats.server_ftp_kbytes_in);
1078 stats.server_ftp_kbytes_out);
1081 stats.server_other_requests);
1083 stats.server_other_errors);
1085 stats.server_other_kbytes_in);
1087 stats.server_other_kbytes_out);
1090 stats.icp_pkts_sent);
1092 stats.icp_pkts_recv);
1094 stats.icp_queries_sent);
1096 stats.icp_replies_sent);
1098 stats.icp_queries_recv);
1100 stats.icp_replies_recv);
1102 stats.icp_replies_queued);
1104 stats.icp_query_timeouts);
1106 stats.icp_kbytes_sent);
1108 stats.icp_kbytes_recv);
1110 stats.icp_q_kbytes_sent);
1112 stats.icp_r_kbytes_sent);
1114 stats.icp_q_kbytes_recv);
1116 stats.icp_r_kbytes_recv);
1118 stats.icp_query_median_svc_time / fct);
1120 stats.icp_reply_median_svc_time / fct);
1122 stats.dns_median_svc_time / fct);
1124 stats.unlink_requests);
1128 stats.select_loops);
1132 stats.average_select_fd_period / fct);
1134 stats.median_select_fds / fct);
1140 stats.swap_files_cleaned);
1142 stats.aborted_requests);
1145 stats.hitValidationAttempts);
1147 stats.hitValidationRefusalsDueToLocking);
1149 stats.hitValidationRefusalsDueToZeroSize);
1150 storeAppendPrintf(sentry,
"hit_validation.refusals.due_to_timeLimit = %f/sec\n",
1151 stats.hitValidationRefusalsDueToTimeLimit);
1153 stats.hitValidationFailures);
1157 #elif defined(USE_SELECT) || defined(USE_SELECT_WIN32)
1211 "Client-side Active Requests",
1215 "Active Cached Usernames",
1222 statGraphDump, 0, 1);
1233 C->client_http.allSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1234 C->client_http.missSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1235 C->client_http.nearMissSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1236 C->client_http.nearHitSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1237 C->client_http.hitSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1241 C->icp.querySvcTime.logInit(300, 0.0, 1000000.0 * 60.0);
1242 C->icp.replySvcTime.logInit(300, 0.0, 1000000.0 * 60.0);
1246 C->dns.svcTime.logInit(300, 0.0, 60000.0 * 10.0);
1254 C->select_fds_hist.enumInit(256);
1269 debugs(18, 5,
"statInit: Initializing...");
1316 debugs(18,
DBG_CRITICAL,
"WARNING: Median response time is " << i <<
" milliseconds");
1323 if (i > 0 && dt > 0.0) {
1333 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
1334 struct mstats ms = mstats();
1338 debugs(18,
DBG_CRITICAL,
"WARNING: Memory usage at " << ((
unsigned long int)(i >> 20)) <<
" MB");
1426 #if USE_CACHE_DIGESTS
1459 (
int)
stats.sample_time.tv_sec,
1460 (
int)
stats.sample_time.tv_usec,
1463 stats.client_http_requests);
1465 stats.client_http_hits);
1467 stats.client_http_errors);
1469 stats.client_http_kbytes_in);
1471 stats.client_http_kbytes_out);
1473 stats.client_http_hit_kbytes_out);
1476 stats.server_all_requests);
1478 stats.server_all_errors);
1480 stats.server_all_kbytes_in);
1482 stats.server_all_kbytes_out);
1485 stats.server_http_requests);
1487 stats.server_http_errors);
1489 stats.server_http_kbytes_in);
1491 stats.server_http_kbytes_out);
1494 stats.server_ftp_requests);
1496 stats.server_ftp_errors);
1498 stats.server_ftp_kbytes_in);
1500 stats.server_ftp_kbytes_out);
1503 stats.server_other_requests);
1505 stats.server_other_errors);
1507 stats.server_other_kbytes_in);
1509 stats.server_other_kbytes_out);
1512 stats.icp_pkts_sent);
1514 stats.icp_pkts_recv);
1516 stats.icp_queries_sent);
1518 stats.icp_replies_sent);
1520 stats.icp_queries_recv);
1522 stats.icp_replies_recv);
1524 stats.icp_query_timeouts);
1526 stats.icp_replies_queued);
1528 stats.icp_kbytes_sent);
1530 stats.icp_kbytes_recv);
1532 stats.icp_q_kbytes_sent);
1534 stats.icp_r_kbytes_sent);
1536 stats.icp_q_kbytes_recv);
1538 stats.icp_r_kbytes_recv);
1540 #if USE_CACHE_DIGESTS
1543 stats.icp_times_used);
1545 stats.cd_times_used);
1547 stats.cd_msgs_sent);
1549 stats.cd_msgs_recv);
1553 stats.cd_local_memory);
1555 stats.cd_kbytes_sent);
1557 stats.cd_kbytes_recv);
1561 stats.unlink_requests);
1565 stats.select_loops);
1575 stats.swap_files_cleaned);
1577 stats.aborted_requests);
1580 stats.hitValidationAttempts);
1582 stats.hitValidationRefusalsDueToLocking);
1584 stats.hitValidationRefusalsDueToZeroSize);
1586 stats.hitValidationRefusalsDueToTimeLimit);
1588 stats.hitValidationFailures);
1605 #if USE_CACHE_DIGESTS
1611 static const SBuf label(
"all peers");
1634 storeAppendPrintf(sentry,
"peer digests are disabled; no stats is available.\n");
1703 debugs(49, 5,
"statPctileSvc: unknown type.");
1766 #if USE_CACHE_DIGESTS
1774 #if USE_CACHE_DIGESTS
1806 const char *p =
NULL;
1813 const int fd =
conn->clientConnection->fd;
1818 conn->inBuf.rawContent(), (
long int)
conn->inBuf.length(), (
long int)
conn->inBuf.spaceSize());
1834 (
long int) http->
al->cache.start_time.tv_sec,
1835 (
int) http->
al->cache.start_time.tv_usec,
1846 if (!p &&
conn !=
NULL &&
conn->clientConnection->rfc931[0])
1847 p =
conn->clientConnection->rfc931;
1872 #define GRAPH_PER_MIN(Y) \
1873 for (i=0;i<(N_COUNT_HIST-2);++i) { \
1874 dt = tvSubDsec(CountHist[i+1].timestamp, CountHist[i].timestamp); \
1877 storeAppendPrintf(e, "%lu,%0.2f:", \
1878 CountHist[i].timestamp.tv_sec, \
1879 ((CountHist[i].Y - CountHist[i+1].Y) / dt)); \
1882 #define GRAPH_PER_HOUR(Y) \
1883 for (i=0;i<(N_COUNT_HOUR_HIST-2);++i) { \
1884 dt = tvSubDsec(CountHourHist[i+1].timestamp, CountHourHist[i].timestamp); \
1887 storeAppendPrintf(e, "%lu,%0.2f:", \
1888 CountHourHist[i].timestamp.tv_sec, \
1889 ((CountHourHist[i].Y - CountHourHist[i+1].Y) / dt)); \
1892 #define GRAPH_TITLE(X,Y) storeAppendPrintf(e,"%s\t%s\t",X,Y);
1893 #define GRAPH_END storeAppendPrintf(e,"\n");
1895 #define GENGRAPH(X,Y,Z) \
1907 GENGRAPH(client_http.requests,
"client_http.requests",
"Client HTTP requests/sec");
1908 GENGRAPH(client_http.hits,
"client_http.hits",
"Client HTTP hits/sec");
1909 GENGRAPH(client_http.errors,
"client_http.errors",
"Client HTTP errors/sec");
1910 GENGRAPH(client_http.kbytes_in.kb,
"client_http.kbytes_in",
"Client HTTP kbytes_in/sec");
1911 GENGRAPH(client_http.kbytes_out.kb,
"client_http.kbytes_out",
"Client HTTP kbytes_out/sec");
1915 GENGRAPH(
server.all.requests,
"server.all.requests",
"Server requests/sec");
1916 GENGRAPH(
server.all.errors,
"server.all.errors",
"Server errors/sec");
1917 GENGRAPH(
server.all.kbytes_in.kb,
"server.all.kbytes_in",
"Server total kbytes_in/sec");
1918 GENGRAPH(
server.all.kbytes_out.kb,
"server.all.kbytes_out",
"Server total kbytes_out/sec");
1920 GENGRAPH(
server.http.requests,
"server.http.requests",
"Server HTTP requests/sec");
1921 GENGRAPH(
server.http.errors,
"server.http.errors",
"Server HTTP errors/sec");
1922 GENGRAPH(
server.http.kbytes_in.kb,
"server.http.kbytes_in",
"Server HTTP kbytes_in/sec");
1923 GENGRAPH(
server.http.kbytes_out.kb,
"server.http.kbytes_out",
"Server HTTP kbytes_out/sec");
1925 GENGRAPH(
server.ftp.requests,
"server.ftp.requests",
"Server FTP requests/sec");
1926 GENGRAPH(
server.ftp.errors,
"server.ftp.errors",
"Server FTP errors/sec");
1927 GENGRAPH(
server.ftp.kbytes_in.kb,
"server.ftp.kbytes_in",
"Server FTP kbytes_in/sec");
1928 GENGRAPH(
server.ftp.kbytes_out.kb,
"server.ftp.kbytes_out",
"Server FTP kbytes_out/sec");
1930 GENGRAPH(
server.other.requests,
"server.other.requests",
"Server other requests/sec");
1931 GENGRAPH(
server.other.errors,
"server.other.errors",
"Server other errors/sec");
1932 GENGRAPH(
server.other.kbytes_in.kb,
"server.other.kbytes_in",
"Server other kbytes_in/sec");
1933 GENGRAPH(
server.other.kbytes_out.kb,
"server.other.kbytes_out",
"Server other kbytes_out/sec");
1935 GENGRAPH(icp.pkts_sent,
"icp.pkts_sent",
"ICP packets sent/sec");
1936 GENGRAPH(icp.pkts_recv,
"icp.pkts_recv",
"ICP packets received/sec");
1937 GENGRAPH(icp.kbytes_sent.kb,
"icp.kbytes_sent",
"ICP kbytes_sent/sec");
1938 GENGRAPH(icp.kbytes_recv.kb,
"icp.kbytes_recv",
"ICP kbytes_received/sec");
1943 GENGRAPH(unlink.requests,
"unlink.requests",
"Cache File unlink requests/sec");
1944 GENGRAPH(page_faults,
"page_faults",
"System Page Faults/sec");
1945 GENGRAPH(select_loops,
"select_loops",
"System Select Loop calls/sec");
1946 GENGRAPH(cputime,
"cputime",
"CPU utilisation");
double current_dtime
the current UNIX time in seconds (with microsecond precision)
double tvSubDsec(struct timeval t1, struct timeval t2)
static DelayId DelayClient(ClientHttpRequest *, HttpReply *reply=nullptr)
struct timeval squid_start
class Ping::pingStats_ stats
static Pointer Create(const CommandPointer &cmd)
static int statObjectsOpenfdFilter(const StoreEntry *e)
void appendf(const char *fmt,...) PRINTF_FORMAT_ARG2
Append operation with printf-style arguments.
static OBJH statClientRequests
static const int histSize
uint64_t refusalsDueToZeroSize
uint64_t refusalsDueToLocking
double statByteHitRatio(int minutes)
StatCounters CountHist[N_COUNT_HIST]
struct StatCounters::@137 hitValidation
#define LOCAL_ARRAY(type, name, size)
ByteCounter r_kbytes_recv
struct StatCounters::@128::@138 ftp
ByteCounter hit_kbytes_out
static void statCountersInitSpecial(StatCounters *C)
CacheDigestGuessStats guess
ConnStateData * getConn() const
struct StatCounters::@133 cd
void storeAppendPrintf(StoreEntry *e, const char *fmt,...)
void lock(const char *context)
store size histograms of network read() from peer server
static void DumpStats(StoreEntry *)
#define CBDATA_CLASS(type)
void init(mb_size_t szInit, mb_size_t szMax)
store service times for 5 and 60 min
StoreIOState::Pointer sio
void DumpInfo(Mgr::InfoActionData &stats, StoreEntry *sentry)
int memPoolGetGlobalStats(MemPoolGlobalStats *stats)
double request_failure_ratio
void DumpCountersStats(Mgr::CountersActionData &stats, StoreEntry *sentry)
Auth::UserRequest::Pointer auth_user_request
const char * pingStatusStr[]
CachePeer * getNextPeer(CachePeer *p)
struct ClientHttpRequest::Out out
virtual void append(const char *c, int sz)
struct StatCounters::@130 htcp
void cacheDigestGuessStatsReport(const CacheDigestGuessStats *stats, StoreEntry *sentry, const SBuf &label)
bool IsConnOpen(const Comm::ConnectionPointer &conn)
const char * sslGetUserEmail(SSL *ssl)
int locks() const
returns a local concurrent use counter, for debugging
struct IoStats::@78 Gopher
struct StatCounters::@131 unlink
static double statPctileSvc(double, int, int)
int stat5minClientRequests(void)
double statHistDeltaMedian(const StatHist &A, const StatHist &B)
static void statCountersInit(StatCounters *C)
struct StatCounters::@128 server
static void statAvgDump(StoreEntry *, int minutes, int hours)
const char * swapStatusStr[]
void peerDigestStatsReport(const PeerDigest *pd, StoreEntry *e)
static Pointer Create(const CommandPointer &cmd)
#define MAX_IPSTRLEN
Length of buffer that needs to be allocated to old a null-terminated IP-string.
static void statStoreEntry(MemBuf *mb, StoreEntry *e)
const char * version_string
const char * FormatRfc1123(time_t)
double doublePercent(const double, const double)
static StatCounters CountHourHist[N_COUNT_HOUR_HIST]
static Pointer Create5min(const CommandPointer &cmd)
struct timeval current_time
the current UNIX time in timeval {seconds, microseconds} format
static void CredentialsCacheStats(StoreEntry *output)
#define SQUIDSBUFPRINT(s)
store traffic and resource counters
struct StatCounters::@127 client_http
void dump(StoreEntry *sentry, StatHistBinDumper *bd) const
dlink_list ClientActiveRequests
#define EBIT_TEST(flag, bit)
@ RELEASE_REQUEST
prohibits making the key public
unsigned int mem_pool_free_calls
ping_status_t ping_status
static OBJH statCountersHistograms
int unlock(const char *context)
CachePeer * getFirstPeer(void)
const char * storeEntryFlags(const StoreEntry *entry)
store_status_t store_status
double statHistDeltaPctile(const StatHist &A, const StatHist &B, double pctile)
static Pointer Create(const CommandPointer &cmd)
int conn
the current server connection FD
char const * termedBuf() const
virtual void getStats(StoreInfoStats &stats) const override
collect statistics
void DumpAvgStat(Mgr::IntervalActionData &stats, StoreEntry *sentry)
int memPoolsTotalAllocated(void)
unsigned int mem_pool_alloc_calls
void GetCountersStats(Mgr::CountersActionData &stats)
virtual bool isDone() const =0
virtual StoreEntry * currentItem()=0
static void statObjectsStart(StoreEntry *sentry, STOBJFLT *filter)
static OBJH statCountersDump
int STOBJFLT(const StoreEntry *)
#define CBDATA_CLASS_INIT(type)
static OBJH statDigestBlob
uint64_t size
Response header and body bytes written to the client connection.
static void statRegisterWithCacheManager(void)
void storeDigestReport(StoreEntry *e)
const LogTags & loggingTags() const
the processing tags associated with this request transaction.
swap_status_t swap_status
struct SquidConfig::@120 warnings
void DumpServiceTimesStats(Mgr::ServiceTimesActionData &stats, StoreEntry *sentry)
void DumpIoStats(Mgr::IoActionData &stats, StoreEntry *sentry)
static OBJH stat_vmobjects_get
StoreSearchPointer theSearch
struct StatCounters::@129 icp
unsigned long int select_loops
bool checkDeferRead(int fd) const
struct StatCounters::@128::@138 http
uint64_t refusalsDueToTimeLimit
struct SquidConfig::@110 onoff
ByteCounter q_kbytes_sent
void GetIoStats(Mgr::IoActionData &stats)
static char server[MAXLINE]
void GetAvgStat(Mgr::IntervalActionData &stats, int minutes, int hours)
const char * memStatusStr[]
void DumpMallocStatistics(StoreEntry *sentry)
char const * username() const
struct StatCounters::@128::@138 all
double statRequestHitMemoryRatio(int minutes)
static Pointer Create(const CommandPointer &cmd)
ByteCounter q_kbytes_recv
size_t req_sz
raw request size on input, not current request size
CacheDigest * store_digest
StatCounters * snmpStatGet(int minutes)
const AccessLogEntry::Pointer al
access.log entry
SQUIDCEXTERN double xdiv(double nom, double denom)
struct StatCounters::@136 swap
virtual void append(char const *, int)
Appends a c-string to existing packed data.
double statRequestHitRatio(int minutes)
#define N_COUNT_HOUR_HIST
static OBJH statPeerSelect
StoreEntry * storeEntry() const
@ ENTRY_REVALIDATE_ALWAYS
const char * storeStatusStr[]
static int statObjectsVmFilter(const StoreEntry *e)
void RegisterAction(char const *action, char const *desc, OBJH *handler, int pw_req_flag, int atomic)
static int NCountHourHist
static Pointer Create60min(const CommandPointer &cmd)
static void statAvgTick(void *notused)
void GetServiceTimesStats(Mgr::ServiceTimesActionData &stats)
static OBJH statOpenfdObj
void statFreeMemory(void)
double statRequestHitDiskRatio(int minutes)
SQUIDCEXTERN int xpercentInt(double part, double whole)
struct StatCounters::@132 dns
#define debugs(SECTION, LEVEL, CONTENT)
void stat(MemBuf *mb) const
const char * describeTimestamps() const
int CacheDigestHashFuncCount
void GetInfo(Mgr::InfoActionData &stats)
int statMemoryAccounted(void)
static OBJH stat_objects_get
const char * getMD5Text() const
void eventAdd(const char *name, EVH *func, void *arg, double when, int weight, bool cbdata)
struct StatCounters::@128::@138 other
static const char * describeStatuses(const StoreEntry *)
int storePendingNClients(const StoreEntry *e)
HttpRequest *const request
struct SquidConfig::@108 Store
static double statCPUUsage(int minutes)
ByteCounter r_kbytes_sent
static OBJH statUtilization
sfileno swap_filen
unique ID inside a cache_dir for swapped out entries; -1 for others
Controller & Root()
safely access controller singleton