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

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors