stat.cc
Go to the documentation of this file.
1/*
2 * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
3 *
4 * Squid software is distributed under GPLv2+ license and includes
5 * contributions from numerous individuals and organizations.
6 * Please see the COPYING and CONTRIBUTORS files for details.
7 */
8
9/* DEBUG: section 18 Cache Manager Statistics */
10
11#include "squid.h"
12#include "AccessLogEntry.h"
13#include "CacheDigest.h"
14#include "CachePeer.h"
15#include "client_side.h"
16#include "client_side_request.h"
17#include "comm/Connection.h"
18#include "comm/Loops.h"
19#include "event.h"
20#include "fde.h"
21#include "format/Token.h"
22#include "globals.h"
23#include "http/Stream.h"
24#include "HttpRequest.h"
25#include "IoStats.h"
26#include "mem/Pool.h"
27#include "mem_node.h"
28#include "MemBuf.h"
29#include "MemObject.h"
30#include "mgr/CountersAction.h"
31#include "mgr/FunAction.h"
32#include "mgr/InfoAction.h"
33#include "mgr/IntervalAction.h"
34#include "mgr/IoAction.h"
35#include "mgr/Registration.h"
37#include "neighbors.h"
38#include "PeerDigest.h"
39#include "SquidConfig.h"
40#include "SquidMath.h"
41#include "stat.h"
42#include "StatCounters.h"
43#include "Store.h"
44#include "store_digest.h"
45#include "StoreClient.h"
46#include "tools.h"
47#if USE_AUTH
48#include "auth/UserRequest.h"
49#endif
50#if USE_DELAY_POOLS
51#include "DelayId.h"
52#endif
53#if USE_OPENSSL
54#include "ssl/support.h"
55#endif
56
57/* these are included because they expose stats calls */
58/* TODO: provide a self registration mechanism for those classes
59 * to use during static construction
60 */
61#include "comm.h"
62#include "StoreSearch.h"
63
64typedef int STOBJFLT(const StoreEntry *);
65
67{
69
70public:
74};
75
76/* LOCALS */
77static const char *describeStatuses(const StoreEntry *);
78static void statAvgTick(void *notused);
79static void statAvgDump(StoreEntry *, int minutes, int hours);
80#if STAT_GRAPHS
81static void statGraphDump(StoreEntry *);
82#endif
83static double statPctileSvc(double, int, int);
84static void statStoreEntry(MemBuf * mb, StoreEntry * e);
85static double statCPUUsage(int minutes);
96void GetAvgStat(Mgr::IntervalActionData& stats, int minutes, int hours);
100void DumpMallocStatistics(StoreEntry* sentry);
107
108#if XMALLOC_STATISTICS
109static void info_get_mallstat(int, int, int, void *);
110static double xm_time;
111static double xm_deltat;
112#endif
113
115static int NCountHist = 0;
117static int NCountHourHist = 0;
119
120extern unsigned int mem_pool_alloc_calls;
121extern unsigned int mem_pool_free_calls;
122
123static void
125{
126 storeAppendPrintf(e, "Cache Utilisation:\n");
127 storeAppendPrintf(e, "\n");
128 storeAppendPrintf(e, "Last 5 minutes:\n");
129
130 if (NCountHist >= 5)
131 statAvgDump(e, 5, 0);
132 else
133 storeAppendPrintf(e, "(no values recorded yet)\n");
134
135 storeAppendPrintf(e, "\n");
136
137 storeAppendPrintf(e, "Last 15 minutes:\n");
138
139 if (NCountHist >= 15)
140 statAvgDump(e, 15, 0);
141 else
142 storeAppendPrintf(e, "(no values recorded yet)\n");
143
144 storeAppendPrintf(e, "\n");
145
146 storeAppendPrintf(e, "Last hour:\n");
147
148 if (NCountHist >= 60)
149 statAvgDump(e, 60, 0);
150 else
151 storeAppendPrintf(e, "(no values recorded yet)\n");
152
153 storeAppendPrintf(e, "\n");
154
155 storeAppendPrintf(e, "Last 8 hours:\n");
156
157 if (NCountHourHist >= 8)
158 statAvgDump(e, 0, 8);
159 else
160 storeAppendPrintf(e, "(no values recorded yet)\n");
161
162 storeAppendPrintf(e, "\n");
163
164 storeAppendPrintf(e, "Last day:\n");
165
166 if (NCountHourHist >= 24)
167 statAvgDump(e, 0, 24);
168 else
169 storeAppendPrintf(e, "(no values recorded yet)\n");
170
171 storeAppendPrintf(e, "\n");
172
173 storeAppendPrintf(e, "Last 3 days:\n");
174
175 if (NCountHourHist >= 72)
176 statAvgDump(e, 0, 72);
177 else
178 storeAppendPrintf(e, "(no values recorded yet)\n");
179
180 storeAppendPrintf(e, "\n");
181
182 storeAppendPrintf(e, "Totals since cache startup:\n");
183
185}
186
187void
189{
190 int i;
191
192 stats.http_reads = IOStats.Http.reads;
193
194 for (i = 0; i < IoStats::histSize; ++i) {
195 stats.http_read_hist[i] = IOStats.Http.read_hist[i];
196 }
197
198 stats.ftp_reads = IOStats.Ftp.reads;
199
200 for (i = 0; i < IoStats::histSize; ++i) {
201 stats.ftp_read_hist[i] = IOStats.Ftp.read_hist[i];
202 }
203}
204
205void
207{
208 int i;
209
210 storeAppendPrintf(sentry, "HTTP I/O\n");
211 storeAppendPrintf(sentry, "number of reads: %.0f\n", stats.http_reads);
212 storeAppendPrintf(sentry, "Read Histogram:\n");
213
214 for (i = 0; i < IoStats::histSize; ++i) {
215 storeAppendPrintf(sentry, "%5d-%5d: %9.0f %2.0f%%\n",
216 i ? (1 << (i - 1)) + 1 : 1,
217 1 << i,
218 stats.http_read_hist[i],
219 Math::doublePercent(stats.http_read_hist[i], stats.http_reads));
220 }
221
222 storeAppendPrintf(sentry, "\n");
223 storeAppendPrintf(sentry, "FTP I/O\n");
224 storeAppendPrintf(sentry, "number of reads: %.0f\n", stats.ftp_reads);
225 storeAppendPrintf(sentry, "Read Histogram:\n");
226
227 for (i = 0; i < IoStats::histSize; ++i) {
228 storeAppendPrintf(sentry, "%5d-%5d: %9.0f %2.0f%%\n",
229 i ? (1 << (i - 1)) + 1 : 1,
230 1 << i,
231 stats.ftp_read_hist[i],
232 Math::doublePercent(stats.ftp_read_hist[i], stats.ftp_reads));
233 }
234
235 storeAppendPrintf(sentry, "\n");
236}
237
238static const char *
240{
241 LOCAL_ARRAY(char, buf, 256);
242 snprintf(buf, 256, "%-13s %-13s %-12s %-12s",
244 memStatusStr[entry->mem_status],
246 pingStatusStr[entry->ping_status]);
247 return buf;
248}
249
250const char *
252{
253 LOCAL_ARRAY(char, buf, 256);
254 int flags = (int) entry->flags;
255 char *t;
256 buf[0] = '\0';
257
258 if (EBIT_TEST(flags, ENTRY_SPECIAL))
259 strcat(buf, "SPECIAL,");
260
262 strcat(buf, "REVALIDATE_ALWAYS,");
263
264 if (EBIT_TEST(flags, DELAY_SENDING))
265 strcat(buf, "DELAY_SENDING,");
266
267 if (EBIT_TEST(flags, RELEASE_REQUEST))
268 strcat(buf, "RELEASE_REQUEST,");
269
270 if (EBIT_TEST(flags, REFRESH_REQUEST))
271 strcat(buf, "REFRESH_REQUEST,");
272
274 strcat(buf, "REVALIDATE_STALE,");
275
276 if (EBIT_TEST(flags, ENTRY_DISPATCHED))
277 strcat(buf, "DISPATCHED,");
278
279 if (EBIT_TEST(flags, KEY_PRIVATE))
280 strcat(buf, "PRIVATE,");
281
282 if (EBIT_TEST(flags, ENTRY_FWD_HDR_WAIT))
283 strcat(buf, "FWD_HDR_WAIT,");
284
285 if (EBIT_TEST(flags, ENTRY_NEGCACHED))
286 strcat(buf, "NEGCACHED,");
287
288 if (EBIT_TEST(flags, ENTRY_VALIDATED))
289 strcat(buf, "VALIDATED,");
290
291 if (EBIT_TEST(flags, ENTRY_BAD_LENGTH))
292 strcat(buf, "BAD_LENGTH,");
293
294 if (EBIT_TEST(flags, ENTRY_ABORTED))
295 strcat(buf, "ABORTED,");
296
297 if ((t = strrchr(buf, ',')))
298 *t = '\0';
299
300 return buf;
301}
302
303static void
305{
306 MemObject *mem = e->mem_obj;
307 mb->appendf("KEY %s\n", e->getMD5Text());
308 mb->appendf("\t%s\n", describeStatuses(e));
309 mb->appendf("\t%s\n", storeEntryFlags(e));
310 mb->appendf("\t%s\n", e->describeTimestamps());
311 mb->appendf("\t%d locks, %d clients, %d refs\n", (int) e->locks(), storePendingNClients(e), (int) e->refcount);
312 mb->appendf("\tSwap Dir %d, File %#08X\n", e->swap_dirn, e->swap_filen);
313
314 if (mem != nullptr)
315 mem->stat (mb);
316
317 mb->append("\n", 1);
318}
319
320/* process objects list */
321static void
322statObjects(void *data)
323{
324 StatObjectsState *state = static_cast<StatObjectsState *>(data);
325 StoreEntry *e;
326
327 if (state->theSearch->isDone()) {
328 if (UsingSmp())
329 storeAppendPrintf(state->sentry, "} by kid%d\n\n", KidIdentifier);
330 state->sentry->complete();
331 state->sentry->unlock("statObjects+isDone");
332 delete state;
333 return;
334 } else if (EBIT_TEST(state->sentry->flags, ENTRY_ABORTED)) {
335 state->sentry->unlock("statObjects+aborted");
336 delete state;
337 return;
338 } else if (state->sentry->checkDeferRead(-1)) {
339 state->sentry->flush();
340 eventAdd("statObjects", statObjects, state, 0.1, 1);
341 return;
342 }
343
344 state->sentry->buffer();
345 size_t statCount = 0;
346 MemBuf mb;
347 mb.init();
348
349 while (statCount++ < static_cast<size_t>(Config.Store.objectsPerBucket) && state->
350 theSearch->next()) {
351 e = state->theSearch->currentItem();
352
353 if (state->filter && 0 == state->filter(e))
354 continue;
355
356 statStoreEntry(&mb, e);
357 }
358
359 if (mb.size)
360 state->sentry->append(mb.buf, mb.size);
361 mb.clean();
362
363 eventAdd("statObjects", statObjects, state, 0.0, 1);
364}
365
366static void
368{
370 state->sentry = sentry;
371 state->filter = filter;
372
373 sentry->lock("statObjects");
374 state->theSearch = Store::Root().search();
375
376 eventAdd("statObjects", statObjects, state, 0.0, 1);
377}
378
379static void
381{
382 statObjectsStart(sentry, nullptr);
383}
384
385static int
387{
388 return e->mem_obj ? 1 : 0;
389}
390
391static void
393{
395}
396
397static int
399{
400 if (e->mem_obj == nullptr)
401 return 0;
402
403 if (e->mem_obj->swapout.sio == nullptr)
404 return 0;
405
406 return 1;
407}
408
409static void
411{
413}
414
415#if XMALLOC_STATISTICS
416static void
417info_get_mallstat(int size, int number, int oldnum, void *data)
418{
419 StoreEntry *sentry = (StoreEntry *)data;
420
421// format: "%12s %15s %6s %12s\n","Alloc Size","Count","Delta","Alloc/sec"
422 if (number > 0)
423 storeAppendPrintf(sentry, "%12d %15d %6d %.1f\n", size, number, number - oldnum, xdiv((number - oldnum), xm_deltat));
424}
425
426#endif
427
428void
430{
431
432 struct rusage rusage;
433 double cputime;
434 double runtime;
435#if HAVE_MSTATS && HAVE_GNUMALLOC_H
436 struct mstats ms;
437#endif
438
440
441 if (runtime == 0.0)
442 runtime = 1.0;
443
444 stats.squid_start = squid_start;
445
446 stats.current_time = current_time;
447
448 stats.client_http_clients = statCounter.client_http.clients;
449
450 stats.client_http_requests = statCounter.client_http.requests;
451
452 stats.icp_pkts_recv = statCounter.icp.pkts_recv;
453
454 stats.icp_pkts_sent = statCounter.icp.pkts_sent;
455
456 stats.icp_replies_queued = statCounter.icp.replies_queued;
457
458#if USE_HTCP
459
460 stats.htcp_pkts_recv = statCounter.htcp.pkts_recv;
461
462 stats.htcp_pkts_sent = statCounter.htcp.pkts_sent;
463
464#endif
465
466 stats.request_failure_ratio = request_failure_ratio;
467
468 stats.avg_client_http_requests = statCounter.client_http.requests / (runtime / 60.0);
469
470 stats.avg_icp_messages = (statCounter.icp.pkts_sent + statCounter.icp.pkts_recv) / (runtime / 60.0);
471
472 stats.select_loops = statCounter.select_loops;
473 stats.avg_loop_time = 1000.0 * runtime / statCounter.select_loops;
474
475 stats.request_hit_ratio5 = statRequestHitRatio(5);
476 stats.request_hit_ratio60 = statRequestHitRatio(60);
477
478 stats.byte_hit_ratio5 = statByteHitRatio(5);
479 stats.byte_hit_ratio60 = statByteHitRatio(60);
480
481 stats.request_hit_mem_ratio5 = statRequestHitMemoryRatio(5);
482 stats.request_hit_mem_ratio60 = statRequestHitMemoryRatio(60);
483
484 stats.request_hit_disk_ratio5 = statRequestHitDiskRatio(5);
485 stats.request_hit_disk_ratio60 = statRequestHitDiskRatio(60);
486
487 Store::Root().getStats(stats.store);
488
489 stats.unlink_requests = statCounter.unlink.requests;
490
491 stats.http_requests5 = statPctileSvc(0.5, 5, PCTILE_HTTP);
492 stats.http_requests60 = statPctileSvc(0.5, 60, PCTILE_HTTP);
493
494 stats.cache_misses5 = statPctileSvc(0.5, 5, PCTILE_MISS);
495 stats.cache_misses60 = statPctileSvc(0.5, 60, PCTILE_MISS);
496
497 stats.cache_hits5 = statPctileSvc(0.5, 5, PCTILE_HIT);
498 stats.cache_hits60 = statPctileSvc(0.5, 60, PCTILE_HIT);
499
500 stats.near_hits5 = statPctileSvc(0.5, 5, PCTILE_NH);
501 stats.near_hits60 = statPctileSvc(0.5, 60, PCTILE_NH);
502
503 stats.not_modified_replies5 = statPctileSvc(0.5, 5, PCTILE_NM);
504 stats.not_modified_replies60 = statPctileSvc(0.5, 60, PCTILE_NM);
505
506 stats.dns_lookups5 = statPctileSvc(0.5, 5, PCTILE_DNS);
507 stats.dns_lookups60 = statPctileSvc(0.5, 60, PCTILE_DNS);
508
509 stats.icp_queries5 = statPctileSvc(0.5, 5, PCTILE_ICP_QUERY);
510 stats.icp_queries60 = statPctileSvc(0.5, 60, PCTILE_ICP_QUERY);
511
513 cputime = rusage_cputime(&rusage);
514
515 stats.up_time = runtime;
516 stats.cpu_time = cputime;
517 stats.cpu_usage = Math::doublePercent(cputime, runtime);
518 stats.cpu_usage5 = statCPUUsage(5);
519 stats.cpu_usage60 = statCPUUsage(60);
520
521 stats.maxrss = rusage_maxrss(&rusage);
522
523 stats.page_faults = rusage_pagefaults(&rusage);
524
525#if HAVE_MSTATS && HAVE_GNUMALLOC_H
526
527 ms = mstats();
528
529 stats.ms_bytes_total = ms.bytes_total;
530
531 stats.ms_bytes_free = ms.bytes_free;
532
533#endif
534
535 stats.total_accounted = statMemoryAccounted();
536
537 {
538 MemPoolGlobalStats mp_stats;
539 memPoolGetGlobalStats(&mp_stats);
540 stats.gb_saved_count = mp_stats.TheMeter->gb_saved.count;
541 stats.gb_freed_count = mp_stats.TheMeter->gb_freed.count;
542 }
543
544 stats.max_fd = Squid_MaxFD;
545 stats.biggest_fd = Biggest_FD;
546 stats.number_fd = Number_FD;
547 stats.opening_fd = Opening_FD;
548 stats.num_fd_free = fdNFree();
549 stats.reserved_fd = RESERVED_FD;
550}
551
552void
554{
555 storeAppendPrintf(sentry, "Squid Object Cache: Version %s\n",
557
558 storeAppendPrintf(sentry, "Build Info: " SQUID_BUILD_INFO "\n");
559
560#if _SQUID_WINDOWS_
561 if (WIN32_run_mode == _WIN_SQUID_RUN_MODE_SERVICE) {
562 storeAppendPrintf(sentry,"\nRunning as " SQUIDSBUFPH " Windows System Service on %s\n",
563 SQUIDSBUFPRINT(service_name), WIN32_OS_string);
564 storeAppendPrintf(sentry,"Service command line is: %s\n", WIN32_Service_Command_Line);
565 } else
566 storeAppendPrintf(sentry,"Running on %s\n",WIN32_OS_string);
567#else
568 storeAppendPrintf(sentry,"Service Name: " SQUIDSBUFPH "\n", SQUIDSBUFPRINT(service_name));
569#endif
570
571 storeAppendPrintf(sentry, "Start Time:\t%s\n",
572 Time::FormatRfc1123(stats.squid_start.tv_sec));
573
574 storeAppendPrintf(sentry, "Current Time:\t%s\n",
575 Time::FormatRfc1123(stats.current_time.tv_sec));
576
577 storeAppendPrintf(sentry, "Connection information for %s:\n",APP_SHORTNAME);
578
580 storeAppendPrintf(sentry, "\tNumber of clients accessing cache:\t%.0f\n", stats.client_http_clients);
581 else
582 sentry->append("\tNumber of clients accessing cache:\t(client_db off)\n", 52);
583
584 storeAppendPrintf(sentry, "\tNumber of HTTP requests received:\t%.0f\n",
585 stats.client_http_requests);
586
587 storeAppendPrintf(sentry, "\tNumber of ICP messages received:\t%.0f\n",
588 stats.icp_pkts_recv);
589
590 storeAppendPrintf(sentry, "\tNumber of ICP messages sent:\t%.0f\n",
591 stats.icp_pkts_sent);
592
593 storeAppendPrintf(sentry, "\tNumber of queued ICP replies:\t%.0f\n",
594 stats.icp_replies_queued);
595
596#if USE_HTCP
597
598 storeAppendPrintf(sentry, "\tNumber of HTCP messages received:\t%.0f\n",
599 stats.htcp_pkts_recv);
600
601 storeAppendPrintf(sentry, "\tNumber of HTCP messages sent:\t%.0f\n",
602 stats.htcp_pkts_sent);
603
604#endif
605
606 double fct = stats.count > 1 ? stats.count : 1.0;
607 storeAppendPrintf(sentry, "\tRequest failure ratio:\t%5.2f\n",
608 stats.request_failure_ratio / fct);
609
610 storeAppendPrintf(sentry, "\tAverage HTTP requests per minute since start:\t%.1f\n",
611 stats.avg_client_http_requests);
612
613 storeAppendPrintf(sentry, "\tAverage ICP messages per minute since start:\t%.1f\n",
614 stats.avg_icp_messages);
615
616 storeAppendPrintf(sentry, "\tSelect loop called: %.0f times, %0.3f ms avg\n",
617 stats.select_loops, stats.avg_loop_time / fct);
618
619 storeAppendPrintf(sentry, "Cache information for %s:\n",APP_SHORTNAME);
620
621 storeAppendPrintf(sentry, "\tHits as %% of all requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
622 stats.request_hit_ratio5 / fct,
623 stats.request_hit_ratio60 / fct);
624
625 storeAppendPrintf(sentry, "\tHits as %% of bytes sent:\t5min: %3.1f%%, 60min: %3.1f%%\n",
626 stats.byte_hit_ratio5 / fct,
627 stats.byte_hit_ratio60 / fct);
628
629 storeAppendPrintf(sentry, "\tMemory hits as %% of hit requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
630 stats.request_hit_mem_ratio5 / fct,
631 stats.request_hit_mem_ratio60 / fct);
632
633 storeAppendPrintf(sentry, "\tDisk hits as %% of hit requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
634 stats.request_hit_disk_ratio5 / fct,
635 stats.request_hit_disk_ratio60 / fct);
636
637 storeAppendPrintf(sentry, "\tStorage Swap size:\t%.0f KB\n",
638 stats.store.swap.size / 1024);
639
640 storeAppendPrintf(sentry, "\tStorage Swap capacity:\t%4.1f%% used, %4.1f%% free\n",
641 Math::doublePercent(stats.store.swap.size, stats.store.swap.capacity),
642 Math::doublePercent(stats.store.swap.available(), stats.store.swap.capacity));
643
644 storeAppendPrintf(sentry, "\tStorage Mem size:\t%.0f KB\n",
645 stats.store.mem.size / 1024);
646
647 storeAppendPrintf(sentry, "\tStorage Mem capacity:\t%4.1f%% used, %4.1f%% free\n",
648 Math::doublePercent(stats.store.mem.size, stats.store.mem.capacity),
649 Math::doublePercent(stats.store.mem.available(), stats.store.mem.capacity));
650
651 storeAppendPrintf(sentry, "\tMean Object Size:\t%0.2f KB\n",
652 stats.store.swap.meanObjectSize() / 1024);
653
654 storeAppendPrintf(sentry, "\tRequests given to unlinkd:\t%.0f\n",
655 stats.unlink_requests);
656
657 storeAppendPrintf(sentry, "Median Service Times (seconds) 5 min 60 min:\n");
658
659 fct = stats.count > 1 ? stats.count * 1000.0 : 1000.0;
660 storeAppendPrintf(sentry, "\tHTTP Requests (All): %8.5f %8.5f\n",
661 stats.http_requests5 / fct,
662 stats.http_requests60 / fct);
663
664 storeAppendPrintf(sentry, "\tCache Misses: %8.5f %8.5f\n",
665 stats.cache_misses5 / fct,
666 stats.cache_misses60 / fct);
667
668 storeAppendPrintf(sentry, "\tCache Hits: %8.5f %8.5f\n",
669 stats.cache_hits5 / fct,
670 stats.cache_hits60 / fct);
671
672 storeAppendPrintf(sentry, "\tNear Hits: %8.5f %8.5f\n",
673 stats.near_hits5 / fct,
674 stats.near_hits60 / fct);
675
676 storeAppendPrintf(sentry, "\tNot-Modified Replies: %8.5f %8.5f\n",
677 stats.not_modified_replies5 / fct,
678 stats.not_modified_replies60 / fct);
679
680 storeAppendPrintf(sentry, "\tDNS Lookups: %8.5f %8.5f\n",
681 stats.dns_lookups5 / fct,
682 stats.dns_lookups60 / fct);
683
684 fct = stats.count > 1 ? stats.count * 1000000.0 : 1000000.0;
685 storeAppendPrintf(sentry, "\tICP Queries: %8.5f %8.5f\n",
686 stats.icp_queries5 / fct,
687 stats.icp_queries60 / fct);
688
689 storeAppendPrintf(sentry, "Resource usage for %s:\n", APP_SHORTNAME);
690
691 storeAppendPrintf(sentry, "\tUP Time:\t%.3f seconds\n", stats.up_time);
692
693 storeAppendPrintf(sentry, "\tCPU Time:\t%.3f seconds\n", stats.cpu_time);
694
695 storeAppendPrintf(sentry, "\tCPU Usage:\t%.2f%%\n",
696 stats.cpu_usage);
697
698 storeAppendPrintf(sentry, "\tCPU Usage, 5 minute avg:\t%.2f%%\n",
699 stats.cpu_usage5);
700
701 storeAppendPrintf(sentry, "\tCPU Usage, 60 minute avg:\t%.2f%%\n",
702 stats.cpu_usage60);
703
704 storeAppendPrintf(sentry, "\tMaximum Resident Size: %.0f KB\n",
705 stats.maxrss);
706
707 storeAppendPrintf(sentry, "\tPage faults with physical i/o: %.0f\n",
708 stats.page_faults);
709
710#if HAVE_MSTATS && HAVE_GNUMALLOC_H
711
712 storeAppendPrintf(sentry, "Memory usage for %s via mstats():\n",APP_SHORTNAME);
713
714 storeAppendPrintf(sentry, "\tTotal space in arena: %6.0f KB\n",
715 stats.ms_bytes_total / 1024);
716
717 storeAppendPrintf(sentry, "\tTotal free: %6.0f KB %.0f%%\n",
718 stats.ms_bytes_free / 1024,
719 Math::doublePercent(stats.ms_bytes_free, stats.ms_bytes_total));
720
721#endif
722
723 storeAppendPrintf(sentry, "Memory accounted for:\n");
724 storeAppendPrintf(sentry, "\tTotal accounted: %6.0f KB\n",
725 stats.total_accounted / 1024);
726 {
727 MemPoolGlobalStats mp_stats;
728 memPoolGetGlobalStats(&mp_stats);
729 storeAppendPrintf(sentry, "\tmemPoolAlloc calls: %9.0f\n",
730 stats.gb_saved_count);
731 storeAppendPrintf(sentry, "\tmemPoolFree calls: %9.0f\n",
732 stats.gb_freed_count);
733 }
734
735 storeAppendPrintf(sentry, "File descriptor usage for %s:\n", APP_SHORTNAME);
736 storeAppendPrintf(sentry, "\tMaximum number of file descriptors: %4.0f\n",
737 stats.max_fd);
738 storeAppendPrintf(sentry, "\tLargest file desc currently in use: %4.0f\n",
739 stats.biggest_fd);
740 storeAppendPrintf(sentry, "\tNumber of file desc currently in use: %4.0f\n",
741 stats.number_fd);
742 storeAppendPrintf(sentry, "\tFiles queued for open: %4.0f\n",
743 stats.opening_fd);
744 storeAppendPrintf(sentry, "\tAvailable number of file descriptors: %4.0f\n",
745 stats.num_fd_free);
746 storeAppendPrintf(sentry, "\tReserved number of file descriptors: %4.0f\n",
747 stats.reserved_fd);
748 storeAppendPrintf(sentry, "\tStore Disk files open: %4.0f\n",
749 stats.store.swap.open_disk_fd);
750
751 storeAppendPrintf(sentry, "Internal Data Structures:\n");
752 storeAppendPrintf(sentry, "\t%6.0f StoreEntries\n",
753 stats.store.store_entry_count);
754 storeAppendPrintf(sentry, "\t%6.0f StoreEntries with MemObjects\n",
755 stats.store.mem_object_count);
756 storeAppendPrintf(sentry, "\t%6.0f Hot Object Cache Items\n",
757 stats.store.mem.count);
758 storeAppendPrintf(sentry, "\t%6.0f on-disk objects\n",
759 stats.store.swap.count);
760}
761
762void
764{
765#if XMALLOC_STATISTICS
768 storeAppendPrintf(sentry, "\nMemory allocation statistics\n");
769 storeAppendPrintf(sentry, "%12s %15s %6s %12s\n","Alloc Size","Count","Delta","Alloc/sec");
770 malloc_statistics(info_get_mallstat, sentry);
771#else
772 (void)sentry;
773#endif
774}
775
776void
778{
779 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
780 double p = (i + 1) * 5 / 100.0;
781 stats.http_requests5[i] = statPctileSvc(p, 5, PCTILE_HTTP);
782 stats.http_requests60[i] = statPctileSvc(p, 60, PCTILE_HTTP);
783
784 stats.cache_misses5[i] = statPctileSvc(p, 5, PCTILE_MISS);
785 stats.cache_misses60[i] = statPctileSvc(p, 60, PCTILE_MISS);
786
787 stats.cache_hits5[i] = statPctileSvc(p, 5, PCTILE_HIT);
788 stats.cache_hits60[i] = statPctileSvc(p, 60, PCTILE_HIT);
789
790 stats.near_hits5[i] = statPctileSvc(p, 5, PCTILE_NH);
791 stats.near_hits60[i] = statPctileSvc(p, 60, PCTILE_NH);
792
793 stats.not_modified_replies5[i] = statPctileSvc(p, 5, PCTILE_NM);
794 stats.not_modified_replies60[i] = statPctileSvc(p, 60, PCTILE_NM);
795
796 stats.dns_lookups5[i] = statPctileSvc(p, 5, PCTILE_DNS);
797 stats.dns_lookups60[i] = statPctileSvc(p, 60, PCTILE_DNS);
798
799 stats.icp_queries5[i] = statPctileSvc(p, 5, PCTILE_ICP_QUERY);
800 stats.icp_queries60[i] = statPctileSvc(p, 60, PCTILE_ICP_QUERY);
801 }
802}
803
804void
806{
807 storeAppendPrintf(sentry, "Service Time Percentiles 5 min 60 min:\n");
808 double fct = stats.count > 1 ? stats.count * 1000.0 : 1000.0;
809 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
810 storeAppendPrintf(sentry, "\tHTTP Requests (All): %2d%% %8.5f %8.5f\n",
811 (i + 1) * 5,
812 stats.http_requests5[i] / fct,
813 stats.http_requests60[i] / fct);
814 }
815 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
816 storeAppendPrintf(sentry, "\tCache Misses: %2d%% %8.5f %8.5f\n",
817 (i + 1) * 5,
818 stats.cache_misses5[i] / fct,
819 stats.cache_misses60[i] / fct);
820 }
821 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
822 storeAppendPrintf(sentry, "\tCache Hits: %2d%% %8.5f %8.5f\n",
823 (i + 1) * 5,
824 stats.cache_hits5[i] / fct,
825 stats.cache_hits60[i] / fct);
826 }
827 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
828 storeAppendPrintf(sentry, "\tNear Hits: %2d%% %8.5f %8.5f\n",
829 (i + 1) * 5,
830 stats.near_hits5[i] / fct,
831 stats.near_hits60[i] / fct);
832 }
833 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
834 storeAppendPrintf(sentry, "\tNot-Modified Replies: %2d%% %8.5f %8.5f\n",
835 (i + 1) * 5,
836 stats.not_modified_replies5[i] / fct,
837 stats.not_modified_replies60[i] / fct);
838 }
839 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
840 storeAppendPrintf(sentry, "\tDNS Lookups: %2d%% %8.5f %8.5f\n",
841 (i + 1) * 5,
842 stats.dns_lookups5[i] / fct,
843 stats.dns_lookups60[i] / fct);
844 }
845 fct = stats.count > 1 ? stats.count * 1000000.0 : 1000000.0;
846 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
847 storeAppendPrintf(sentry, "\tICP Queries: %2d%% %8.5f %8.5f\n",
848 (i + 1) * 5,
849 stats.icp_queries5[i] / fct,
850 stats.icp_queries60[i] / fct);
851 }
852}
853
854static void
855statAvgDump(StoreEntry * sentry, int minutes, int hours)
856{
858 GetAvgStat(stats, minutes, hours);
859 DumpAvgStat(stats, sentry);
860}
861
862#define XAVG(X) (dt ? (double) (f->X - l->X) / dt : 0.0)
863void
864GetAvgStat(Mgr::IntervalActionData& stats, int minutes, int hours)
865{
866 StatCounters *f;
867 StatCounters *l;
868 double dt;
869 double ct;
870 assert(N_COUNT_HIST > 1);
871 assert(minutes > 0 || hours > 0);
872 f = &CountHist[0];
873 l = f;
874
875 if (minutes > 0 && hours == 0) {
876 /* checking minute readings ... */
877
878 if (minutes > N_COUNT_HIST - 1)
879 minutes = N_COUNT_HIST - 1;
880
881 l = &CountHist[minutes];
882 } else if (minutes == 0 && hours > 0) {
883 /* checking hour readings ... */
884
885 if (hours > N_COUNT_HOUR_HIST - 1)
886 hours = N_COUNT_HOUR_HIST - 1;
887
888 l = &CountHourHist[hours];
889 } else {
890 debugs(18, DBG_IMPORTANT, "ERROR: statAvgDump: Invalid args, minutes=" << minutes << ", hours=" << hours);
891 return;
892 }
893
894 dt = tvSubDsec(l->timestamp, f->timestamp);
895 ct = f->cputime - l->cputime;
896
897 stats.sample_start_time = l->timestamp;
898 stats.sample_end_time = f->timestamp;
899
900 stats.client_http_requests = XAVG(client_http.requests);
901 stats.client_http_hits = XAVG(client_http.hits);
902 stats.client_http_errors = XAVG(client_http.errors);
903 stats.client_http_kbytes_in = XAVG(client_http.kbytes_in.kb);
904 stats.client_http_kbytes_out = XAVG(client_http.kbytes_out.kb);
905
906 stats.client_http_all_median_svc_time = statHistDeltaMedian(l->client_http.allSvcTime,
907 f->client_http.allSvcTime) / 1000.0;
908 stats.client_http_miss_median_svc_time = statHistDeltaMedian(l->client_http.missSvcTime,
909 f->client_http.missSvcTime) / 1000.0;
910 stats.client_http_nm_median_svc_time = statHistDeltaMedian(l->client_http.nearMissSvcTime,
911 f->client_http.nearMissSvcTime) / 1000.0;
912 stats.client_http_nh_median_svc_time = statHistDeltaMedian(l->client_http.nearHitSvcTime,
913 f->client_http.nearHitSvcTime) / 1000.0;
914 stats.client_http_hit_median_svc_time = statHistDeltaMedian(l->client_http.hitSvcTime,
915 f->client_http.hitSvcTime) / 1000.0;
916
917 stats.server_all_requests = XAVG(server.all.requests);
918 stats.server_all_errors = XAVG(server.all.errors);
919 stats.server_all_kbytes_in = XAVG(server.all.kbytes_in.kb);
920 stats.server_all_kbytes_out = XAVG(server.all.kbytes_out.kb);
921
922 stats.server_http_requests = XAVG(server.http.requests);
923 stats.server_http_errors = XAVG(server.http.errors);
924 stats.server_http_kbytes_in = XAVG(server.http.kbytes_in.kb);
925 stats.server_http_kbytes_out = XAVG(server.http.kbytes_out.kb);
926
927 stats.server_ftp_requests = XAVG(server.ftp.requests);
928 stats.server_ftp_errors = XAVG(server.ftp.errors);
929 stats.server_ftp_kbytes_in = XAVG(server.ftp.kbytes_in.kb);
930 stats.server_ftp_kbytes_out = XAVG(server.ftp.kbytes_out.kb);
931
932 stats.server_other_requests = XAVG(server.other.requests);
933 stats.server_other_errors = XAVG(server.other.errors);
934 stats.server_other_kbytes_in = XAVG(server.other.kbytes_in.kb);
935 stats.server_other_kbytes_out = XAVG(server.other.kbytes_out.kb);
936
937 stats.icp_pkts_sent = XAVG(icp.pkts_sent);
938 stats.icp_pkts_recv = XAVG(icp.pkts_recv);
939 stats.icp_queries_sent = XAVG(icp.queries_sent);
940 stats.icp_replies_sent = XAVG(icp.replies_sent);
941 stats.icp_queries_recv = XAVG(icp.queries_recv);
942 stats.icp_replies_recv = XAVG(icp.replies_recv);
943 stats.icp_replies_queued = XAVG(icp.replies_queued);
944 stats.icp_query_timeouts = XAVG(icp.query_timeouts);
945 stats.icp_kbytes_sent = XAVG(icp.kbytes_sent.kb);
946 stats.icp_kbytes_recv = XAVG(icp.kbytes_recv.kb);
947 stats.icp_q_kbytes_sent = XAVG(icp.q_kbytes_sent.kb);
948 stats.icp_r_kbytes_sent = XAVG(icp.r_kbytes_sent.kb);
949 stats.icp_q_kbytes_recv = XAVG(icp.q_kbytes_recv.kb);
950 stats.icp_r_kbytes_recv = XAVG(icp.r_kbytes_recv.kb);
951
952 stats.icp_query_median_svc_time = statHistDeltaMedian(l->icp.querySvcTime,
953 f->icp.querySvcTime) / 1000000.0;
954 stats.icp_reply_median_svc_time = statHistDeltaMedian(l->icp.replySvcTime,
955 f->icp.replySvcTime) / 1000000.0;
956 stats.dns_median_svc_time = statHistDeltaMedian(l->dns.svcTime,
957 f->dns.svcTime) / 1000.0;
958
959 stats.unlink_requests = XAVG(unlink.requests);
960 stats.page_faults = XAVG(page_faults);
961 stats.select_loops = XAVG(select_loops);
962 stats.select_fds = XAVG(select_fds);
963 stats.average_select_fd_period = f->select_fds > l->select_fds ?
964 (f->select_time - l->select_time) / (f->select_fds - l->select_fds) : 0.0;
965
966 stats.median_select_fds = statHistDeltaMedian(l->select_fds_hist, f->select_fds_hist);
967 stats.swap_outs = XAVG(swap.outs);
968 stats.swap_ins = XAVG(swap.ins);
969 stats.swap_files_cleaned = XAVG(swap.files_cleaned);
970 stats.aborted_requests = XAVG(aborted_requests);
971
972 stats.hitValidationAttempts = XAVG(hitValidation.attempts);
973 stats.hitValidationRefusalsDueToLocking = XAVG(hitValidation.refusalsDueToLocking);
974 stats.hitValidationRefusalsDueToZeroSize = XAVG(hitValidation.refusalsDueToZeroSize);
975 stats.hitValidationRefusalsDueToTimeLimit = XAVG(hitValidation.refusalsDueToTimeLimit);
976 stats.hitValidationFailures = XAVG(hitValidation.failures);
977
978 stats.syscalls_disk_opens = XAVG(syscalls.disk.opens);
979 stats.syscalls_disk_closes = XAVG(syscalls.disk.closes);
980 stats.syscalls_disk_reads = XAVG(syscalls.disk.reads);
981 stats.syscalls_disk_writes = XAVG(syscalls.disk.writes);
982 stats.syscalls_disk_seeks = XAVG(syscalls.disk.seeks);
983 stats.syscalls_disk_unlinks = XAVG(syscalls.disk.unlinks);
984 stats.syscalls_sock_accepts = XAVG(syscalls.sock.accepts);
985 stats.syscalls_sock_sockets = XAVG(syscalls.sock.sockets);
986 stats.syscalls_sock_connects = XAVG(syscalls.sock.connects);
987 stats.syscalls_sock_binds = XAVG(syscalls.sock.binds);
988 stats.syscalls_sock_closes = XAVG(syscalls.sock.closes);
989 stats.syscalls_sock_reads = XAVG(syscalls.sock.reads);
990 stats.syscalls_sock_writes = XAVG(syscalls.sock.writes);
991 stats.syscalls_sock_recvfroms = XAVG(syscalls.sock.recvfroms);
992 stats.syscalls_sock_sendtos = XAVG(syscalls.sock.sendtos);
993 stats.syscalls_selects = XAVG(syscalls.selects);
994
995 stats.cpu_time = ct;
996 stats.wall_time = dt;
997}
998
999void
1001{
1002 storeAppendPrintf(sentry, "sample_start_time = %d.%d (%s)\n",
1003 (int)stats.sample_start_time.tv_sec,
1004 (int)stats.sample_start_time.tv_usec,
1005 Time::FormatRfc1123(stats.sample_start_time.tv_sec));
1006 storeAppendPrintf(sentry, "sample_end_time = %d.%d (%s)\n",
1007 (int)stats.sample_end_time.tv_sec,
1008 (int)stats.sample_end_time.tv_usec,
1009 Time::FormatRfc1123(stats.sample_end_time.tv_sec));
1010
1011 storeAppendPrintf(sentry, "client_http.requests = %f/sec\n",
1012 stats.client_http_requests);
1013 storeAppendPrintf(sentry, "client_http.hits = %f/sec\n",
1014 stats.client_http_hits);
1015 storeAppendPrintf(sentry, "client_http.errors = %f/sec\n",
1016 stats.client_http_errors);
1017 storeAppendPrintf(sentry, "client_http.kbytes_in = %f/sec\n",
1018 stats.client_http_kbytes_in);
1019 storeAppendPrintf(sentry, "client_http.kbytes_out = %f/sec\n",
1020 stats.client_http_kbytes_out);
1021
1022 double fct = stats.count > 1 ? stats.count : 1.0;
1023 storeAppendPrintf(sentry, "client_http.all_median_svc_time = %f seconds\n",
1024 stats.client_http_all_median_svc_time / fct);
1025 storeAppendPrintf(sentry, "client_http.miss_median_svc_time = %f seconds\n",
1026 stats.client_http_miss_median_svc_time / fct);
1027 storeAppendPrintf(sentry, "client_http.nm_median_svc_time = %f seconds\n",
1028 stats.client_http_nm_median_svc_time / fct);
1029 storeAppendPrintf(sentry, "client_http.nh_median_svc_time = %f seconds\n",
1030 stats.client_http_nh_median_svc_time / fct);
1031 storeAppendPrintf(sentry, "client_http.hit_median_svc_time = %f seconds\n",
1032 stats.client_http_hit_median_svc_time / fct);
1033
1034 storeAppendPrintf(sentry, "server.all.requests = %f/sec\n",
1035 stats.server_all_requests);
1036 storeAppendPrintf(sentry, "server.all.errors = %f/sec\n",
1037 stats.server_all_errors);
1038 storeAppendPrintf(sentry, "server.all.kbytes_in = %f/sec\n",
1039 stats.server_all_kbytes_in);
1040 storeAppendPrintf(sentry, "server.all.kbytes_out = %f/sec\n",
1041 stats.server_all_kbytes_out);
1042
1043 storeAppendPrintf(sentry, "server.http.requests = %f/sec\n",
1044 stats.server_http_requests);
1045 storeAppendPrintf(sentry, "server.http.errors = %f/sec\n",
1046 stats.server_http_errors);
1047 storeAppendPrintf(sentry, "server.http.kbytes_in = %f/sec\n",
1048 stats.server_http_kbytes_in);
1049 storeAppendPrintf(sentry, "server.http.kbytes_out = %f/sec\n",
1050 stats.server_http_kbytes_out);
1051
1052 storeAppendPrintf(sentry, "server.ftp.requests = %f/sec\n",
1053 stats.server_ftp_requests);
1054 storeAppendPrintf(sentry, "server.ftp.errors = %f/sec\n",
1055 stats.server_ftp_errors);
1056 storeAppendPrintf(sentry, "server.ftp.kbytes_in = %f/sec\n",
1057 stats.server_ftp_kbytes_in);
1058 storeAppendPrintf(sentry, "server.ftp.kbytes_out = %f/sec\n",
1059 stats.server_ftp_kbytes_out);
1060
1061 storeAppendPrintf(sentry, "server.other.requests = %f/sec\n",
1062 stats.server_other_requests);
1063 storeAppendPrintf(sentry, "server.other.errors = %f/sec\n",
1064 stats.server_other_errors);
1065 storeAppendPrintf(sentry, "server.other.kbytes_in = %f/sec\n",
1066 stats.server_other_kbytes_in);
1067 storeAppendPrintf(sentry, "server.other.kbytes_out = %f/sec\n",
1068 stats.server_other_kbytes_out);
1069
1070 storeAppendPrintf(sentry, "icp.pkts_sent = %f/sec\n",
1071 stats.icp_pkts_sent);
1072 storeAppendPrintf(sentry, "icp.pkts_recv = %f/sec\n",
1073 stats.icp_pkts_recv);
1074 storeAppendPrintf(sentry, "icp.queries_sent = %f/sec\n",
1075 stats.icp_queries_sent);
1076 storeAppendPrintf(sentry, "icp.replies_sent = %f/sec\n",
1077 stats.icp_replies_sent);
1078 storeAppendPrintf(sentry, "icp.queries_recv = %f/sec\n",
1079 stats.icp_queries_recv);
1080 storeAppendPrintf(sentry, "icp.replies_recv = %f/sec\n",
1081 stats.icp_replies_recv);
1082 storeAppendPrintf(sentry, "icp.replies_queued = %f/sec\n",
1083 stats.icp_replies_queued);
1084 storeAppendPrintf(sentry, "icp.query_timeouts = %f/sec\n",
1085 stats.icp_query_timeouts);
1086 storeAppendPrintf(sentry, "icp.kbytes_sent = %f/sec\n",
1087 stats.icp_kbytes_sent);
1088 storeAppendPrintf(sentry, "icp.kbytes_recv = %f/sec\n",
1089 stats.icp_kbytes_recv);
1090 storeAppendPrintf(sentry, "icp.q_kbytes_sent = %f/sec\n",
1091 stats.icp_q_kbytes_sent);
1092 storeAppendPrintf(sentry, "icp.r_kbytes_sent = %f/sec\n",
1093 stats.icp_r_kbytes_sent);
1094 storeAppendPrintf(sentry, "icp.q_kbytes_recv = %f/sec\n",
1095 stats.icp_q_kbytes_recv);
1096 storeAppendPrintf(sentry, "icp.r_kbytes_recv = %f/sec\n",
1097 stats.icp_r_kbytes_recv);
1098 storeAppendPrintf(sentry, "icp.query_median_svc_time = %f seconds\n",
1099 stats.icp_query_median_svc_time / fct);
1100 storeAppendPrintf(sentry, "icp.reply_median_svc_time = %f seconds\n",
1101 stats.icp_reply_median_svc_time / fct);
1102 storeAppendPrintf(sentry, "dns.median_svc_time = %f seconds\n",
1103 stats.dns_median_svc_time / fct);
1104 storeAppendPrintf(sentry, "unlink.requests = %f/sec\n",
1105 stats.unlink_requests);
1106 storeAppendPrintf(sentry, "page_faults = %f/sec\n",
1107 stats.page_faults);
1108 storeAppendPrintf(sentry, "select_loops = %f/sec\n",
1109 stats.select_loops);
1110 storeAppendPrintf(sentry, "select_fds = %f/sec\n",
1111 stats.select_fds);
1112 storeAppendPrintf(sentry, "average_select_fd_period = %f/fd\n",
1113 stats.average_select_fd_period / fct);
1114 storeAppendPrintf(sentry, "median_select_fds = %f\n",
1115 stats.median_select_fds / fct);
1116 storeAppendPrintf(sentry, "swap.outs = %f/sec\n",
1117 stats.swap_outs);
1118 storeAppendPrintf(sentry, "swap.ins = %f/sec\n",
1119 stats.swap_ins);
1120 storeAppendPrintf(sentry, "swap.files_cleaned = %f/sec\n",
1121 stats.swap_files_cleaned);
1122 storeAppendPrintf(sentry, "aborted_requests = %f/sec\n",
1123 stats.aborted_requests);
1124
1125 storeAppendPrintf(sentry, "hit_validation.attempts = %f/sec\n",
1126 stats.hitValidationAttempts);
1127 storeAppendPrintf(sentry, "hit_validation.refusals.due_to_locking = %f/sec\n",
1128 stats.hitValidationRefusalsDueToLocking);
1129 storeAppendPrintf(sentry, "hit_validation.refusals.due_to_zeroSize = %f/sec\n",
1130 stats.hitValidationRefusalsDueToZeroSize);
1131 storeAppendPrintf(sentry, "hit_validation.refusals.due_to_timeLimit = %f/sec\n",
1132 stats.hitValidationRefusalsDueToTimeLimit);
1133 storeAppendPrintf(sentry, "hit_validation.failures = %f/sec\n",
1134 stats.hitValidationFailures);
1135
1136#if USE_POLL
1137 storeAppendPrintf(sentry, "syscalls.polls = %f/sec\n", stats.syscalls_selects);
1138#elif defined(USE_SELECT) || defined(USE_SELECT_WIN32)
1139 storeAppendPrintf(sentry, "syscalls.selects = %f/sec\n", stats.syscalls_selects);
1140#endif
1141
1142 storeAppendPrintf(sentry, "syscalls.disk.opens = %f/sec\n", stats.syscalls_disk_opens);
1143 storeAppendPrintf(sentry, "syscalls.disk.closes = %f/sec\n", stats.syscalls_disk_closes);
1144 storeAppendPrintf(sentry, "syscalls.disk.reads = %f/sec\n", stats.syscalls_disk_reads);
1145 storeAppendPrintf(sentry, "syscalls.disk.writes = %f/sec\n", stats.syscalls_disk_writes);
1146 storeAppendPrintf(sentry, "syscalls.disk.seeks = %f/sec\n", stats.syscalls_disk_seeks);
1147 storeAppendPrintf(sentry, "syscalls.disk.unlinks = %f/sec\n", stats.syscalls_disk_unlinks);
1148 storeAppendPrintf(sentry, "syscalls.sock.accepts = %f/sec\n", stats.syscalls_sock_accepts);
1149 storeAppendPrintf(sentry, "syscalls.sock.sockets = %f/sec\n", stats.syscalls_sock_sockets);
1150 storeAppendPrintf(sentry, "syscalls.sock.connects = %f/sec\n", stats.syscalls_sock_connects);
1151 storeAppendPrintf(sentry, "syscalls.sock.binds = %f/sec\n", stats.syscalls_sock_binds);
1152 storeAppendPrintf(sentry, "syscalls.sock.closes = %f/sec\n", stats.syscalls_sock_closes);
1153 storeAppendPrintf(sentry, "syscalls.sock.reads = %f/sec\n", stats.syscalls_sock_reads);
1154 storeAppendPrintf(sentry, "syscalls.sock.writes = %f/sec\n", stats.syscalls_sock_writes);
1155 storeAppendPrintf(sentry, "syscalls.sock.recvfroms = %f/sec\n", stats.syscalls_sock_recvfroms);
1156 storeAppendPrintf(sentry, "syscalls.sock.sendtos = %f/sec\n", stats.syscalls_sock_sendtos);
1157
1158 storeAppendPrintf(sentry, "cpu_time = %f seconds\n", stats.cpu_time);
1159 storeAppendPrintf(sentry, "wall_time = %f seconds\n", stats.wall_time);
1160 storeAppendPrintf(sentry, "cpu_usage = %f%%\n", Math::doublePercent(stats.cpu_time, stats.wall_time));
1161}
1162
1163static void
1165{
1166 Mgr::RegisterAction("info", "General Runtime Information",
1168 Mgr::RegisterAction("service_times", "Service Times (Percentiles)",
1170 Mgr::RegisterAction("filedescriptors", "Process Filedescriptor Allocation",
1171 fde::DumpStats, 0, 1);
1172 Mgr::RegisterAction("objects", "All Cache Objects", stat_objects_get, 0, 0);
1173 Mgr::RegisterAction("vm_objects", "In-Memory and In-Transit Objects",
1174 stat_vmobjects_get, 0, 0);
1175 Mgr::RegisterAction("io", "Server-side network read() size histograms",
1176 &Mgr::IoAction::Create, 0, 1);
1177 Mgr::RegisterAction("counters", "Traffic and Resource Counters",
1179 Mgr::RegisterAction("peer_select", "Peer Selection Algorithms",
1180 statPeerSelect, 0, 1);
1181 Mgr::RegisterAction("digest_stats", "Cache Digest and ICP blob",
1182 statDigestBlob, 0, 1);
1183 Mgr::RegisterAction("5min", "5 Minute Average of Counters",
1185 Mgr::RegisterAction("60min", "60 Minute Average of Counters",
1187 Mgr::RegisterAction("utilization", "Cache Utilization",
1188 statUtilization, 0, 1);
1189 Mgr::RegisterAction("histograms", "Full Histogram Counts",
1191 Mgr::RegisterAction("active_requests",
1192 "Client-side Active Requests",
1193 statClientRequests, 0, 1);
1194#if USE_AUTH
1195 Mgr::RegisterAction("username_cache",
1196 "Active Cached Usernames",
1198#endif
1199 Mgr::RegisterAction("openfd_objects", "Objects with Swapout files open",
1200 statOpenfdObj, 0, 0);
1201#if STAT_GRAPHS
1202 Mgr::RegisterAction("graph_variables", "Display cache metrics graphically",
1203 statGraphDump, 0, 1);
1204#endif
1205}
1206
1207/* add special cases here as they arrive */
1208static void
1210{
1211 /*
1212 * HTTP svc_time hist is kept in milli-seconds; max of 3 hours.
1213 */
1214 C->client_http.allSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1215 C->client_http.missSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1216 C->client_http.nearMissSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1217 C->client_http.nearHitSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1218 C->client_http.hitSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1219 /*
1220 * ICP svc_time hist is kept in micro-seconds; max of 1 minute.
1221 */
1222 C->icp.querySvcTime.logInit(300, 0.0, 1000000.0 * 60.0);
1223 C->icp.replySvcTime.logInit(300, 0.0, 1000000.0 * 60.0);
1224 /*
1225 * DNS svc_time hist is kept in milli-seconds; max of 10 minutes.
1226 */
1227 C->dns.svcTime.logInit(300, 0.0, 60000.0 * 10.0);
1228 /*
1229 * Cache Digest Stuff
1230 */
1231 C->cd.on_xition_count.enumInit(CacheDigestHashFuncCount);
1232 C->comm_udp_incoming.enumInit(INCOMING_UDP_MAX);
1233 C->comm_dns_incoming.enumInit(INCOMING_DNS_MAX);
1234 C->comm_tcp_incoming.enumInit(INCOMING_TCP_MAX);
1235 C->select_fds_hist.enumInit(256); /* was SQUID_MAXFD, but it is way too much. It is OK to crop this statistics */
1236}
1237
1238static void
1240{
1241 assert(C);
1242 *C = StatCounters();
1244}
1245
1246void
1248{
1249 int i;
1250 debugs(18, 5, "statInit: Initializing...");
1251
1252 for (i = 0; i < N_COUNT_HIST; ++i)
1254
1255 for (i = 0; i < N_COUNT_HOUR_HIST; ++i)
1257
1259
1260 eventAdd("statAvgTick", statAvgTick, nullptr, (double) COUNT_INTERVAL, 1);
1261
1262 ClientActiveRequests.head = nullptr;
1263
1264 ClientActiveRequests.tail = nullptr;
1265
1267}
1268
1269static void
1271{
1272 struct rusage rusage;
1273 eventAdd("statAvgTick", statAvgTick, nullptr, (double) COUNT_INTERVAL, 1);
1278 // shift all elements right and prepend statCounter
1279 for(int i = N_COUNT_HIST-1; i > 0; --i)
1280 CountHist[i] = CountHist[i-1];
1282 ++NCountHist;
1283
1284 if ((NCountHist % COUNT_INTERVAL) == 0) {
1285 /* we have an hours worth of readings. store previous hour */
1286 // shift all elements right and prepend final CountHist element
1287 for(int i = N_COUNT_HOUR_HIST-1; i > 0; --i)
1288 CountHourHist[i] = CountHourHist[i-1];
1291 }
1292
1293 if (Config.warnings.high_rptm > 0) {
1294 int i = (int) statPctileSvc(0.5, 20, PCTILE_HTTP);
1295
1296 if (Config.warnings.high_rptm < i)
1297 debugs(18, DBG_CRITICAL, "WARNING: Median response time is " << i << " milliseconds");
1298 }
1299
1300 if (Config.warnings.high_pf) {
1301 int i = (CountHist[0].page_faults - CountHist[1].page_faults);
1302 double dt = tvSubDsec(CountHist[0].timestamp, CountHist[1].timestamp);
1303
1304 if (i > 0 && dt > 0.0) {
1305 i /= (int) dt;
1306
1307 if (Config.warnings.high_pf < i)
1308 debugs(18, DBG_CRITICAL, "WARNING: Page faults occurring at " << i << "/sec");
1309 }
1310 }
1311
1313 size_t i = 0;
1314#if HAVE_MSTATS && HAVE_GNUMALLOC_H
1315 struct mstats ms = mstats();
1316 i = ms.bytes_total;
1317#endif
1318 if (Config.warnings.high_memory < i)
1319 debugs(18, DBG_CRITICAL, "WARNING: Memory usage at " << ((unsigned long int)(i >> 20)) << " MB");
1320 }
1321}
1322
1323static void
1325{
1326 storeAppendPrintf(sentry, "client_http.allSvcTime histogram:\n");
1327 statCounter.client_http.allSvcTime.dump(sentry, nullptr);
1328 storeAppendPrintf(sentry, "client_http.missSvcTime histogram:\n");
1329 statCounter.client_http.missSvcTime.dump(sentry, nullptr);
1330 storeAppendPrintf(sentry, "client_http.nearMissSvcTime histogram:\n");
1332 storeAppendPrintf(sentry, "client_http.nearHitSvcTime histogram:\n");
1333 statCounter.client_http.nearHitSvcTime.dump(sentry, nullptr);
1334 storeAppendPrintf(sentry, "client_http.hitSvcTime histogram:\n");
1335 statCounter.client_http.hitSvcTime.dump(sentry, nullptr);
1336 storeAppendPrintf(sentry, "icp.querySvcTime histogram:\n");
1337 statCounter.icp.querySvcTime.dump(sentry, nullptr);
1338 storeAppendPrintf(sentry, "icp.replySvcTime histogram:\n");
1339 statCounter.icp.replySvcTime.dump(sentry, nullptr);
1340 storeAppendPrintf(sentry, "dns.svc_time histogram:\n");
1341 statCounter.dns.svcTime.dump(sentry, nullptr);
1342 storeAppendPrintf(sentry, "select_fds_hist histogram:\n");
1343 statCounter.select_fds_hist.dump(sentry, nullptr);
1344}
1345
1346static void
1348{
1351 DumpCountersStats(stats, sentry);
1352}
1353
1354void
1356{
1358
1359 struct rusage rusage;
1363
1364 stats.sample_time = f->timestamp;
1365 stats.client_http_requests = f->client_http.requests;
1366 stats.client_http_hits = f->client_http.hits;
1367 stats.client_http_errors = f->client_http.errors;
1368 stats.client_http_kbytes_in = f->client_http.kbytes_in.kb;
1369 stats.client_http_kbytes_out = f->client_http.kbytes_out.kb;
1370 stats.client_http_hit_kbytes_out = f->client_http.hit_kbytes_out.kb;
1371
1372 stats.server_all_requests = f->server.all.requests;
1373 stats.server_all_errors = f->server.all.errors;
1374 stats.server_all_kbytes_in = f->server.all.kbytes_in.kb;
1375 stats.server_all_kbytes_out = f->server.all.kbytes_out.kb;
1376
1377 stats.server_http_requests = f->server.http.requests;
1378 stats.server_http_errors = f->server.http.errors;
1379 stats.server_http_kbytes_in = f->server.http.kbytes_in.kb;
1380 stats.server_http_kbytes_out = f->server.http.kbytes_out.kb;
1381
1382 stats.server_ftp_requests = f->server.ftp.requests;
1383 stats.server_ftp_errors = f->server.ftp.errors;
1384 stats.server_ftp_kbytes_in = f->server.ftp.kbytes_in.kb;
1385 stats.server_ftp_kbytes_out = f->server.ftp.kbytes_out.kb;
1386
1387 stats.server_other_requests = f->server.other.requests;
1388 stats.server_other_errors = f->server.other.errors;
1389 stats.server_other_kbytes_in = f->server.other.kbytes_in.kb;
1390 stats.server_other_kbytes_out = f->server.other.kbytes_out.kb;
1391
1392 stats.icp_pkts_sent = f->icp.pkts_sent;
1393 stats.icp_pkts_recv = f->icp.pkts_recv;
1394 stats.icp_queries_sent = f->icp.queries_sent;
1395 stats.icp_replies_sent = f->icp.replies_sent;
1396 stats.icp_queries_recv = f->icp.queries_recv;
1397 stats.icp_replies_recv = f->icp.replies_recv;
1398 stats.icp_query_timeouts = f->icp.query_timeouts;
1399 stats.icp_replies_queued = f->icp.replies_queued;
1400 stats.icp_kbytes_sent = f->icp.kbytes_sent.kb;
1401 stats.icp_kbytes_recv = f->icp.kbytes_recv.kb;
1402 stats.icp_q_kbytes_sent = f->icp.q_kbytes_sent.kb;
1403 stats.icp_r_kbytes_sent = f->icp.r_kbytes_sent.kb;
1404 stats.icp_q_kbytes_recv = f->icp.q_kbytes_recv.kb;
1405 stats.icp_r_kbytes_recv = f->icp.r_kbytes_recv.kb;
1406
1407#if USE_CACHE_DIGESTS
1408
1409 stats.icp_times_used = f->icp.times_used;
1410 stats.cd_times_used = f->cd.times_used;
1411 stats.cd_msgs_sent = f->cd.msgs_sent;
1412 stats.cd_msgs_recv = f->cd.msgs_recv;
1413 stats.cd_memory = f->cd.memory.kb;
1414 stats.cd_local_memory = store_digest ? store_digest->mask_size / 1024 : 0;
1415 stats.cd_kbytes_sent = f->cd.kbytes_sent.kb;
1416 stats.cd_kbytes_recv = f->cd.kbytes_recv.kb;
1417#endif
1418
1419 stats.unlink_requests = f->unlink.requests;
1420 stats.page_faults = f->page_faults;
1421 stats.select_loops = f->select_loops;
1422 stats.cpu_time = f->cputime;
1423 stats.wall_time = tvSubDsec(f->timestamp, current_time);
1424 stats.swap_outs = f->swap.outs;
1425 stats.swap_ins = f->swap.ins;
1426 stats.swap_files_cleaned = f->swap.files_cleaned;
1427 stats.aborted_requests = f->aborted_requests;
1428
1429 stats.hitValidationAttempts = f->hitValidation.attempts;
1430 stats.hitValidationRefusalsDueToLocking = f->hitValidation.refusalsDueToLocking;
1431 stats.hitValidationRefusalsDueToZeroSize = f->hitValidation.refusalsDueToZeroSize;
1432 stats.hitValidationRefusalsDueToTimeLimit = f->hitValidation.refusalsDueToTimeLimit;
1433 stats.hitValidationFailures = f->hitValidation.failures;
1434}
1435
1436void
1438{
1439 storeAppendPrintf(sentry, "sample_time = %d.%d (%s)\n",
1440 (int) stats.sample_time.tv_sec,
1441 (int) stats.sample_time.tv_usec,
1442 Time::FormatRfc1123(stats.sample_time.tv_sec));
1443 storeAppendPrintf(sentry, "client_http.requests = %.0f\n",
1444 stats.client_http_requests);
1445 storeAppendPrintf(sentry, "client_http.hits = %.0f\n",
1446 stats.client_http_hits);
1447 storeAppendPrintf(sentry, "client_http.errors = %.0f\n",
1448 stats.client_http_errors);
1449 storeAppendPrintf(sentry, "client_http.kbytes_in = %.0f\n",
1450 stats.client_http_kbytes_in);
1451 storeAppendPrintf(sentry, "client_http.kbytes_out = %.0f\n",
1452 stats.client_http_kbytes_out);
1453 storeAppendPrintf(sentry, "client_http.hit_kbytes_out = %.0f\n",
1454 stats.client_http_hit_kbytes_out);
1455
1456 storeAppendPrintf(sentry, "server.all.requests = %.0f\n",
1457 stats.server_all_requests);
1458 storeAppendPrintf(sentry, "server.all.errors = %.0f\n",
1459 stats.server_all_errors);
1460 storeAppendPrintf(sentry, "server.all.kbytes_in = %.0f\n",
1461 stats.server_all_kbytes_in);
1462 storeAppendPrintf(sentry, "server.all.kbytes_out = %.0f\n",
1463 stats.server_all_kbytes_out);
1464
1465 storeAppendPrintf(sentry, "server.http.requests = %.0f\n",
1466 stats.server_http_requests);
1467 storeAppendPrintf(sentry, "server.http.errors = %.0f\n",
1468 stats.server_http_errors);
1469 storeAppendPrintf(sentry, "server.http.kbytes_in = %.0f\n",
1470 stats.server_http_kbytes_in);
1471 storeAppendPrintf(sentry, "server.http.kbytes_out = %.0f\n",
1472 stats.server_http_kbytes_out);
1473
1474 storeAppendPrintf(sentry, "server.ftp.requests = %.0f\n",
1475 stats.server_ftp_requests);
1476 storeAppendPrintf(sentry, "server.ftp.errors = %.0f\n",
1477 stats.server_ftp_errors);
1478 storeAppendPrintf(sentry, "server.ftp.kbytes_in = %.0f\n",
1479 stats.server_ftp_kbytes_in);
1480 storeAppendPrintf(sentry, "server.ftp.kbytes_out = %.0f\n",
1481 stats.server_ftp_kbytes_out);
1482
1483 storeAppendPrintf(sentry, "server.other.requests = %.0f\n",
1484 stats.server_other_requests);
1485 storeAppendPrintf(sentry, "server.other.errors = %.0f\n",
1486 stats.server_other_errors);
1487 storeAppendPrintf(sentry, "server.other.kbytes_in = %.0f\n",
1488 stats.server_other_kbytes_in);
1489 storeAppendPrintf(sentry, "server.other.kbytes_out = %.0f\n",
1490 stats.server_other_kbytes_out);
1491
1492 storeAppendPrintf(sentry, "icp.pkts_sent = %.0f\n",
1493 stats.icp_pkts_sent);
1494 storeAppendPrintf(sentry, "icp.pkts_recv = %.0f\n",
1495 stats.icp_pkts_recv);
1496 storeAppendPrintf(sentry, "icp.queries_sent = %.0f\n",
1497 stats.icp_queries_sent);
1498 storeAppendPrintf(sentry, "icp.replies_sent = %.0f\n",
1499 stats.icp_replies_sent);
1500 storeAppendPrintf(sentry, "icp.queries_recv = %.0f\n",
1501 stats.icp_queries_recv);
1502 storeAppendPrintf(sentry, "icp.replies_recv = %.0f\n",
1503 stats.icp_replies_recv);
1504 storeAppendPrintf(sentry, "icp.query_timeouts = %.0f\n",
1505 stats.icp_query_timeouts);
1506 storeAppendPrintf(sentry, "icp.replies_queued = %.0f\n",
1507 stats.icp_replies_queued);
1508 storeAppendPrintf(sentry, "icp.kbytes_sent = %.0f\n",
1509 stats.icp_kbytes_sent);
1510 storeAppendPrintf(sentry, "icp.kbytes_recv = %.0f\n",
1511 stats.icp_kbytes_recv);
1512 storeAppendPrintf(sentry, "icp.q_kbytes_sent = %.0f\n",
1513 stats.icp_q_kbytes_sent);
1514 storeAppendPrintf(sentry, "icp.r_kbytes_sent = %.0f\n",
1515 stats.icp_r_kbytes_sent);
1516 storeAppendPrintf(sentry, "icp.q_kbytes_recv = %.0f\n",
1517 stats.icp_q_kbytes_recv);
1518 storeAppendPrintf(sentry, "icp.r_kbytes_recv = %.0f\n",
1519 stats.icp_r_kbytes_recv);
1520
1521#if USE_CACHE_DIGESTS
1522
1523 storeAppendPrintf(sentry, "icp.times_used = %.0f\n",
1524 stats.icp_times_used);
1525 storeAppendPrintf(sentry, "cd.times_used = %.0f\n",
1526 stats.cd_times_used);
1527 storeAppendPrintf(sentry, "cd.msgs_sent = %.0f\n",
1528 stats.cd_msgs_sent);
1529 storeAppendPrintf(sentry, "cd.msgs_recv = %.0f\n",
1530 stats.cd_msgs_recv);
1531 storeAppendPrintf(sentry, "cd.memory = %.0f\n",
1532 stats.cd_memory);
1533 storeAppendPrintf(sentry, "cd.local_memory = %.0f\n",
1534 stats.cd_local_memory);
1535 storeAppendPrintf(sentry, "cd.kbytes_sent = %.0f\n",
1536 stats.cd_kbytes_sent);
1537 storeAppendPrintf(sentry, "cd.kbytes_recv = %.0f\n",
1538 stats.cd_kbytes_recv);
1539#endif
1540
1541 storeAppendPrintf(sentry, "unlink.requests = %.0f\n",
1542 stats.unlink_requests);
1543 storeAppendPrintf(sentry, "page_faults = %.0f\n",
1544 stats.page_faults);
1545 storeAppendPrintf(sentry, "select_loops = %.0f\n",
1546 stats.select_loops);
1547 storeAppendPrintf(sentry, "cpu_time = %f\n",
1548 stats.cpu_time);
1549 storeAppendPrintf(sentry, "wall_time = %f\n",
1550 stats.wall_time);
1551 storeAppendPrintf(sentry, "swap.outs = %.0f\n",
1552 stats.swap_outs);
1553 storeAppendPrintf(sentry, "swap.ins = %.0f\n",
1554 stats.swap_ins);
1555 storeAppendPrintf(sentry, "swap.files_cleaned = %.0f\n",
1556 stats.swap_files_cleaned);
1557 storeAppendPrintf(sentry, "aborted_requests = %.0f\n",
1558 stats.aborted_requests);
1559
1560 storeAppendPrintf(sentry, "hit_validation.attempts = %.0f\n",
1561 stats.hitValidationAttempts);
1562 storeAppendPrintf(sentry, "hit_validation.refusals.due_to_locking = %.0f\n",
1563 stats.hitValidationRefusalsDueToLocking);
1564 storeAppendPrintf(sentry, "hit_validation.refusals.due_to_zeroSize = %.0f\n",
1565 stats.hitValidationRefusalsDueToZeroSize);
1566 storeAppendPrintf(sentry, "hit_validation.refusals.due_to_timeLimit = %.0f\n",
1567 stats.hitValidationRefusalsDueToTimeLimit);
1568 storeAppendPrintf(sentry, "hit_validation.failures = %.0f\n",
1569 stats.hitValidationFailures);
1570}
1571
1572static void
1574{
1575#if USE_CACHE_DIGESTS
1577 CachePeer *peer;
1578 const int tot_used = f->cd.times_used + f->icp.times_used;
1579
1580 /* totals */
1581 static const SBuf label("all peers");
1582 cacheDigestGuessStatsReport(&f->cd.guess, sentry, label);
1583 /* per-peer */
1584 storeAppendPrintf(sentry, "\nPer-peer statistics:\n");
1585
1586 for (peer = getFirstPeer(); peer; peer = getNextPeer(peer)) {
1587 if (peer->digest)
1588 peerDigestStatsReport(peer->digest, sentry);
1589 else
1590 storeAppendPrintf(sentry, "\nNo peer digest from %s\n", peer->host);
1591
1592 storeAppendPrintf(sentry, "\n");
1593 }
1594
1595 storeAppendPrintf(sentry, "\nAlgorithm usage:\n");
1596 storeAppendPrintf(sentry, "Cache Digest: %7d (%3d%%)\n",
1597 f->cd.times_used, xpercentInt(f->cd.times_used, tot_used));
1598 storeAppendPrintf(sentry, "Icp: %7d (%3d%%)\n",
1599 f->icp.times_used, xpercentInt(f->icp.times_used, tot_used));
1600 storeAppendPrintf(sentry, "Total: %7d (%3d%%)\n",
1601 tot_used, xpercentInt(tot_used, tot_used));
1602#else
1603
1604 storeAppendPrintf(sentry, "peer digests are disabled; no stats is available.\n");
1605#endif
1606}
1607
1608static void
1610{
1611 storeAppendPrintf(sentry, "\nCounters:\n");
1612 statCountersDump(sentry);
1613 storeAppendPrintf(sentry, "\n5 Min Averages:\n");
1614 statAvgDump(sentry, 5, 0);
1615 storeAppendPrintf(sentry, "\nHistograms:\n");
1616 statCountersHistograms(sentry);
1617 storeAppendPrintf(sentry, "\nPeer Digests:\n");
1618 statPeerSelect(sentry);
1619 storeAppendPrintf(sentry, "\nLocal Digest:\n");
1620 storeDigestReport(sentry);
1621}
1622
1623static double
1624statPctileSvc(double pctile, int interval, int which)
1625{
1626 StatCounters *f;
1627 StatCounters *l;
1628 double x;
1629 assert(interval > 0);
1630
1631 if (interval > N_COUNT_HIST - 1)
1632 interval = N_COUNT_HIST - 1;
1633
1634 f = &CountHist[0];
1635
1636 l = &CountHist[interval];
1637
1638 assert(f);
1639
1640 assert(l);
1641
1642 switch (which) {
1643
1644 case PCTILE_HTTP:
1646 break;
1647
1648 case PCTILE_HIT:
1650 break;
1651
1652 case PCTILE_MISS:
1654 break;
1655
1656 case PCTILE_NM:
1658 break;
1659
1660 case PCTILE_NH:
1662 break;
1663
1664 case PCTILE_ICP_QUERY:
1666 break;
1667
1668 case PCTILE_DNS:
1669 x = statHistDeltaPctile(l->dns.svcTime,f->dns.svcTime, pctile);
1670 break;
1671
1672 default:
1673 debugs(49, 5, "statPctileSvc: unknown type.");
1674 x = 0;
1675 }
1676
1677 return x;
1678}
1679
1681snmpStatGet(int minutes)
1682{
1683 return &CountHist[minutes];
1684}
1685
1686int
1688{
1689 assert(N_COUNT_HIST > 5);
1691}
1692
1693static double
1694statCPUUsage(int minutes)
1695{
1696 assert(minutes < N_COUNT_HIST);
1697 return Math::doublePercent(CountHist[0].cputime - CountHist[minutes].cputime,
1698 tvSubDsec(CountHist[minutes].timestamp, CountHist[0].timestamp));
1699}
1700
1701double
1703{
1704 assert(minutes < N_COUNT_HIST);
1705 return Math::doublePercent(CountHist[0].client_http.hits -
1706 CountHist[minutes].client_http.hits,
1708 CountHist[minutes].client_http.requests);
1709}
1710
1711double
1713{
1714 assert(minutes < N_COUNT_HIST);
1715 return Math::doublePercent(CountHist[0].client_http.mem_hits -
1718 CountHist[minutes].client_http.hits);
1719}
1720
1721double
1723{
1724 assert(minutes < N_COUNT_HIST);
1725 return Math::doublePercent(CountHist[0].client_http.disk_hits -
1728 CountHist[minutes].client_http.hits);
1729}
1730
1731double
1733{
1734 size_t s;
1735 size_t c;
1736#if USE_CACHE_DIGESTS
1737
1738 size_t cd;
1739#endif
1740 /* size_t might be unsigned */
1741 assert(minutes < N_COUNT_HIST);
1744#if USE_CACHE_DIGESTS
1745 /*
1746 * This ugly hack is here to prevent the user from seeing a
1747 * negative byte hit ratio. When we fetch a cache digest from
1748 * a neighbor, it gets treated like a cache miss because the
1749 * object is consumed internally. Thus, we subtract cache
1750 * digest bytes out before calculating the byte hit ratio.
1751 */
1752 cd = CountHist[0].cd.kbytes_recv.kb - CountHist[minutes].cd.kbytes_recv.kb;
1753
1754 if (s < cd)
1755 debugs(18, DBG_IMPORTANT, "STRANGE: srv_kbytes=" << s << ", cd_kbytes=" << cd);
1756
1757 s -= cd;
1758
1759#endif
1760
1761 if (c > s)
1762 return Math::doublePercent(c - s, c);
1763 else
1764 return (-1.0 * Math::doublePercent(s - c, c));
1765}
1766
1767static void
1769{
1770 dlink_node *i;
1771 ClientHttpRequest *http;
1772 StoreEntry *e;
1773 char buf[MAX_IPSTRLEN];
1774
1775 for (i = ClientActiveRequests.head; i; i = i->next) {
1776 const char *p = nullptr;
1777 http = static_cast<ClientHttpRequest *>(i->data);
1778 assert(http);
1779 ConnStateData * conn = http->getConn();
1780 storeAppendPrintf(s, "Connection: %p\n", conn);
1781
1782 if (conn != nullptr) {
1783 const int fd = conn->clientConnection->fd;
1784 storeAppendPrintf(s, "\tFD %d, read %" PRId64 ", wrote %" PRId64 "\n", fd,
1785 fd_table[fd].bytes_read, fd_table[fd].bytes_written);
1786 storeAppendPrintf(s, "\tFD desc: %s\n", fd_table[fd].desc);
1787 storeAppendPrintf(s, "\tin: buf %p, used %ld, free %ld\n",
1788 conn->inBuf.rawContent(), (long int) conn->inBuf.length(), (long int) conn->inBuf.spaceSize());
1789 storeAppendPrintf(s, "\tremote: %s\n",
1790 conn->clientConnection->remote.toUrl(buf,MAX_IPSTRLEN));
1791 storeAppendPrintf(s, "\tlocal: %s\n",
1792 conn->clientConnection->local.toUrl(buf,MAX_IPSTRLEN));
1793 storeAppendPrintf(s, "\tnrequests: %u\n", conn->pipeline.nrequests);
1794 }
1795
1796 storeAppendPrintf(s, "uri %s\n", http->uri);
1797 storeAppendPrintf(s, "logType %s\n", http->loggingTags().c_str());
1798 storeAppendPrintf(s, "out.offset %ld, out.size %lu\n",
1799 (long int) http->out.offset, (unsigned long int) http->out.size);
1800 storeAppendPrintf(s, "req_sz %ld\n", (long int) http->req_sz);
1801 e = http->storeEntry();
1802 storeAppendPrintf(s, "entry %p/%s\n", e, e ? e->getMD5Text() : "N/A");
1803 storeAppendPrintf(s, "start %ld.%06d (%f seconds ago)\n",
1804 (long int) http->al->cache.start_time.tv_sec,
1805 (int) http->al->cache.start_time.tv_usec,
1807#if USE_AUTH
1808 if (http->request->auth_user_request != nullptr)
1809 p = http->request->auth_user_request->username();
1810 else
1811#endif
1812 if (http->request->extacl_user.size() > 0) {
1813 p = http->request->extacl_user.termedBuf();
1814 }
1815
1816 if (!p && conn != nullptr && conn->clientConnection->rfc931[0])
1817 p = conn->clientConnection->rfc931;
1818
1819#if USE_OPENSSL
1820 if (!p && conn != nullptr && Comm::IsConnOpen(conn->clientConnection))
1821 p = sslGetUserEmail(fd_table[conn->clientConnection->fd].ssl.get());
1822#endif
1823
1824 if (!p)
1825 p = dash_str;
1826
1827 storeAppendPrintf(s, "username %s\n", p);
1828
1829#if USE_DELAY_POOLS
1830 storeAppendPrintf(s, "delay_pool %d\n", DelayId::DelayClient(http).pool());
1831#endif
1832
1833 storeAppendPrintf(s, "\n");
1834 }
1835}
1836
1837#if STAT_GRAPHS
1838/*
1839 * urgh, i don't like these, but they do cut the amount of code down immensely
1840 */
1841
1842#define GRAPH_PER_MIN(Y) \
1843 for (i=0;i<(N_COUNT_HIST-2);++i) { \
1844 dt = tvSubDsec(CountHist[i+1].timestamp, CountHist[i].timestamp); \
1845 if (dt <= 0.0) \
1846 break; \
1847 storeAppendPrintf(e, "%lu,%0.2f:", \
1848 CountHist[i].timestamp.tv_sec, \
1849 ((CountHist[i].Y - CountHist[i+1].Y) / dt)); \
1850 }
1851
1852#define GRAPH_PER_HOUR(Y) \
1853 for (i=0;i<(N_COUNT_HOUR_HIST-2);++i) { \
1854 dt = tvSubDsec(CountHourHist[i+1].timestamp, CountHourHist[i].timestamp); \
1855 if (dt <= 0.0) \
1856 break; \
1857 storeAppendPrintf(e, "%lu,%0.2f:", \
1858 CountHourHist[i].timestamp.tv_sec, \
1859 ((CountHourHist[i].Y - CountHourHist[i+1].Y) / dt)); \
1860 }
1861
1862#define GRAPH_TITLE(X,Y) storeAppendPrintf(e,"%s\t%s\t",X,Y);
1863#define GRAPH_END storeAppendPrintf(e,"\n");
1864
1865#define GENGRAPH(X,Y,Z) \
1866 GRAPH_TITLE(Y,Z) \
1867 GRAPH_PER_MIN(X) \
1868 GRAPH_PER_HOUR(X) \
1869 GRAPH_END
1870
1871static void
1872statGraphDump(StoreEntry * e)
1873{
1874 int i;
1875 double dt;
1876
1877 GENGRAPH(client_http.requests, "client_http.requests", "Client HTTP requests/sec");
1878 GENGRAPH(client_http.hits, "client_http.hits", "Client HTTP hits/sec");
1879 GENGRAPH(client_http.errors, "client_http.errors", "Client HTTP errors/sec");
1880 GENGRAPH(client_http.kbytes_in.kb, "client_http.kbytes_in", "Client HTTP kbytes_in/sec");
1881 GENGRAPH(client_http.kbytes_out.kb, "client_http.kbytes_out", "Client HTTP kbytes_out/sec");
1882
1883 // TODO: http median service times
1884
1885 GENGRAPH(server.all.requests, "server.all.requests", "Server requests/sec");
1886 GENGRAPH(server.all.errors, "server.all.errors", "Server errors/sec");
1887 GENGRAPH(server.all.kbytes_in.kb, "server.all.kbytes_in", "Server total kbytes_in/sec");
1888 GENGRAPH(server.all.kbytes_out.kb, "server.all.kbytes_out", "Server total kbytes_out/sec");
1889
1890 GENGRAPH(server.http.requests, "server.http.requests", "Server HTTP requests/sec");
1891 GENGRAPH(server.http.errors, "server.http.errors", "Server HTTP errors/sec");
1892 GENGRAPH(server.http.kbytes_in.kb, "server.http.kbytes_in", "Server HTTP kbytes_in/sec");
1893 GENGRAPH(server.http.kbytes_out.kb, "server.http.kbytes_out", "Server HTTP kbytes_out/sec");
1894
1895 GENGRAPH(server.ftp.requests, "server.ftp.requests", "Server FTP requests/sec");
1896 GENGRAPH(server.ftp.errors, "server.ftp.errors", "Server FTP errors/sec");
1897 GENGRAPH(server.ftp.kbytes_in.kb, "server.ftp.kbytes_in", "Server FTP kbytes_in/sec");
1898 GENGRAPH(server.ftp.kbytes_out.kb, "server.ftp.kbytes_out", "Server FTP kbytes_out/sec");
1899
1900 GENGRAPH(server.other.requests, "server.other.requests", "Server other requests/sec");
1901 GENGRAPH(server.other.errors, "server.other.errors", "Server other errors/sec");
1902 GENGRAPH(server.other.kbytes_in.kb, "server.other.kbytes_in", "Server other kbytes_in/sec");
1903 GENGRAPH(server.other.kbytes_out.kb, "server.other.kbytes_out", "Server other kbytes_out/sec");
1904
1905 GENGRAPH(icp.pkts_sent, "icp.pkts_sent", "ICP packets sent/sec");
1906 GENGRAPH(icp.pkts_recv, "icp.pkts_recv", "ICP packets received/sec");
1907 GENGRAPH(icp.kbytes_sent.kb, "icp.kbytes_sent", "ICP kbytes_sent/sec");
1908 GENGRAPH(icp.kbytes_recv.kb, "icp.kbytes_recv", "ICP kbytes_received/sec");
1909
1910 // TODO: icp median service times
1911 // TODO: dns median service times
1912
1913 GENGRAPH(unlink.requests, "unlink.requests", "Cache File unlink requests/sec");
1914 GENGRAPH(page_faults, "page_faults", "System Page Faults/sec");
1915 GENGRAPH(select_loops, "select_loops", "System Select Loop calls/sec");
1916 GENGRAPH(cputime, "cputime", "CPU utilisation");
1917}
1918
1919#endif /* STAT_GRAPHS */
1920
1921int
1923{
1924 return memPoolsTotalAllocated();
1925}
1926
void cacheDigestGuessStatsReport(const CacheDigestGuessStats *stats, StoreEntry *sentry, const SBuf &label)
Definition: CacheDigest.cc:209
#define INCOMING_TCP_MAX
Definition: Loops.h:69
#define INCOMING_DNS_MAX
Definition: Loops.h:59
#define INCOMING_UDP_MAX
Definition: Loops.h:50
int size
Definition: ModDevPoll.cc:75
#define SQUIDSBUFPH
Definition: SBuf.h:31
#define SQUIDSBUFPRINT(s)
Definition: SBuf.h:32
class SquidConfig Config
Definition: SquidConfig.cc:12
StatCounters statCounter
Definition: StatCounters.cc:12
double statHistDeltaMedian(const StatHist &A, const StatHist &B)
Definition: StatHist.cc:91
double statHistDeltaPctile(const StatHist &A, const StatHist &B, double pctile)
Definition: StatHist.cc:97
int conn
the current server connection FD
Definition: Transport.cc:26
#define assert(EX)
Definition: assert.h:19
static char server[MAXLINE]
#define CBDATA_CLASS_INIT(type)
Definition: cbdata.h:318
#define CBDATA_CLASS(type)
Definition: cbdata.h:302
struct timeval start_time
The time the master transaction started.
class AccessLogEntry::CacheDetails cache
char const * username() const
Definition: UserRequest.cc:32
static void CredentialsCacheStats(StoreEntry *output)
Definition: User.cc:243
size_t kb
Definition: ByteCounter.h:25
uint32_t mask_size
Definition: CacheDigest.h:59
char * host
Definition: CachePeer.h:40
PeerDigest * digest
Definition: CachePeer.h:142
struct ClientHttpRequest::Out out
HttpRequest *const request
ConnStateData * getConn() const
size_t req_sz
raw request size on input, not current request size
StoreEntry * storeEntry() const
const LogTags & loggingTags() const
the processing tags associated with this request transaction.
const AccessLogEntry::Pointer al
access.log entry
static DelayId DelayClient(ClientHttpRequest *, HttpReply *reply=nullptr)
Definition: DelayId.cc:67
String extacl_user
Definition: HttpRequest.h:178
Auth::UserRequest::Pointer auth_user_request
Definition: HttpRequest.h:127
static const int histSize
Definition: IoStats.h:16
int read_hist[histSize]
Definition: IoStats.h:21
struct IoStats::@80 Http
struct IoStats::@80 Ftp
int reads
Definition: IoStats.h:19
const char * c_str() const
compute the status access.log field
Definition: LogTags.cc:66
Definition: MemBuf.h:24
void clean()
Definition: MemBuf.cc:110
virtual void append(const char *c, int sz)
Definition: MemBuf.cc:209
void init(mb_size_t szInit, mb_size_t szMax)
Definition: MemBuf.cc:93
mb_size_t size
Definition: MemBuf.h:135
char * buf
Definition: MemBuf.h:134
StoreIOState::Pointer sio
Definition: MemObject.h:152
SwapOut swapout
Definition: MemObject.h:159
void stat(MemBuf *mb) const
Definition: MemObject.cc:189
mgb_t gb_freed
Definition: Pool.h:110
mgb_t gb_saved
Definition: Pool.h:107
store traffic and resource counters
static Pointer Create(const CommandPointer &cmd)
static Pointer Create(const CommandPointer &cmd)
Definition: InfoAction.cc:105
static Pointer Create60min(const CommandPointer &cmd)
static Pointer Create5min(const CommandPointer &cmd)
store size histograms of network read() from peer server
Definition: IoAction.h:22
static Pointer Create(const CommandPointer &cmd)
Definition: IoAction.cc:43
store service times for 5 and 60 min
static Pointer Create(const CommandPointer &cmd)
void appendf(const char *fmt,...) PRINTF_FORMAT_ARG2
Append operation with printf-style arguments.
Definition: Packable.h:61
Definition: SBuf.h:94
struct SquidConfig::@121 warnings
int objectsPerBucket
Definition: SquidConfig.h:262
struct SquidConfig::@111 onoff
size_t high_memory
Definition: SquidConfig.h:506
struct SquidConfig::@109 Store
ByteCounter kbytes_sent
Definition: StatCounters.h:76
double select_time
Definition: StatCounters.h:120
int aborted_requests
Definition: StatCounters.h:152
StatHist replySvcTime
Definition: StatCounters.h:83
struct StatCounters::@131 htcp
StatHist querySvcTime
Definition: StatCounters.h:82
StatHist select_fds_hist
Definition: StatCounters.h:127
struct StatCounters::@129::@139 all
struct StatCounters::@128 client_http
StatHist nearHitSvcTime
Definition: StatCounters.h:50
CacheDigestGuessStats guess
Definition: StatCounters.h:109
ByteCounter r_kbytes_sent
Definition: StatCounters.h:78
StatHist svcTime
Definition: StatCounters.h:98
struct StatCounters::@137 swap
ByteCounter kbytes_recv
Definition: StatCounters.h:79
StatHist missSvcTime
Definition: StatCounters.h:48
struct StatCounters::@129::@139 other
struct StatCounters::@129::@139 http
unsigned long int select_loops
Definition: StatCounters.h:118
struct StatCounters::@129::@139 ftp
StatHist hitSvcTime
Definition: StatCounters.h:51
uint64_t refusalsDueToZeroSize
Definition: StatCounters.h:163
uint64_t refusalsDueToTimeLimit
Definition: StatCounters.h:164
ByteCounter q_kbytes_sent
Definition: StatCounters.h:77
struct StatCounters::@134 cd
StatHist allSvcTime
Definition: StatCounters.h:52
ByteCounter q_kbytes_recv
Definition: StatCounters.h:80
int query_timeouts
Definition: StatCounters.h:84
double cputime
Definition: StatCounters.h:121
ByteCounter kbytes_out
Definition: StatCounters.h:46
struct StatCounters::@130 icp
ByteCounter r_kbytes_recv
Definition: StatCounters.h:81
StatHist nearMissSvcTime
Definition: StatCounters.h:49
ByteCounter kbytes_in
Definition: StatCounters.h:45
uint64_t attempts
Definition: StatCounters.h:161
ByteCounter hit_kbytes_out
Definition: StatCounters.h:47
ByteCounter memory
Definition: StatCounters.h:105
struct StatCounters::@129 server
int replies_queued
Definition: StatCounters.h:74
uint64_t failures
Definition: StatCounters.h:165
struct StatCounters::@133 dns
uint64_t refusalsDueToLocking
Definition: StatCounters.h:162
struct StatCounters::@132 unlink
struct timeval timestamp
Definition: StatCounters.h:123
struct StatCounters::@138 hitValidation
void dump(StoreEntry *sentry, StatHistBinDumper *bd) const
Definition: StatHist.cc:171
StoreEntry * sentry
Definition: stat.cc:71
StoreSearchPointer theSearch
Definition: stat.cc:73
STOBJFLT * filter
Definition: stat.cc:72
int locks() const
returns a local concurrent use counter, for debugging
Definition: Store.h:269
mem_status_t mem_status
Definition: Store.h:240
uint16_t flags
Definition: Store.h:232
sdirno swap_dirn
Definition: Store.h:238
virtual void buffer()
Definition: store.cc:1568
virtual void flush()
Definition: store.cc:1579
int unlock(const char *context)
Definition: store.cc:442
void complete()
Definition: store.cc:1004
swap_status_t swap_status
Definition: Store.h:246
virtual void append(char const *, int)
Appends a c-string to existing packed data.
Definition: store.cc:776
void lock(const char *context)
Definition: store.cc:418
bool checkDeferRead(int fd) const
Definition: store.cc:228
const char * describeTimestamps() const
Definition: store.cc:1968
const char * getMD5Text() const
Definition: store.cc:204
sfileno swap_filen
unique ID inside a cache_dir for swapped out entries; -1 for others
Definition: Store.h:236
MemObject * mem_obj
Definition: Store.h:221
ping_status_t ping_status
Definition: Store.h:242
store_status_t store_status
Definition: Store.h:244
uint16_t refcount
Definition: Store.h:231
virtual StoreEntry * currentItem()=0
virtual bool isDone() const =0
virtual void getStats(StoreInfoStats &stats) const override
collect statistics
Definition: Controller.cc:111
StoreSearch * search()
Definition: Controller.cc:211
char const * termedBuf() const
Definition: SquidString.h:92
size_type size() const
Definition: SquidString.h:73
static void DumpStats(StoreEntry *)
Definition: fde.cc:96
double count
Definition: Pool.h:84
#define DBG_IMPORTANT
Definition: Stream.h:41
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Stream.h:196
#define DBG_CRITICAL
Definition: Stream.h:40
#define COUNT_INTERVAL
Definition: defines.h:110
#define N_COUNT_HIST
Definition: defines.h:114
#define N_COUNT_HOUR_HIST
Definition: defines.h:118
#define EBIT_TEST(flag, bit)
Definition: defines.h:69
@ PCTILE_HIT
Definition: enums.h:167
@ PCTILE_DNS
Definition: enums.h:166
@ PCTILE_HTTP
Definition: enums.h:164
@ PCTILE_ICP_QUERY
Definition: enums.h:165
@ PCTILE_NH
Definition: enums.h:170
@ PCTILE_NM
Definition: enums.h:169
@ PCTILE_MISS
Definition: enums.h:168
@ ENTRY_BAD_LENGTH
Definition: enums.h:114
@ ENTRY_VALIDATED
Definition: enums.h:113
@ ENTRY_SPECIAL
Definition: enums.h:84
@ KEY_PRIVATE
Definition: enums.h:102
@ ENTRY_FWD_HDR_WAIT
Definition: enums.h:111
@ DELAY_SENDING
Definition: enums.h:97
@ RELEASE_REQUEST
prohibits making the key public
Definition: enums.h:98
@ ENTRY_REVALIDATE_STALE
Definition: enums.h:100
@ ENTRY_DISPATCHED
Definition: enums.h:101
@ ENTRY_ABORTED
Definition: enums.h:115
@ ENTRY_NEGCACHED
Definition: enums.h:112
@ ENTRY_REVALIDATE_ALWAYS
Definition: enums.h:85
@ REFRESH_REQUEST
Definition: enums.h:99
void eventAdd(const char *name, EVH *func, void *arg, double when, int weight, bool cbdata)
Definition: event.cc:107
void EVH(void *)
Definition: event.h:18
int fdNFree(void)
Definition: fd.cc:266
#define fd_table
Definition: fde.h:189
const char * swapStatusStr[]
Definition: store.cc:89
int Opening_FD
struct timeval squid_start
const char * pingStatusStr[]
Definition: store.cc:78
const char * dash_str
int CacheDigestHashFuncCount
const char * memStatusStr[]
Definition: store.cc:73
const char * version_string
int Squid_MaxFD
int Number_FD
CacheDigest * store_digest
const char * storeStatusStr[]
Definition: store.cc:84
int RESERVED_FD
double request_failure_ratio
int Biggest_FD
IoStats IOStats
int KidIdentifier
int memPoolsTotalAllocated(void)
Definition: Pool.cc:298
int memPoolGetGlobalStats(MemPoolGlobalStats *stats)
Definition: Pool.cc:249
const char * sslGetUserEmail(SSL *ssl)
Definition: support.cc:885
#define MAX_IPSTRLEN
Length of buffer that needs to be allocated to old a null-terminated IP-string.
Definition: forward.h:25
static uint32 C
Definition: md4.c:43
void OBJH(StoreEntry *)
Definition: forward.h:44
bool IsConnOpen(const Comm::ConnectionPointer &conn)
Definition: Connection.cc:27
double doublePercent(const double, const double)
Definition: SquidMath.cc:25
void RegisterAction(char const *action, char const *desc, OBJH *handler, int pw_req_flag, int atomic)
Definition: Registration.cc:16
class Ping::pingStats_ stats
Controller & Root()
safely access controller singleton
Definition: Controller.cc:926
const char * FormatRfc1123(time_t)
Definition: rfc1123.cc:202
CachePeer * getNextPeer(CachePeer *p)
Definition: neighbors.cc:501
CachePeer * getFirstPeer(void)
Definition: neighbors.cc:507
static double xm_time
Definition: old_api.cc:41
static double xm_deltat
Definition: old_api.cc:42
void peerDigestStatsReport(const PeerDigest *pd, StoreEntry *e)
#define LOCAL_ARRAY(type, name, size)
Definition: squid.h:68
static int statObjectsOpenfdFilter(const StoreEntry *e)
Definition: stat.cc:398
static double statPctileSvc(double, int, int)
Definition: stat.cc:1624
unsigned int mem_pool_alloc_calls
static OBJH statClientRequests
Definition: stat.cc:95
#define XAVG(X)
Definition: stat.cc:862
static int NCountHist
Definition: stat.cc:115
int stat5minClientRequests(void)
Definition: stat.cc:1687
void DumpInfo(Mgr::InfoActionData &stats, StoreEntry *sentry)
Definition: stat.cc:553
void GetInfo(Mgr::InfoActionData &stats)
Definition: stat.cc:429
static OBJH stat_objects_get
Definition: stat.cc:86
static void statAvgDump(StoreEntry *, int minutes, int hours)
Definition: stat.cc:855
void GetServiceTimesStats(Mgr::ServiceTimesActionData &stats)
Definition: stat.cc:777
StatCounters * snmpStatGet(int minutes)
Definition: stat.cc:1681
double statRequestHitMemoryRatio(int minutes)
Definition: stat.cc:1712
static EVH statObjects
Definition: stat.cc:89
static OBJH stat_vmobjects_get
Definition: stat.cc:87
static void statRegisterWithCacheManager(void)
Definition: stat.cc:1164
static OBJH statDigestBlob
Definition: stat.cc:92
static OBJH statUtilization
Definition: stat.cc:93
void DumpServiceTimesStats(Mgr::ServiceTimesActionData &stats, StoreEntry *sentry)
Definition: stat.cc:805
static void statObjectsStart(StoreEntry *sentry, STOBJFLT *filter)
Definition: stat.cc:367
double statRequestHitRatio(int minutes)
Definition: stat.cc:1702
static void statCountersInit(StatCounters *C)
Definition: stat.cc:1239
void GetAvgStat(Mgr::IntervalActionData &stats, int minutes, int hours)
Definition: stat.cc:864
static StatCounters CountHourHist[N_COUNT_HOUR_HIST]
Definition: stat.cc:116
static OBJH statCountersHistograms
Definition: stat.cc:94
void GetIoStats(Mgr::IoActionData &stats)
Definition: stat.cc:188
double statByteHitRatio(int minutes)
Definition: stat.cc:1732
StatCounters CountHist[N_COUNT_HIST]
Definition: stat.cc:114
static OBJH statPeerSelect
Definition: stat.cc:91
void DumpIoStats(Mgr::IoActionData &stats, StoreEntry *sentry)
Definition: stat.cc:206
int STOBJFLT(const StoreEntry *)
Definition: stat.cc:64
static void statStoreEntry(MemBuf *mb, StoreEntry *e)
Definition: stat.cc:304
static int statObjectsVmFilter(const StoreEntry *e)
Definition: stat.cc:386
double statRequestHitDiskRatio(int minutes)
Definition: stat.cc:1722
void GetCountersStats(Mgr::CountersActionData &stats)
Definition: stat.cc:1355
void DumpMallocStatistics(StoreEntry *sentry)
Definition: stat.cc:763
static void statCountersInitSpecial(StatCounters *C)
Definition: stat.cc:1209
static int NCountHourHist
Definition: stat.cc:117
const char * storeEntryFlags(const StoreEntry *entry)
Definition: stat.cc:251
void DumpAvgStat(Mgr::IntervalActionData &stats, StoreEntry *sentry)
Definition: stat.cc:1000
void DumpCountersStats(Mgr::CountersActionData &stats, StoreEntry *sentry)
Definition: stat.cc:1437
int statMemoryAccounted(void)
Definition: stat.cc:1922
static OBJH statOpenfdObj
Definition: stat.cc:88
static const char * describeStatuses(const StoreEntry *)
Definition: stat.cc:239
void statInit(void)
Definition: stat.cc:1247
static void statAvgTick(void *notused)
Definition: stat.cc:1270
static double statCPUUsage(int minutes)
Definition: stat.cc:1694
static OBJH statCountersDump
Definition: stat.cc:90
unsigned int mem_pool_free_calls
void storeAppendPrintf(StoreEntry *e, const char *fmt,...)
Definition: store.cc:828
int storePendingNClients(const StoreEntry *e)
void storeDigestReport(StoreEntry *e)
uint64_t size
Response header and body bytes written to the client connection.
MemPoolMeter * TheMeter
Definition: Pool.h:304
int unsigned int
Definition: stub_fd.cc:19
double current_dtime
the current UNIX time in seconds (with microsecond precision)
Definition: stub_libtime.cc:19
SBuf service_name(APP_SHORTNAME)
number
Definition: testStatHist.cc:16
double tvSubDsec(struct timeval t1, struct timeval t2)
Definition: gadgets.cc:44
struct timeval current_time
the current UNIX time in timeval {seconds, microseconds} format
Definition: gadgets.cc:17
void squid_getrusage(struct rusage *r)
Definition: tools.cc:177
double rusage_cputime(struct rusage *r)
Definition: tools.cc:235
int rusage_maxrss(struct rusage *r)
Definition: tools.cc:250
int rusage_pagefaults(struct rusage *r)
Definition: tools.cc:271
bool UsingSmp()
Whether there should be more than one worker process running.
Definition: tools.cc:693
#define PRId64
Definition: types.h:110
SQUIDCEXTERN int xpercentInt(double part, double whole)
Definition: util.c:46
SQUIDCEXTERN double xdiv(double nom, double denom)
Definition: util.c:53
#define APP_SHORTNAME
Definition: version.h:22

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors