]> git.ipfire.org Git - thirdparty/squid.git/blob - src/stat.cc
projects / thirdparty / squid.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
SourceFormat Enforcement
[thirdparty/squid.git] / src / stat.cc
1 /*
2 * $Id$
3 *
4 * DEBUG: section 18 Cache Manager Statistics
5 * AUTHOR: Harvest Derived
6 *
7 * SQUID Web Proxy Cache http://www.squid-cache.org/
8 * ----------------------------------------------------------
9 *
10 * Squid is the result of efforts by numerous individuals from
11 * the Internet community; see the CONTRIBUTORS file for full
12 * details. Many organizations have provided support for Squid's
13 * development; see the SPONSORS file for full details. Squid is
14 * Copyrighted (C) 2001 by the Regents of the University of
15 * California; see the COPYRIGHT file for full details. Squid
16 * incorporates software developed and/or copyrighted by other
17 * sources; see the CREDITS file for full details.
18 *
19 * This program is free software; you can redistribute it and/or modify
20 * it under the terms of the GNU General Public License as published by
21 * the Free Software Foundation; either version 2 of the License, or
22 * (at your option) any later version.
23 *
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
32 *
33 */
34
35 #include "squid.h"
36 #include "client_side_request.h"
37 #include "client_side.h"
38 #include "comm/Connection.h"
39 #include "comm/Loops.h"
40 #include "event.h"
41 #include "fde.h"
42 #include "format/Token.h"
43 #include "globals.h"
44 #include "HttpRequest.h"
45 #include "MemObject.h"
46 #include "mem_node.h"
47 #include "MemBuf.h"
48 #include "mgr/CountersAction.h"
49 #include "mgr/FunAction.h"
50 #include "mgr/InfoAction.h"
51 #include "mgr/IntervalAction.h"
52 #include "mgr/IoAction.h"
53 #include "mgr/Registration.h"
54 #include "mgr/ServiceTimesAction.h"
55 #include "protos.h"
56 #include "SquidMath.h"
57 #include "SquidTime.h"
58 #include "StatCounters.h"
59 #include "StoreClient.h"
60 #include "Store.h"
61 #if USE_AUTH
62 #include "auth/UserRequest.h"
63 #endif
64 #if USE_DELAY_POOLS
65 #include "DelayId.h"
66 #endif
67 #if USE_SSL
68 #include "ssl/support.h"
69 #endif
70
71 /* these are included because they expose stats calls */
72 /* TODO: provide a self registration mechanism for those classes
73 * to use during static construction
74 */
75 #include "comm.h"
76 #include "StoreSearch.h"
77
78 #define DEBUG_OPENFD 1
79
80 typedef int STOBJFLT(const StoreEntry *);
81
82 class StatObjectsState
83 {
84
85 public:
86 StoreEntry *sentry;
87 STOBJFLT *filter;
88 StoreSearchPointer theSearch;
89
90 private:
91 CBDATA_CLASS2(StatObjectsState);
92 };
93
94 /* LOCALS */
95 static const char *describeStatuses(const StoreEntry *);
96 static const char *describeTimestamps(const StoreEntry *);
97 static void statAvgTick(void *notused);
98 static void statAvgDump(StoreEntry *, int minutes, int hours);
99 #if STAT_GRAPHS
100 static void statGraphDump(StoreEntry *);
101 #endif
102 static void statCountersInit(StatCounters *);
103 static void statCountersInitSpecial(StatCounters *);
104 static void statCountersClean(StatCounters *);
105 static void statCountersCopy(StatCounters * dest, const StatCounters * orig);
106 static double statPctileSvc(double, int, int);
107 static void statStoreEntry(MemBuf * mb, StoreEntry * e);
108 static double statCPUUsage(int minutes);
109 static OBJH stat_objects_get;
110 static OBJH stat_vmobjects_get;
111 #if DEBUG_OPENFD
112 static OBJH statOpenfdObj;
113 #endif
114 static EVH statObjects;
115 static OBJH statCountersDump;
116 static OBJH statPeerSelect;
117 static OBJH statDigestBlob;
118 static OBJH statUtilization;
119 static OBJH statCountersHistograms;
120 static OBJH statClientRequests;
121 void GetAvgStat(Mgr::IntervalActionData& stats, int minutes, int hours);
122 void DumpAvgStat(Mgr::IntervalActionData& stats, StoreEntry* sentry);
123 void GetInfo(Mgr::InfoActionData& stats);
124 void DumpInfo(Mgr::InfoActionData& stats, StoreEntry* sentry);
125 void DumpMallocStatistics(StoreEntry* sentry);
126 void GetCountersStats(Mgr::CountersActionData& stats);
127 void DumpCountersStats(Mgr::CountersActionData& stats, StoreEntry* sentry);
128 void GetServiceTimesStats(Mgr::ServiceTimesActionData& stats);
129 void DumpServiceTimesStats(Mgr::ServiceTimesActionData& stats, StoreEntry* sentry);
130 void GetIoStats(Mgr::IoActionData& stats);
131 void DumpIoStats(Mgr::IoActionData& stats, StoreEntry* sentry);
132
133 #if XMALLOC_STATISTICS
134 static void info_get_mallstat(int, int, int, void *);
135 static double xm_time;
136 static double xm_deltat;
137 #endif
138
139 StatCounters CountHist[N_COUNT_HIST];
140 static int NCountHist = 0;
141 static StatCounters CountHourHist[N_COUNT_HOUR_HIST];
142 static int NCountHourHist = 0;
143 CBDATA_CLASS_INIT(StatObjectsState);
144
145 extern unsigned int mem_pool_alloc_calls;
146 extern unsigned int mem_pool_free_calls;
147
148 static void
149 statUtilization(StoreEntry * e)
150 {
151 storeAppendPrintf(e, "Cache Utilisation:\n");
152 storeAppendPrintf(e, "\n");
153 storeAppendPrintf(e, "Last 5 minutes:\n");
154
155 if (NCountHist >= 5)
156 statAvgDump(e, 5, 0);
157 else
158 storeAppendPrintf(e, "(no values recorded yet)\n");
159
160 storeAppendPrintf(e, "\n");
161
162 storeAppendPrintf(e, "Last 15 minutes:\n");
163
164 if (NCountHist >= 15)
165 statAvgDump(e, 15, 0);
166 else
167 storeAppendPrintf(e, "(no values recorded yet)\n");
168
169 storeAppendPrintf(e, "\n");
170
171 storeAppendPrintf(e, "Last hour:\n");
172
173 if (NCountHist >= 60)
174 statAvgDump(e, 60, 0);
175 else
176 storeAppendPrintf(e, "(no values recorded yet)\n");
177
178 storeAppendPrintf(e, "\n");
179
180 storeAppendPrintf(e, "Last 8 hours:\n");
181
182 if (NCountHourHist >= 8)
183 statAvgDump(e, 0, 8);
184 else
185 storeAppendPrintf(e, "(no values recorded yet)\n");
186
187 storeAppendPrintf(e, "\n");
188
189 storeAppendPrintf(e, "Last day:\n");
190
191 if (NCountHourHist >= 24)
192 statAvgDump(e, 0, 24);
193 else
194 storeAppendPrintf(e, "(no values recorded yet)\n");
195
196 storeAppendPrintf(e, "\n");
197
198 storeAppendPrintf(e, "Last 3 days:\n");
199
200 if (NCountHourHist >= 72)
201 statAvgDump(e, 0, 72);
202 else
203 storeAppendPrintf(e, "(no values recorded yet)\n");
204
205 storeAppendPrintf(e, "\n");
206
207 storeAppendPrintf(e, "Totals since cache startup:\n");
208
209 statCountersDump(e);
210 }
211
212 void
213 GetIoStats(Mgr::IoActionData& stats)
214 {
215 int i;
216
217 stats.http_reads = IOStats.Http.reads;
218
219 for (i = 0; i < _iostats::histSize; ++i) {
220 stats.http_read_hist[i] = IOStats.Http.read_hist[i];
221 }
222
223 stats.ftp_reads = IOStats.Ftp.reads;
224
225 for (i = 0; i < _iostats::histSize; ++i) {
226 stats.ftp_read_hist[i] = IOStats.Ftp.read_hist[i];
227 }
228
229 stats.gopher_reads = IOStats.Gopher.reads;
230
231 for (i = 0; i < _iostats::histSize; ++i) {
232 stats.gopher_read_hist[i] = IOStats.Gopher.read_hist[i];
233 }
234 }
235
236 void
237 DumpIoStats(Mgr::IoActionData& stats, StoreEntry* sentry)
238 {
239 int i;
240
241 storeAppendPrintf(sentry, "HTTP I/O\n");
242 storeAppendPrintf(sentry, "number of reads: %.0f\n", stats.http_reads);
243 storeAppendPrintf(sentry, "Read Histogram:\n");
244
245 for (i = 0; i < _iostats::histSize; ++i) {
246 storeAppendPrintf(sentry, "%5d-%5d: %9.0f %2.0f%%\n",
247 i ? (1 << (i - 1)) + 1 : 1,
248 1 << i,
249 stats.http_read_hist[i],
250 Math::doublePercent(stats.http_read_hist[i], stats.http_reads));
251 }
252
253 storeAppendPrintf(sentry, "\n");
254 storeAppendPrintf(sentry, "FTP I/O\n");
255 storeAppendPrintf(sentry, "number of reads: %.0f\n", stats.ftp_reads);
256 storeAppendPrintf(sentry, "Read Histogram:\n");
257
258 for (i = 0; i < _iostats::histSize; ++i) {
259 storeAppendPrintf(sentry, "%5d-%5d: %9.0f %2.0f%%\n",
260 i ? (1 << (i - 1)) + 1 : 1,
261 1 << i,
262 stats.ftp_read_hist[i],
263 Math::doublePercent(stats.ftp_read_hist[i], stats.ftp_reads));
264 }
265
266 storeAppendPrintf(sentry, "\n");
267 storeAppendPrintf(sentry, "Gopher I/O\n");
268 storeAppendPrintf(sentry, "number of reads: %.0f\n", stats.gopher_reads);
269 storeAppendPrintf(sentry, "Read Histogram:\n");
270
271 for (i = 0; i < _iostats::histSize; ++i) {
272 storeAppendPrintf(sentry, "%5d-%5d: %9.0f %2.0f%%\n",
273 i ? (1 << (i - 1)) + 1 : 1,
274 1 << i,
275 stats.gopher_read_hist[i],
276 Math::doublePercent(stats.gopher_read_hist[i], stats.gopher_reads));
277 }
278
279 storeAppendPrintf(sentry, "\n");
280 }
281
282 static const char *
283 describeStatuses(const StoreEntry * entry)
284 {
285 LOCAL_ARRAY(char, buf, 256);
286 snprintf(buf, 256, "%-13s %-13s %-12s %-12s",
287 storeStatusStr[entry->store_status],
288 memStatusStr[entry->mem_status],
289 swapStatusStr[entry->swap_status],
290 pingStatusStr[entry->ping_status]);
291 return buf;
292 }
293
294 const char *
295 storeEntryFlags(const StoreEntry * entry)
296 {
297 LOCAL_ARRAY(char, buf, 256);
298 int flags = (int) entry->flags;
299 char *t;
300 buf[0] = '\0';
301
302 if (EBIT_TEST(flags, ENTRY_SPECIAL))
303 strcat(buf, "SPECIAL,");
304
305 if (EBIT_TEST(flags, ENTRY_REVALIDATE))
306 strcat(buf, "REVALIDATE,");
307
308 if (EBIT_TEST(flags, DELAY_SENDING))
309 strcat(buf, "DELAY_SENDING,");
310
311 if (EBIT_TEST(flags, RELEASE_REQUEST))
312 strcat(buf, "RELEASE_REQUEST,");
313
314 if (EBIT_TEST(flags, REFRESH_REQUEST))
315 strcat(buf, "REFRESH_REQUEST,");
316
317 if (EBIT_TEST(flags, ENTRY_CACHABLE))
318 strcat(buf, "CACHABLE,");
319
320 if (EBIT_TEST(flags, ENTRY_DISPATCHED))
321 strcat(buf, "DISPATCHED,");
322
323 if (EBIT_TEST(flags, KEY_PRIVATE))
324 strcat(buf, "PRIVATE,");
325
326 if (EBIT_TEST(flags, ENTRY_FWD_HDR_WAIT))
327 strcat(buf, "FWD_HDR_WAIT,");
328
329 if (EBIT_TEST(flags, ENTRY_NEGCACHED))
330 strcat(buf, "NEGCACHED,");
331
332 if (EBIT_TEST(flags, ENTRY_VALIDATED))
333 strcat(buf, "VALIDATED,");
334
335 if (EBIT_TEST(flags, ENTRY_BAD_LENGTH))
336 strcat(buf, "BAD_LENGTH,");
337
338 if (EBIT_TEST(flags, ENTRY_ABORTED))
339 strcat(buf, "ABORTED,");
340
341 if ((t = strrchr(buf, ',')))
342 *t = '\0';
343
344 return buf;
345 }
346
347 static const char *
348 describeTimestamps(const StoreEntry * entry)
349 {
350 LOCAL_ARRAY(char, buf, 256);
351 snprintf(buf, 256, "LV:%-9d LU:%-9d LM:%-9d EX:%-9d",
352 (int) entry->timestamp,
353 (int) entry->lastref,
354 (int) entry->lastmod,
355 (int) entry->expires);
356 return buf;
357 }
358
359 static void
360 statStoreEntry(MemBuf * mb, StoreEntry * e)
361 {
362 MemObject *mem = e->mem_obj;
363 mb->Printf("KEY %s\n", e->getMD5Text());
364 mb->Printf("\t%s\n", describeStatuses(e));
365 mb->Printf("\t%s\n", storeEntryFlags(e));
366 mb->Printf("\t%s\n", describeTimestamps(e));
367 mb->Printf("\t%d locks, %d clients, %d refs\n",
368 (int) e->lock_count,
369 storePendingNClients(e),
370 (int) e->refcount);
371 mb->Printf("\tSwap Dir %d, File %#08X\n",
372 e->swap_dirn, e->swap_filen);
373
374 if (mem != NULL)
375 mem->stat (mb);
376
377 mb->Printf("\n");
378 }
379
380 /* process objects list */
381 static void
382 statObjects(void *data)
383 {
384 StatObjectsState *state = static_cast<StatObjectsState *>(data);
385 StoreEntry *e;
386
387 if (state->theSearch->isDone()) {
388 if (UsingSmp())
389 storeAppendPrintf(state->sentry, "} by kid%d\n\n", KidIdentifier);
390 state->sentry->complete();
391 state->sentry->unlock();
392 cbdataFree(state);
393 return;
394 } else if (EBIT_TEST(state->sentry->flags, ENTRY_ABORTED)) {
395 state->sentry->unlock();
396 cbdataFree(state);
397 return;
398 } else if (state->sentry->checkDeferRead(-1)) {
399 state->sentry->flush();
400 eventAdd("statObjects", statObjects, state, 0.1, 1);
401 return;
402 }
403
404 state->sentry->buffer();
405 size_t statCount = 0;
406 MemBuf mb;
407 mb.init();
408
409 while (statCount++ < static_cast<size_t>(Config.Store.objectsPerBucket) && state->
410 theSearch->next()) {
411 e = state->theSearch->currentItem();
412
413 if (state->filter && 0 == state->filter(e))
414 continue;
415
416 statStoreEntry(&mb, e);
417 }
418
419 if (mb.size)
420 state->sentry->append(mb.buf, mb.size);
421 mb.clean();
422
423 eventAdd("statObjects", statObjects, state, 0.0, 1);
424 }
425
426 static void
427 statObjectsStart(StoreEntry * sentry, STOBJFLT * filter)
428 {
429 StatObjectsState *state = new StatObjectsState;
430 state->sentry = sentry;
431 state->filter = filter;
432
433 sentry->lock();
434 state->theSearch = Store::Root().search(NULL, NULL);
435
436 eventAdd("statObjects", statObjects, state, 0.0, 1);
437 }
438
439 static void
440 stat_objects_get(StoreEntry * sentry)
441 {
442 statObjectsStart(sentry, NULL);
443 }
444
445 static int
446 statObjectsVmFilter(const StoreEntry * e)
447 {
448 return e->mem_obj ? 1 : 0;
449 }
450
451 static void
452 stat_vmobjects_get(StoreEntry * sentry)
453 {
454 statObjectsStart(sentry, statObjectsVmFilter);
455 }
456
457 #if DEBUG_OPENFD
458 static int
459 statObjectsOpenfdFilter(const StoreEntry * e)
460 {
461 if (e->mem_obj == NULL)
462 return 0;
463
464 if (e->mem_obj->swapout.sio == NULL)
465 return 0;
466
467 return 1;
468 }
469
470 static void
471 statOpenfdObj(StoreEntry * sentry)
472 {
473 statObjectsStart(sentry, statObjectsOpenfdFilter);
474 }
475
476 #endif
477
478 #if XMALLOC_STATISTICS
479 static void
480 info_get_mallstat(int size, int number, int oldnum, void *data)
481 {
482 StoreEntry *sentry = (StoreEntry *)data;
483
484 // format: "%12s %15s %6s %12s\n","Alloc Size","Count","Delta","Alloc/sec"
485 if (number > 0)
486 storeAppendPrintf(sentry, "%12d %15d %6d %.1f\n", size, number, number - oldnum, xdiv((number - oldnum), xm_deltat));
487 }
488
489 #endif
490
491 void
492 GetInfo(Mgr::InfoActionData& stats)
493 {
494
495 struct rusage rusage;
496 double cputime;
497 double runtime;
498 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
499
500 struct mstats ms;
501 #elif HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
502
503 struct mallinfo mp;
504 #endif
505
506 runtime = tvSubDsec(squid_start, current_time);
507
508 if (runtime == 0.0)
509 runtime = 1.0;
510
511 stats.squid_start = squid_start;
512
513 stats.current_time = current_time;
514
515 stats.client_http_clients = statCounter.client_http.clients;
516
517 stats.client_http_requests = statCounter.client_http.requests;
518
519 stats.icp_pkts_recv = statCounter.icp.pkts_recv;
520
521 stats.icp_pkts_sent = statCounter.icp.pkts_sent;
522
523 stats.icp_replies_queued = statCounter.icp.replies_queued;
524
525 #if USE_HTCP
526
527 stats.htcp_pkts_recv = statCounter.htcp.pkts_recv;
528
529 stats.htcp_pkts_sent = statCounter.htcp.pkts_sent;
530
531 #endif
532
533 stats.request_failure_ratio = request_failure_ratio;
534
535 stats.avg_client_http_requests = statCounter.client_http.requests / (runtime / 60.0);
536
537 stats.avg_icp_messages = (statCounter.icp.pkts_sent + statCounter.icp.pkts_recv) / (runtime / 60.0);
538
539 stats.select_loops = statCounter.select_loops;
540 stats.avg_loop_time = 1000.0 * runtime / statCounter.select_loops;
541
542 stats.request_hit_ratio5 = statRequestHitRatio(5);
543 stats.request_hit_ratio60 = statRequestHitRatio(60);
544
545 stats.byte_hit_ratio5 = statByteHitRatio(5);
546 stats.byte_hit_ratio60 = statByteHitRatio(60);
547
548 stats.request_hit_mem_ratio5 = statRequestHitMemoryRatio(5);
549 stats.request_hit_mem_ratio60 = statRequestHitMemoryRatio(60);
550
551 stats.request_hit_disk_ratio5 = statRequestHitDiskRatio(5);
552 stats.request_hit_disk_ratio60 = statRequestHitDiskRatio(60);
553
554 Store::Root().getStats(stats.store);
555
556 stats.unlink_requests = statCounter.unlink.requests;
557
558 stats.http_requests5 = statPctileSvc(0.5, 5, PCTILE_HTTP);
559 stats.http_requests60 = statPctileSvc(0.5, 60, PCTILE_HTTP);
560
561 stats.cache_misses5 = statPctileSvc(0.5, 5, PCTILE_MISS);
562 stats.cache_misses60 = statPctileSvc(0.5, 60, PCTILE_MISS);
563
564 stats.cache_hits5 = statPctileSvc(0.5, 5, PCTILE_HIT);
565 stats.cache_hits60 = statPctileSvc(0.5, 60, PCTILE_HIT);
566
567 stats.near_hits5 = statPctileSvc(0.5, 5, PCTILE_NH);
568 stats.near_hits60 = statPctileSvc(0.5, 60, PCTILE_NH);
569
570 stats.not_modified_replies5 = statPctileSvc(0.5, 5, PCTILE_NM);
571 stats.not_modified_replies60 = statPctileSvc(0.5, 60, PCTILE_NM);
572
573 stats.dns_lookups5 = statPctileSvc(0.5, 5, PCTILE_DNS);
574 stats.dns_lookups60 = statPctileSvc(0.5, 60, PCTILE_DNS);
575
576 stats.icp_queries5 = statPctileSvc(0.5, 5, PCTILE_ICP_QUERY);
577 stats.icp_queries60 = statPctileSvc(0.5, 60, PCTILE_ICP_QUERY);
578
579 squid_getrusage(&rusage);
580 cputime = rusage_cputime(&rusage);
581
582 stats.up_time = runtime;
583 stats.cpu_time = cputime;
584 stats.cpu_usage = Math::doublePercent(cputime, runtime);
585 stats.cpu_usage5 = statCPUUsage(5);
586 stats.cpu_usage60 = statCPUUsage(60);
587
588 #if HAVE_SBRK
589
590 stats.proc_data_seg = ((char *) sbrk(0) - (char *) sbrk_start);
591
592 #endif
593
594 stats.maxrss = rusage_maxrss(&rusage);
595
596 stats.page_faults = rusage_pagefaults(&rusage);
597
598 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
599
600 ms = mstats();
601
602 stats.ms_bytes_total = ms.bytes_total;
603
604 stats.ms_bytes_free = ms.bytes_free;
605
606 #elif HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
607
608 mp = mallinfo();
609
610 stats.mp_arena = mp.arena;
611
612 stats.mp_uordblks = mp.uordblks;
613 stats.mp_ordblks = mp.ordblks;
614
615 stats.mp_usmblks = mp.usmblks;
616 stats.mp_smblks = mp.smblks;
617
618 stats.mp_hblkhd = mp.hblkhd;
619 stats.mp_hblks = mp.hblks;
620
621 stats.mp_fsmblks = mp.fsmblks;
622
623 stats.mp_fordblks = mp.fordblks;
624
625 #if HAVE_STRUCT_MALLINFO_MXFAST
626
627 stats.mp_mxfast = mp.mxfast;
628
629 stats.mp_nlblks = mp.nlblks;
630
631 stats.mp_grain = mp.grain;
632
633 stats.mp_uordbytes = mp.uordbytes;
634
635 stats.mp_allocated = mp.allocated;
636
637 stats.mp_treeoverhead = mp.treeoverhead;
638
639 #endif /* HAVE_STRUCT_MALLINFO_MXFAST */
640 #endif /* HAVE_MALLINFO */
641
642 stats.total_accounted = statMemoryAccounted();
643
644 {
645 MemPoolGlobalStats mp_stats;
646 memPoolGetGlobalStats(&mp_stats);
647 #if !(HAVE_MSTATS && HAVE_GNUMALLOC_H) && HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
648
649 stats.mem_pool_allocated = mp_stats.TheMeter->alloc.level;
650 #endif
651
652 stats.gb_saved_count = mp_stats.TheMeter->gb_saved.count;
653 stats.gb_freed_count = mp_stats.TheMeter->gb_freed.count;
654 }
655
656 stats.max_fd = Squid_MaxFD;
657 stats.biggest_fd = Biggest_FD;
658 stats.number_fd = Number_FD;
659 stats.opening_fd = Opening_FD;
660 stats.num_fd_free = fdNFree();
661 stats.reserved_fd = RESERVED_FD;
662 }
663
664 void
665 DumpInfo(Mgr::InfoActionData& stats, StoreEntry* sentry)
666 {
667 storeAppendPrintf(sentry, "Squid Object Cache: Version %s\n",
668 version_string);
669
670 #if _SQUID_WINDOWS_
671 if (WIN32_run_mode == _WIN_SQUID_RUN_MODE_SERVICE) {
672 storeAppendPrintf(sentry,"\nRunning as %s Windows System Service on %s\n",
673 WIN32_Service_name, WIN32_OS_string);
674 storeAppendPrintf(sentry,"Service command line is: %s\n", WIN32_Service_Command_Line);
675 } else
676 storeAppendPrintf(sentry,"Running on %s\n",WIN32_OS_string);
677 #endif
678
679 storeAppendPrintf(sentry, "Start Time:\t%s\n",
680 mkrfc1123(stats.squid_start.tv_sec));
681
682 storeAppendPrintf(sentry, "Current Time:\t%s\n",
683 mkrfc1123(stats.current_time.tv_sec));
684
685 storeAppendPrintf(sentry, "Connection information for %s:\n",APP_SHORTNAME);
686
687 storeAppendPrintf(sentry, "\tNumber of clients accessing cache:\t%.0f\n",
688 stats.client_http_clients);
689
690 storeAppendPrintf(sentry, "\tNumber of HTTP requests received:\t%.0f\n",
691 stats.client_http_requests);
692
693 storeAppendPrintf(sentry, "\tNumber of ICP messages received:\t%.0f\n",
694 stats.icp_pkts_recv);
695
696 storeAppendPrintf(sentry, "\tNumber of ICP messages sent:\t%.0f\n",
697 stats.icp_pkts_sent);
698
699 storeAppendPrintf(sentry, "\tNumber of queued ICP replies:\t%.0f\n",
700 stats.icp_replies_queued);
701
702 #if USE_HTCP
703
704 storeAppendPrintf(sentry, "\tNumber of HTCP messages received:\t%.0f\n",
705 stats.htcp_pkts_recv);
706
707 storeAppendPrintf(sentry, "\tNumber of HTCP messages sent:\t%.0f\n",
708 stats.htcp_pkts_sent);
709
710 #endif
711
712 double fct = stats.count > 1 ? stats.count : 1.0;
713 storeAppendPrintf(sentry, "\tRequest failure ratio:\t%5.2f\n",
714 stats.request_failure_ratio / fct);
715
716 storeAppendPrintf(sentry, "\tAverage HTTP requests per minute since start:\t%.1f\n",
717 stats.avg_client_http_requests);
718
719 storeAppendPrintf(sentry, "\tAverage ICP messages per minute since start:\t%.1f\n",
720 stats.avg_icp_messages);
721
722 storeAppendPrintf(sentry, "\tSelect loop called: %.0f times, %0.3f ms avg\n",
723 stats.select_loops, stats.avg_loop_time / fct);
724
725 storeAppendPrintf(sentry, "Cache information for %s:\n",APP_SHORTNAME);
726
727 storeAppendPrintf(sentry, "\tHits as %% of all requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
728 stats.request_hit_ratio5 / fct,
729 stats.request_hit_ratio60 / fct);
730
731 storeAppendPrintf(sentry, "\tHits as %% of bytes sent:\t5min: %3.1f%%, 60min: %3.1f%%\n",
732 stats.byte_hit_ratio5 / fct,
733 stats.byte_hit_ratio60 / fct);
734
735 storeAppendPrintf(sentry, "\tMemory hits as %% of hit requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
736 stats.request_hit_mem_ratio5 / fct,
737 stats.request_hit_mem_ratio60 / fct);
738
739 storeAppendPrintf(sentry, "\tDisk hits as %% of hit requests:\t5min: %3.1f%%, 60min: %3.1f%%\n",
740 stats.request_hit_disk_ratio5 / fct,
741 stats.request_hit_disk_ratio60 / fct);
742
743 storeAppendPrintf(sentry, "\tStorage Swap size:\t%.0f KB\n",
744 stats.store.swap.size / 1024);
745
746 storeAppendPrintf(sentry, "\tStorage Swap capacity:\t%4.1f%% used, %4.1f%% free\n",
747 Math::doublePercent(stats.store.swap.size, stats.store.swap.capacity),
748 Math::doublePercent(stats.store.swap.available(), stats.store.swap.capacity));
749
750 storeAppendPrintf(sentry, "\tStorage Mem size:\t%.0f KB\n",
751 stats.store.mem.size / 1024);
752
753 storeAppendPrintf(sentry, "\tStorage Mem capacity:\t%4.1f%% used, %4.1f%% free\n",
754 Math::doublePercent(stats.store.mem.size, stats.store.mem.capacity),
755 Math::doublePercent(stats.store.mem.available(), stats.store.mem.capacity));
756
757 storeAppendPrintf(sentry, "\tMean Object Size:\t%0.2f KB\n",
758 stats.store.swap.meanObjectSize() / 1024);
759
760 storeAppendPrintf(sentry, "\tRequests given to unlinkd:\t%.0f\n",
761 stats.unlink_requests);
762
763 storeAppendPrintf(sentry, "Median Service Times (seconds) 5 min 60 min:\n");
764
765 fct = stats.count > 1 ? stats.count * 1000.0 : 1000.0;
766 storeAppendPrintf(sentry, "\tHTTP Requests (All): %8.5f %8.5f\n",
767 stats.http_requests5 / fct,
768 stats.http_requests60 / fct);
769
770 storeAppendPrintf(sentry, "\tCache Misses: %8.5f %8.5f\n",
771 stats.cache_misses5 / fct,
772 stats.cache_misses60 / fct);
773
774 storeAppendPrintf(sentry, "\tCache Hits: %8.5f %8.5f\n",
775 stats.cache_hits5 / fct,
776 stats.cache_hits60 / fct);
777
778 storeAppendPrintf(sentry, "\tNear Hits: %8.5f %8.5f\n",
779 stats.near_hits5 / fct,
780 stats.near_hits60 / fct);
781
782 storeAppendPrintf(sentry, "\tNot-Modified Replies: %8.5f %8.5f\n",
783 stats.not_modified_replies5 / fct,
784 stats.not_modified_replies60 / fct);
785
786 storeAppendPrintf(sentry, "\tDNS Lookups: %8.5f %8.5f\n",
787 stats.dns_lookups5 / fct,
788 stats.dns_lookups60 / fct);
789
790 fct = stats.count > 1 ? stats.count * 1000000.0 : 1000000.0;
791 storeAppendPrintf(sentry, "\tICP Queries: %8.5f %8.5f\n",
792 stats.icp_queries5 / fct,
793 stats.icp_queries60 / fct);
794
795 storeAppendPrintf(sentry, "Resource usage for %s:\n", APP_SHORTNAME);
796
797 storeAppendPrintf(sentry, "\tUP Time:\t%.3f seconds\n", stats.up_time);
798
799 storeAppendPrintf(sentry, "\tCPU Time:\t%.3f seconds\n", stats.cpu_time);
800
801 storeAppendPrintf(sentry, "\tCPU Usage:\t%.2f%%\n",
802 stats.cpu_usage);
803
804 storeAppendPrintf(sentry, "\tCPU Usage, 5 minute avg:\t%.2f%%\n",
805 stats.cpu_usage5);
806
807 storeAppendPrintf(sentry, "\tCPU Usage, 60 minute avg:\t%.2f%%\n",
808 stats.cpu_usage60);
809
810 #if HAVE_SBRK
811
812 storeAppendPrintf(sentry, "\tProcess Data Segment Size via sbrk(): %.0f KB\n",
813 stats.proc_data_seg / 1024);
814
815 #endif
816
817 storeAppendPrintf(sentry, "\tMaximum Resident Size: %.0f KB\n",
818 stats.maxrss);
819
820 storeAppendPrintf(sentry, "\tPage faults with physical i/o: %.0f\n",
821 stats.page_faults);
822
823 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
824
825 storeAppendPrintf(sentry, "Memory usage for %s via mstats():\n",APP_SHORTNAME);
826
827 storeAppendPrintf(sentry, "\tTotal space in arena: %6.0f KB\n",
828 stats.ms_bytes_total / 1024);
829
830 storeAppendPrintf(sentry, "\tTotal free: %6.0f KB %.0f%%\n",
831 stats.ms_bytes_free / 1024,
832 Math::doublePercent(stats.ms_bytes_free, stats.ms_bytes_total));
833
834 #elif HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
835
836 storeAppendPrintf(sentry, "Memory usage for %s via mallinfo():\n",APP_SHORTNAME);
837
838 storeAppendPrintf(sentry, "\tTotal space in arena: %6.0f KB\n",
839 stats.mp_arena / 1024);
840
841 storeAppendPrintf(sentry, "\tOrdinary blocks: %6.0f KB %6.0f blks\n",
842 stats.mp_uordblks / 1024, stats.mp_ordblks);
843
844 storeAppendPrintf(sentry, "\tSmall blocks: %6.0f KB %6.0f blks\n",
845 stats.mp_usmblks / 1024, stats.mp_smblks);
846
847 storeAppendPrintf(sentry, "\tHolding blocks: %6.0f KB %6.0f blks\n",
848 stats.mp_hblkhd / 1024, stats.mp_hblks);
849
850 storeAppendPrintf(sentry, "\tFree Small blocks: %6.0f KB\n",
851 stats.mp_fsmblks / 1024);
852
853 storeAppendPrintf(sentry, "\tFree Ordinary blocks: %6.0f KB\n",
854 stats.mp_fordblks / 1024);
855
856 double t = stats.mp_fsmblks + stats.mp_fordblks;
857
858 storeAppendPrintf(sentry, "\tTotal in use: %6.0f KB %.0f%%\n",
859 t / 1024, Math::doublePercent(t, stats.mp_arena + stats.mp_hblkhd));
860
861 t = stats.mp_fsmblks + stats.mp_fordblks;
862
863 storeAppendPrintf(sentry, "\tTotal free: %6.0f KB %.0f%%\n",
864 t / 1024, Math::doublePercent(t, stats.mp_arena + stats.mp_hblkhd));
865
866 t = stats.mp_arena + stats.mp_hblkhd;
867
868 storeAppendPrintf(sentry, "\tTotal size: %6.0f KB\n",
869 t / 1024);
870
871 #if HAVE_STRUCT_MALLINFO_MXFAST
872
873 storeAppendPrintf(sentry, "\tmax size of small blocks:\t%.0f\n", stats.mp_mxfast);
874
875 storeAppendPrintf(sentry, "\tnumber of small blocks in a holding block:\t%.0f\n",
876 stats.mp_nlblks);
877
878 storeAppendPrintf(sentry, "\tsmall block rounding factor:\t%.0f\n", stats.mp_grain);
879
880 storeAppendPrintf(sentry, "\tspace (including overhead) allocated in ord. blks:\t%.0f\n"
881 ,stats.mp_uordbytes);
882
883 storeAppendPrintf(sentry, "\tnumber of ordinary blocks allocated:\t%.0f\n",
884 stats.mp_allocated);
885
886 storeAppendPrintf(sentry, "\tbytes used in maintaining the free tree:\t%.0f\n",
887 stats.mp_treeoverhead);
888
889 #endif /* HAVE_STRUCT_MALLINFO_MXFAST */
890 #endif /* HAVE_MALLINFO */
891
892 storeAppendPrintf(sentry, "Memory accounted for:\n");
893
894 #if !(HAVE_MSTATS && HAVE_GNUMALLOC_H) && HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
895
896 storeAppendPrintf(sentry, "\tTotal accounted: %6.0f KB %3.0f%%\n",
897 stats.total_accounted / 1024, Math::doublePercent(stats.total_accounted, t));
898
899 #else
900
901 storeAppendPrintf(sentry, "\tTotal accounted: %6.0f KB\n",
902 stats.total_accounted / 1024);
903
904 #endif
905 {
906 MemPoolGlobalStats mp_stats;
907 memPoolGetGlobalStats(&mp_stats);
908 #if !(HAVE_MSTATS && HAVE_GNUMALLOC_H) && HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
909
910 storeAppendPrintf(sentry, "\tmemPool accounted: %6.0f KB %3.0f%%\n",
911 stats.mem_pool_allocated / 1024,
912 Math::doublePercent(stats.mem_pool_allocated, t));
913
914 const double iFree = max(0.0, t - stats.mem_pool_allocated);
915 storeAppendPrintf(sentry, "\tmemPool unaccounted: %6.0f KB %3.0f%%\n",
916 (t - stats.mem_pool_allocated) / 1024,
917 Math::doublePercent(iFree, t));
918 #endif
919
920 storeAppendPrintf(sentry, "\tmemPoolAlloc calls: %9.0f\n",
921 stats.gb_saved_count);
922 storeAppendPrintf(sentry, "\tmemPoolFree calls: %9.0f\n",
923 stats.gb_freed_count);
924 }
925
926 storeAppendPrintf(sentry, "File descriptor usage for %s:\n", APP_SHORTNAME);
927 storeAppendPrintf(sentry, "\tMaximum number of file descriptors: %4.0f\n",
928 stats.max_fd);
929 storeAppendPrintf(sentry, "\tLargest file desc currently in use: %4.0f\n",
930 stats.biggest_fd);
931 storeAppendPrintf(sentry, "\tNumber of file desc currently in use: %4.0f\n",
932 stats.number_fd);
933 storeAppendPrintf(sentry, "\tFiles queued for open: %4.0f\n",
934 stats.opening_fd);
935 storeAppendPrintf(sentry, "\tAvailable number of file descriptors: %4.0f\n",
936 stats.num_fd_free);
937 storeAppendPrintf(sentry, "\tReserved number of file descriptors: %4.0f\n",
938 stats.reserved_fd);
939 storeAppendPrintf(sentry, "\tStore Disk files open: %4.0f\n",
940 stats.store.swap.open_disk_fd);
941
942 storeAppendPrintf(sentry, "Internal Data Structures:\n");
943 storeAppendPrintf(sentry, "\t%6.0f StoreEntries\n",
944 stats.store.store_entry_count);
945 storeAppendPrintf(sentry, "\t%6.0f StoreEntries with MemObjects\n",
946 stats.store.mem_object_count);
947 storeAppendPrintf(sentry, "\t%6.0f Hot Object Cache Items\n",
948 stats.store.mem.count);
949 storeAppendPrintf(sentry, "\t%6.0f on-disk objects\n",
950 stats.store.swap.count);
951 }
952
953 void
954 DumpMallocStatistics(StoreEntry* sentry)
955 {
956 #if XMALLOC_STATISTICS
957
958 xm_deltat = current_dtime - xm_time;
959 xm_time = current_dtime;
960 storeAppendPrintf(sentry, "\nMemory allocation statistics\n");
961 storeAppendPrintf(sentry, "%12s %15s %6s %12s\n","Alloc Size","Count","Delta","Alloc/sec");
962 malloc_statistics(info_get_mallstat, sentry);
963 #endif
964 }
965
966 void
967 GetServiceTimesStats(Mgr::ServiceTimesActionData& stats)
968 {
969 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
970 double p = (i + 1) * 5 / 100.0;
971 stats.http_requests5[i] = statPctileSvc(p, 5, PCTILE_HTTP);
972 stats.http_requests60[i] = statPctileSvc(p, 60, PCTILE_HTTP);
973
974 stats.cache_misses5[i] = statPctileSvc(p, 5, PCTILE_MISS);
975 stats.cache_misses60[i] = statPctileSvc(p, 60, PCTILE_MISS);
976
977 stats.cache_hits5[i] = statPctileSvc(p, 5, PCTILE_HIT);
978 stats.cache_hits60[i] = statPctileSvc(p, 60, PCTILE_HIT);
979
980 stats.near_hits5[i] = statPctileSvc(p, 5, PCTILE_NH);
981 stats.near_hits60[i] = statPctileSvc(p, 60, PCTILE_NH);
982
983 stats.not_modified_replies5[i] = statPctileSvc(p, 5, PCTILE_NM);
984 stats.not_modified_replies60[i] = statPctileSvc(p, 60, PCTILE_NM);
985
986 stats.dns_lookups5[i] = statPctileSvc(p, 5, PCTILE_DNS);
987 stats.dns_lookups60[i] = statPctileSvc(p, 60, PCTILE_DNS);
988
989 stats.icp_queries5[i] = statPctileSvc(p, 5, PCTILE_ICP_QUERY);
990 stats.icp_queries60[i] = statPctileSvc(p, 60, PCTILE_ICP_QUERY);
991 }
992 }
993
994 void
995 DumpServiceTimesStats(Mgr::ServiceTimesActionData& stats, StoreEntry* sentry)
996 {
997 storeAppendPrintf(sentry, "Service Time Percentiles 5 min 60 min:\n");
998 double fct = stats.count > 1 ? stats.count * 1000.0 : 1000.0;
999 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1000 storeAppendPrintf(sentry, "\tHTTP Requests (All): %2d%% %8.5f %8.5f\n",
1001 (i + 1) * 5,
1002 stats.http_requests5[i] / fct,
1003 stats.http_requests60[i] / fct);
1004 }
1005 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1006 storeAppendPrintf(sentry, "\tCache Misses: %2d%% %8.5f %8.5f\n",
1007 (i + 1) * 5,
1008 stats.cache_misses5[i] / fct,
1009 stats.cache_misses60[i] / fct);
1010 }
1011 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1012 storeAppendPrintf(sentry, "\tCache Hits: %2d%% %8.5f %8.5f\n",
1013 (i + 1) * 5,
1014 stats.cache_hits5[i] / fct,
1015 stats.cache_hits60[i] / fct);
1016 }
1017 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1018 storeAppendPrintf(sentry, "\tNear Hits: %2d%% %8.5f %8.5f\n",
1019 (i + 1) * 5,
1020 stats.near_hits5[i] / fct,
1021 stats.near_hits60[i] / fct);
1022 }
1023 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1024 storeAppendPrintf(sentry, "\tNot-Modified Replies: %2d%% %8.5f %8.5f\n",
1025 (i + 1) * 5,
1026 stats.not_modified_replies5[i] / fct,
1027 stats.not_modified_replies60[i] / fct);
1028 }
1029 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1030 storeAppendPrintf(sentry, "\tDNS Lookups: %2d%% %8.5f %8.5f\n",
1031 (i + 1) * 5,
1032 stats.dns_lookups5[i] / fct,
1033 stats.dns_lookups60[i] / fct);
1034 }
1035 fct = stats.count > 1 ? stats.count * 1000000.0 : 1000000.0;
1036 for (int i = 0; i < Mgr::ServiceTimesActionData::seriesSize; ++i) {
1037 storeAppendPrintf(sentry, "\tICP Queries: %2d%% %8.5f %8.5f\n",
1038 (i + 1) * 5,
1039 stats.icp_queries5[i] / fct,
1040 stats.icp_queries60[i] / fct);
1041 }
1042 }
1043
1044 static void
1045 statAvgDump(StoreEntry * sentry, int minutes, int hours)
1046 {
1047 Mgr::IntervalActionData stats;
1048 GetAvgStat(stats, minutes, hours);
1049 DumpAvgStat(stats, sentry);
1050 }
1051
1052 #define XAVG(X) (dt ? (double) (f->X - l->X) / dt : 0.0)
1053 void
1054 GetAvgStat(Mgr::IntervalActionData& stats, int minutes, int hours)
1055 {
1056 StatCounters *f;
1057 StatCounters *l;
1058 double dt;
1059 double ct;
1060 assert(N_COUNT_HIST > 1);
1061 assert(minutes > 0 || hours > 0);
1062 f = &CountHist[0];
1063 l = f;
1064
1065 if (minutes > 0 && hours == 0) {
1066 /* checking minute readings ... */
1067
1068 if (minutes > N_COUNT_HIST - 1)
1069 minutes = N_COUNT_HIST - 1;
1070
1071 l = &CountHist[minutes];
1072 } else if (minutes == 0 && hours > 0) {
1073 /* checking hour readings ... */
1074
1075 if (hours > N_COUNT_HOUR_HIST - 1)
1076 hours = N_COUNT_HOUR_HIST - 1;
1077
1078 l = &CountHourHist[hours];
1079 } else {
1080 debugs(18, DBG_IMPORTANT, "statAvgDump: Invalid args, minutes=" << minutes << ", hours=" << hours);
1081 return;
1082 }
1083
1084 dt = tvSubDsec(l->timestamp, f->timestamp);
1085 ct = f->cputime - l->cputime;
1086
1087 stats.sample_start_time = l->timestamp;
1088 stats.sample_end_time = f->timestamp;
1089
1090 stats.client_http_requests = XAVG(client_http.requests);
1091 stats.client_http_hits = XAVG(client_http.hits);
1092 stats.client_http_errors = XAVG(client_http.errors);
1093 stats.client_http_kbytes_in = XAVG(client_http.kbytes_in.kb);
1094 stats.client_http_kbytes_out = XAVG(client_http.kbytes_out.kb);
1095
1096 stats.client_http_all_median_svc_time = statHistDeltaMedian(l->client_http.allSvcTime,
1097 f->client_http.allSvcTime) / 1000.0;
1098 stats.client_http_miss_median_svc_time = statHistDeltaMedian(l->client_http.missSvcTime,
1099 f->client_http.missSvcTime) / 1000.0;
1100 stats.client_http_nm_median_svc_time = statHistDeltaMedian(l->client_http.nearMissSvcTime,
1101 f->client_http.nearMissSvcTime) / 1000.0;
1102 stats.client_http_nh_median_svc_time = statHistDeltaMedian(l->client_http.nearHitSvcTime,
1103 f->client_http.nearHitSvcTime) / 1000.0;
1104 stats.client_http_hit_median_svc_time = statHistDeltaMedian(l->client_http.hitSvcTime,
1105 f->client_http.hitSvcTime) / 1000.0;
1106
1107 stats.server_all_requests = XAVG(server.all.requests);
1108 stats.server_all_errors = XAVG(server.all.errors);
1109 stats.server_all_kbytes_in = XAVG(server.all.kbytes_in.kb);
1110 stats.server_all_kbytes_out = XAVG(server.all.kbytes_out.kb);
1111
1112 stats.server_http_requests = XAVG(server.http.requests);
1113 stats.server_http_errors = XAVG(server.http.errors);
1114 stats.server_http_kbytes_in = XAVG(server.http.kbytes_in.kb);
1115 stats.server_http_kbytes_out = XAVG(server.http.kbytes_out.kb);
1116
1117 stats.server_ftp_requests = XAVG(server.ftp.requests);
1118 stats.server_ftp_errors = XAVG(server.ftp.errors);
1119 stats.server_ftp_kbytes_in = XAVG(server.ftp.kbytes_in.kb);
1120 stats.server_ftp_kbytes_out = XAVG(server.ftp.kbytes_out.kb);
1121
1122 stats.server_other_requests = XAVG(server.other.requests);
1123 stats.server_other_errors = XAVG(server.other.errors);
1124 stats.server_other_kbytes_in = XAVG(server.other.kbytes_in.kb);
1125 stats.server_other_kbytes_out = XAVG(server.other.kbytes_out.kb);
1126
1127 stats.icp_pkts_sent = XAVG(icp.pkts_sent);
1128 stats.icp_pkts_recv = XAVG(icp.pkts_recv);
1129 stats.icp_queries_sent = XAVG(icp.queries_sent);
1130 stats.icp_replies_sent = XAVG(icp.replies_sent);
1131 stats.icp_queries_recv = XAVG(icp.queries_recv);
1132 stats.icp_replies_recv = XAVG(icp.replies_recv);
1133 stats.icp_replies_queued = XAVG(icp.replies_queued);
1134 stats.icp_query_timeouts = XAVG(icp.query_timeouts);
1135 stats.icp_kbytes_sent = XAVG(icp.kbytes_sent.kb);
1136 stats.icp_kbytes_recv = XAVG(icp.kbytes_recv.kb);
1137 stats.icp_q_kbytes_sent = XAVG(icp.q_kbytes_sent.kb);
1138 stats.icp_r_kbytes_sent = XAVG(icp.r_kbytes_sent.kb);
1139 stats.icp_q_kbytes_recv = XAVG(icp.q_kbytes_recv.kb);
1140 stats.icp_r_kbytes_recv = XAVG(icp.r_kbytes_recv.kb);
1141
1142 stats.icp_query_median_svc_time = statHistDeltaMedian(l->icp.querySvcTime,
1143 f->icp.querySvcTime) / 1000000.0;
1144 stats.icp_reply_median_svc_time = statHistDeltaMedian(l->icp.replySvcTime,
1145 f->icp.replySvcTime) / 1000000.0;
1146 stats.dns_median_svc_time = statHistDeltaMedian(l->dns.svcTime,
1147 f->dns.svcTime) / 1000.0;
1148
1149 stats.unlink_requests = XAVG(unlink.requests);
1150 stats.page_faults = XAVG(page_faults);
1151 stats.select_loops = XAVG(select_loops);
1152 stats.select_fds = XAVG(select_fds);
1153 stats.average_select_fd_period = f->select_fds > l->select_fds ?
1154 (f->select_time - l->select_time) / (f->select_fds - l->select_fds) : 0.0;
1155
1156 stats.median_select_fds = statHistDeltaMedian(l->select_fds_hist, f->select_fds_hist);
1157 stats.swap_outs = XAVG(swap.outs);
1158 stats.swap_ins = XAVG(swap.ins);
1159 stats.swap_files_cleaned = XAVG(swap.files_cleaned);
1160 stats.aborted_requests = XAVG(aborted_requests);
1161
1162 stats.syscalls_disk_opens = XAVG(syscalls.disk.opens);
1163 stats.syscalls_disk_closes = XAVG(syscalls.disk.closes);
1164 stats.syscalls_disk_reads = XAVG(syscalls.disk.reads);
1165 stats.syscalls_disk_writes = XAVG(syscalls.disk.writes);
1166 stats.syscalls_disk_seeks = XAVG(syscalls.disk.seeks);
1167 stats.syscalls_disk_unlinks = XAVG(syscalls.disk.unlinks);
1168 stats.syscalls_sock_accepts = XAVG(syscalls.sock.accepts);
1169 stats.syscalls_sock_sockets = XAVG(syscalls.sock.sockets);
1170 stats.syscalls_sock_connects = XAVG(syscalls.sock.connects);
1171 stats.syscalls_sock_binds = XAVG(syscalls.sock.binds);
1172 stats.syscalls_sock_closes = XAVG(syscalls.sock.closes);
1173 stats.syscalls_sock_reads = XAVG(syscalls.sock.reads);
1174 stats.syscalls_sock_writes = XAVG(syscalls.sock.writes);
1175 stats.syscalls_sock_recvfroms = XAVG(syscalls.sock.recvfroms);
1176 stats.syscalls_sock_sendtos = XAVG(syscalls.sock.sendtos);
1177 stats.syscalls_selects = XAVG(syscalls.selects);
1178
1179 stats.cpu_time = ct;
1180 stats.wall_time = dt;
1181 }
1182
1183 void
1184 DumpAvgStat(Mgr::IntervalActionData& stats, StoreEntry* sentry)
1185 {
1186 storeAppendPrintf(sentry, "sample_start_time = %d.%d (%s)\n",
1187 (int)stats.sample_start_time.tv_sec,
1188 (int)stats.sample_start_time.tv_usec,
1189 mkrfc1123(stats.sample_start_time.tv_sec));
1190 storeAppendPrintf(sentry, "sample_end_time = %d.%d (%s)\n",
1191 (int)stats.sample_end_time.tv_sec,
1192 (int)stats.sample_end_time.tv_usec,
1193 mkrfc1123(stats.sample_end_time.tv_sec));
1194
1195 storeAppendPrintf(sentry, "client_http.requests = %f/sec\n",
1196 stats.client_http_requests);
1197 storeAppendPrintf(sentry, "client_http.hits = %f/sec\n",
1198 stats.client_http_hits);
1199 storeAppendPrintf(sentry, "client_http.errors = %f/sec\n",
1200 stats.client_http_errors);
1201 storeAppendPrintf(sentry, "client_http.kbytes_in = %f/sec\n",
1202 stats.client_http_kbytes_in);
1203 storeAppendPrintf(sentry, "client_http.kbytes_out = %f/sec\n",
1204 stats.client_http_kbytes_out);
1205
1206 double fct = stats.count > 1 ? stats.count : 1.0;
1207 storeAppendPrintf(sentry, "client_http.all_median_svc_time = %f seconds\n",
1208 stats.client_http_all_median_svc_time / fct);
1209 storeAppendPrintf(sentry, "client_http.miss_median_svc_time = %f seconds\n",
1210 stats.client_http_miss_median_svc_time / fct);
1211 storeAppendPrintf(sentry, "client_http.nm_median_svc_time = %f seconds\n",
1212 stats.client_http_nm_median_svc_time / fct);
1213 storeAppendPrintf(sentry, "client_http.nh_median_svc_time = %f seconds\n",
1214 stats.client_http_nh_median_svc_time / fct);
1215 storeAppendPrintf(sentry, "client_http.hit_median_svc_time = %f seconds\n",
1216 stats.client_http_hit_median_svc_time / fct);
1217
1218 storeAppendPrintf(sentry, "server.all.requests = %f/sec\n",
1219 stats.server_all_requests);
1220 storeAppendPrintf(sentry, "server.all.errors = %f/sec\n",
1221 stats.server_all_errors);
1222 storeAppendPrintf(sentry, "server.all.kbytes_in = %f/sec\n",
1223 stats.server_all_kbytes_in);
1224 storeAppendPrintf(sentry, "server.all.kbytes_out = %f/sec\n",
1225 stats.server_all_kbytes_out);
1226
1227 storeAppendPrintf(sentry, "server.http.requests = %f/sec\n",
1228 stats.server_http_requests);
1229 storeAppendPrintf(sentry, "server.http.errors = %f/sec\n",
1230 stats.server_http_errors);
1231 storeAppendPrintf(sentry, "server.http.kbytes_in = %f/sec\n",
1232 stats.server_http_kbytes_in);
1233 storeAppendPrintf(sentry, "server.http.kbytes_out = %f/sec\n",
1234 stats.server_http_kbytes_out);
1235
1236 storeAppendPrintf(sentry, "server.ftp.requests = %f/sec\n",
1237 stats.server_ftp_requests);
1238 storeAppendPrintf(sentry, "server.ftp.errors = %f/sec\n",
1239 stats.server_ftp_errors);
1240 storeAppendPrintf(sentry, "server.ftp.kbytes_in = %f/sec\n",
1241 stats.server_ftp_kbytes_in);
1242 storeAppendPrintf(sentry, "server.ftp.kbytes_out = %f/sec\n",
1243 stats.server_ftp_kbytes_out);
1244
1245 storeAppendPrintf(sentry, "server.other.requests = %f/sec\n",
1246 stats.server_other_requests);
1247 storeAppendPrintf(sentry, "server.other.errors = %f/sec\n",
1248 stats.server_other_errors);
1249 storeAppendPrintf(sentry, "server.other.kbytes_in = %f/sec\n",
1250 stats.server_other_kbytes_in);
1251 storeAppendPrintf(sentry, "server.other.kbytes_out = %f/sec\n",
1252 stats.server_other_kbytes_out);
1253
1254 storeAppendPrintf(sentry, "icp.pkts_sent = %f/sec\n",
1255 stats.icp_pkts_sent);
1256 storeAppendPrintf(sentry, "icp.pkts_recv = %f/sec\n",
1257 stats.icp_pkts_recv);
1258 storeAppendPrintf(sentry, "icp.queries_sent = %f/sec\n",
1259 stats.icp_queries_sent);
1260 storeAppendPrintf(sentry, "icp.replies_sent = %f/sec\n",
1261 stats.icp_replies_sent);
1262 storeAppendPrintf(sentry, "icp.queries_recv = %f/sec\n",
1263 stats.icp_queries_recv);
1264 storeAppendPrintf(sentry, "icp.replies_recv = %f/sec\n",
1265 stats.icp_replies_recv);
1266 storeAppendPrintf(sentry, "icp.replies_queued = %f/sec\n",
1267 stats.icp_replies_queued);
1268 storeAppendPrintf(sentry, "icp.query_timeouts = %f/sec\n",
1269 stats.icp_query_timeouts);
1270 storeAppendPrintf(sentry, "icp.kbytes_sent = %f/sec\n",
1271 stats.icp_kbytes_sent);
1272 storeAppendPrintf(sentry, "icp.kbytes_recv = %f/sec\n",
1273 stats.icp_kbytes_recv);
1274 storeAppendPrintf(sentry, "icp.q_kbytes_sent = %f/sec\n",
1275 stats.icp_q_kbytes_sent);
1276 storeAppendPrintf(sentry, "icp.r_kbytes_sent = %f/sec\n",
1277 stats.icp_r_kbytes_sent);
1278 storeAppendPrintf(sentry, "icp.q_kbytes_recv = %f/sec\n",
1279 stats.icp_q_kbytes_recv);
1280 storeAppendPrintf(sentry, "icp.r_kbytes_recv = %f/sec\n",
1281 stats.icp_r_kbytes_recv);
1282 storeAppendPrintf(sentry, "icp.query_median_svc_time = %f seconds\n",
1283 stats.icp_query_median_svc_time / fct);
1284 storeAppendPrintf(sentry, "icp.reply_median_svc_time = %f seconds\n",
1285 stats.icp_reply_median_svc_time / fct);
1286 storeAppendPrintf(sentry, "dns.median_svc_time = %f seconds\n",
1287 stats.dns_median_svc_time / fct);
1288 storeAppendPrintf(sentry, "unlink.requests = %f/sec\n",
1289 stats.unlink_requests);
1290 storeAppendPrintf(sentry, "page_faults = %f/sec\n",
1291 stats.page_faults);
1292 storeAppendPrintf(sentry, "select_loops = %f/sec\n",
1293 stats.select_loops);
1294 storeAppendPrintf(sentry, "select_fds = %f/sec\n",
1295 stats.select_fds);
1296 storeAppendPrintf(sentry, "average_select_fd_period = %f/fd\n",
1297 stats.average_select_fd_period / fct);
1298 storeAppendPrintf(sentry, "median_select_fds = %f\n",
1299 stats.median_select_fds / fct);
1300 storeAppendPrintf(sentry, "swap.outs = %f/sec\n",
1301 stats.swap_outs);
1302 storeAppendPrintf(sentry, "swap.ins = %f/sec\n",
1303 stats.swap_ins);
1304 storeAppendPrintf(sentry, "swap.files_cleaned = %f/sec\n",
1305 stats.swap_files_cleaned);
1306 storeAppendPrintf(sentry, "aborted_requests = %f/sec\n",
1307 stats.aborted_requests);
1308
1309 #if USE_POLL
1310 storeAppendPrintf(sentry, "syscalls.polls = %f/sec\n", stats.syscalls_selects);
1311 #elif defined(USE_SELECT) || defined(USE_SELECT_WIN32)
1312 storeAppendPrintf(sentry, "syscalls.selects = %f/sec\n", stats.syscalls_selects);
1313 #endif
1314
1315 storeAppendPrintf(sentry, "syscalls.disk.opens = %f/sec\n", stats.syscalls_disk_opens);
1316 storeAppendPrintf(sentry, "syscalls.disk.closes = %f/sec\n", stats.syscalls_disk_closes);
1317 storeAppendPrintf(sentry, "syscalls.disk.reads = %f/sec\n", stats.syscalls_disk_reads);
1318 storeAppendPrintf(sentry, "syscalls.disk.writes = %f/sec\n", stats.syscalls_disk_writes);
1319 storeAppendPrintf(sentry, "syscalls.disk.seeks = %f/sec\n", stats.syscalls_disk_seeks);
1320 storeAppendPrintf(sentry, "syscalls.disk.unlinks = %f/sec\n", stats.syscalls_disk_unlinks);
1321 storeAppendPrintf(sentry, "syscalls.sock.accepts = %f/sec\n", stats.syscalls_sock_accepts);
1322 storeAppendPrintf(sentry, "syscalls.sock.sockets = %f/sec\n", stats.syscalls_sock_sockets);
1323 storeAppendPrintf(sentry, "syscalls.sock.connects = %f/sec\n", stats.syscalls_sock_connects);
1324 storeAppendPrintf(sentry, "syscalls.sock.binds = %f/sec\n", stats.syscalls_sock_binds);
1325 storeAppendPrintf(sentry, "syscalls.sock.closes = %f/sec\n", stats.syscalls_sock_closes);
1326 storeAppendPrintf(sentry, "syscalls.sock.reads = %f/sec\n", stats.syscalls_sock_reads);
1327 storeAppendPrintf(sentry, "syscalls.sock.writes = %f/sec\n", stats.syscalls_sock_writes);
1328 storeAppendPrintf(sentry, "syscalls.sock.recvfroms = %f/sec\n", stats.syscalls_sock_recvfroms);
1329 storeAppendPrintf(sentry, "syscalls.sock.sendtos = %f/sec\n", stats.syscalls_sock_sendtos);
1330
1331 storeAppendPrintf(sentry, "cpu_time = %f seconds\n", stats.cpu_time);
1332 storeAppendPrintf(sentry, "wall_time = %f seconds\n", stats.wall_time);
1333 storeAppendPrintf(sentry, "cpu_usage = %f%%\n", Math::doublePercent(stats.cpu_time, stats.wall_time));
1334 }
1335
1336 static void
1337 statRegisterWithCacheManager(void)
1338 {
1339 Mgr::RegisterAction("info", "General Runtime Information",
1340 &Mgr::InfoAction::Create, 0, 1);
1341 Mgr::RegisterAction("service_times", "Service Times (Percentiles)",
1342 &Mgr::ServiceTimesAction::Create, 0, 1);
1343 Mgr::RegisterAction("filedescriptors", "Process Filedescriptor Allocation",
1344 fde::DumpStats, 0, 1);
1345 Mgr::RegisterAction("objects", "All Cache Objects", stat_objects_get, 0, 0);
1346 Mgr::RegisterAction("vm_objects", "In-Memory and In-Transit Objects",
1347 stat_vmobjects_get, 0, 0);
1348 Mgr::RegisterAction("io", "Server-side network read() size histograms",
1349 &Mgr::IoAction::Create, 0, 1);
1350 Mgr::RegisterAction("counters", "Traffic and Resource Counters",
1351 &Mgr::CountersAction::Create, 0, 1);
1352 Mgr::RegisterAction("peer_select", "Peer Selection Algorithms",
1353 statPeerSelect, 0, 1);
1354 Mgr::RegisterAction("digest_stats", "Cache Digest and ICP blob",
1355 statDigestBlob, 0, 1);
1356 Mgr::RegisterAction("5min", "5 Minute Average of Counters",
1357 &Mgr::IntervalAction::Create5min, 0, 1);
1358 Mgr::RegisterAction("60min", "60 Minute Average of Counters",
1359 &Mgr::IntervalAction::Create60min, 0, 1);
1360 Mgr::RegisterAction("utilization", "Cache Utilization",
1361 statUtilization, 0, 1);
1362 Mgr::RegisterAction("histograms", "Full Histogram Counts",
1363 statCountersHistograms, 0, 1);
1364 Mgr::RegisterAction("active_requests",
1365 "Client-side Active Requests",
1366 statClientRequests, 0, 1);
1367 #if USE_AUTH
1368 Mgr::RegisterAction("username_cache",
1369 "Active Cached Usernames",
1370 Auth::User::UsernameCacheStats, 0, 1);
1371 #endif
1372 #if DEBUG_OPENFD
1373 Mgr::RegisterAction("openfd_objects", "Objects with Swapout files open",
1374 statOpenfdObj, 0, 0);
1375 #endif
1376 #if STAT_GRAPHS
1377 Mgr::RegisterAction("graph_variables", "Display cache metrics graphically",
1378 statGraphDump, 0, 1);
1379 #endif
1380 }
1381
1382 void
1383 statInit(void)
1384 {
1385 int i;
1386 debugs(18, 5, "statInit: Initializing...");
1387
1388 for (i = 0; i < N_COUNT_HIST; ++i)
1389 statCountersInit(&CountHist[i]);
1390
1391 for (i = 0; i < N_COUNT_HOUR_HIST; ++i)
1392 statCountersInit(&CountHourHist[i]);
1393
1394 statCountersInit(&statCounter);
1395
1396 eventAdd("statAvgTick", statAvgTick, NULL, (double) COUNT_INTERVAL, 1);
1397
1398 ClientActiveRequests.head = NULL;
1399
1400 ClientActiveRequests.tail = NULL;
1401
1402 statRegisterWithCacheManager();
1403 }
1404
1405 static void
1406 statAvgTick(void *notused)
1407 {
1408 StatCounters *t = &CountHist[0];
1409 StatCounters *p = &CountHist[1];
1410 StatCounters *c = &statCounter;
1411
1412 struct rusage rusage;
1413 eventAdd("statAvgTick", statAvgTick, NULL, (double) COUNT_INTERVAL, 1);
1414 squid_getrusage(&rusage);
1415 c->page_faults = rusage_pagefaults(&rusage);
1416 c->cputime = rusage_cputime(&rusage);
1417 c->timestamp = current_time;
1418 /* even if NCountHist is small, we already Init()ed the tail */
1419 statCountersClean(CountHist + N_COUNT_HIST - 1);
1420 memmove(p, t, (N_COUNT_HIST - 1) * sizeof(StatCounters));
1421 statCountersCopy(t, c);
1422 ++NCountHist;
1423
1424 if ((NCountHist % COUNT_INTERVAL) == 0) {
1425 /* we have an hours worth of readings. store previous hour */
1426 StatCounters *t2 = &CountHourHist[0];
1427 StatCounters *p2 = &CountHourHist[1];
1428 StatCounters *c2 = &CountHist[N_COUNT_HIST - 1];
1429 statCountersClean(CountHourHist + N_COUNT_HOUR_HIST - 1);
1430 memmove(p2, t2, (N_COUNT_HOUR_HIST - 1) * sizeof(StatCounters));
1431 statCountersCopy(t2, c2);
1432 ++NCountHourHist;
1433 }
1434
1435 if (Config.warnings.high_rptm > 0) {
1436 int i = (int) statPctileSvc(0.5, 20, PCTILE_HTTP);
1437
1438 if (Config.warnings.high_rptm < i)
1439 debugs(18, DBG_CRITICAL, "WARNING: Median response time is " << i << " milliseconds");
1440 }
1441
1442 if (Config.warnings.high_pf) {
1443 int i = (CountHist[0].page_faults - CountHist[1].page_faults);
1444 double dt = tvSubDsec(CountHist[0].timestamp, CountHist[1].timestamp);
1445
1446 if (i > 0 && dt > 0.0) {
1447 i /= (int) dt;
1448
1449 if (Config.warnings.high_pf < i)
1450 debugs(18, DBG_CRITICAL, "WARNING: Page faults occuring at " << i << "/sec");
1451 }
1452 }
1453
1454 if (Config.warnings.high_memory) {
1455 size_t i = 0;
1456 #if HAVE_MSTATS && HAVE_GNUMALLOC_H
1457
1458 struct mstats ms = mstats();
1459 i = ms.bytes_total;
1460 #elif HAVE_MALLINFO && HAVE_STRUCT_MALLINFO
1461
1462 struct mallinfo mp = mallinfo();
1463 i = mp.arena;
1464 #elif HAVE_SBRK
1465
1466 i = (size_t) ((char *) sbrk(0) - (char *) sbrk_start);
1467 #endif
1468
1469 if (Config.warnings.high_memory < i)
1470 debugs(18, DBG_CRITICAL, "WARNING: Memory usage at " << ((unsigned long int)(i >> 20)) << " MB");
1471 }
1472 }
1473
1474 static void
1475 statCountersInit(StatCounters * C)
1476 {
1477 assert(C);
1478 memset(C, 0, sizeof(*C));
1479 C->timestamp = current_time;
1480 statCountersInitSpecial(C);
1481 }
1482
1483 /* add special cases here as they arrive */
1484 static void
1485 statCountersInitSpecial(StatCounters * C)
1486 {
1487 /*
1488 * HTTP svc_time hist is kept in milli-seconds; max of 3 hours.
1489 */
1490 C->client_http.allSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1491 C->client_http.missSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1492 C->client_http.nearMissSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1493 C->client_http.nearHitSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1494 C->client_http.hitSvcTime.logInit(300, 0.0, 3600000.0 * 3.0);
1495 /*
1496 * ICP svc_time hist is kept in micro-seconds; max of 1 minute.
1497 */
1498 C->icp.querySvcTime.logInit(300, 0.0, 1000000.0 * 60.0);
1499 C->icp.replySvcTime.logInit(300, 0.0, 1000000.0 * 60.0);
1500 /*
1501 * DNS svc_time hist is kept in milli-seconds; max of 10 minutes.
1502 */
1503 C->dns.svcTime.logInit(300, 0.0, 60000.0 * 10.0);
1504 /*
1505 * Cache Digest Stuff
1506 */
1507 C->cd.on_xition_count.enumInit(CacheDigestHashFuncCount);
1508 C->comm_udp_incoming.enumInit(INCOMING_UDP_MAX);
1509 C->comm_dns_incoming.enumInit(INCOMING_DNS_MAX);
1510 C->comm_tcp_incoming.enumInit(INCOMING_TCP_MAX);
1511 C->select_fds_hist.enumInit(256); /* was SQUID_MAXFD, but it is way too much. It is OK to crop this statistics */
1512 }
1513
1514 /* add special cases here as they arrive */
1515 static void
1516 statCountersClean(StatCounters * C)
1517 {
1518 assert(C);
1519 C->client_http.allSvcTime.clear();
1520 C->client_http.missSvcTime.clear();
1521 C->client_http.nearMissSvcTime.clear();
1522 C->client_http.nearHitSvcTime.clear();
1523 C->client_http.hitSvcTime.clear();
1524 C->icp.querySvcTime.clear();
1525 C->icp.replySvcTime.clear();
1526 C->dns.svcTime.clear();
1527 C->cd.on_xition_count.clear();
1528 C->comm_udp_incoming.clear();
1529 C->comm_dns_incoming.clear();
1530 C->comm_tcp_incoming.clear();
1531 C->select_fds_hist.clear();
1532 }
1533
1534 /* add special cases here as they arrive */
1535 static void
1536 statCountersCopy(StatCounters * dest, const StatCounters * orig)
1537 {
1538 assert(dest && orig);
1539 /* this should take care of all the fields, but "special" ones */
1540 memcpy(dest, orig, sizeof(*dest));
1541 /* prepare space where to copy special entries */
1542 statCountersInitSpecial(dest);
1543 /* now handle special cases */
1544 /* note: we assert that histogram capacities do not change */
1545 dest->client_http.allSvcTime=orig->client_http.allSvcTime;
1546 dest->client_http.missSvcTime=orig->client_http.missSvcTime;
1547 dest->client_http.nearMissSvcTime=orig->client_http.nearMissSvcTime;
1548 dest->client_http.nearHitSvcTime=orig->client_http.nearHitSvcTime;
1549
1550 dest->client_http.hitSvcTime=orig->client_http.hitSvcTime;
1551 dest->icp.querySvcTime=orig->icp.querySvcTime;
1552 dest->icp.replySvcTime=orig->icp.replySvcTime;
1553 dest->dns.svcTime=orig->dns.svcTime;
1554 dest->cd.on_xition_count=orig->cd.on_xition_count;
1555 dest->comm_udp_incoming=orig->comm_udp_incoming;
1556 dest->comm_dns_incoming=orig->comm_dns_incoming;
1557 dest->comm_tcp_incoming=orig->comm_tcp_incoming;
1558 dest->select_fds_hist=orig->select_fds_hist;
1559 }
1560
1561 static void
1562 statCountersHistograms(StoreEntry * sentry)
1563 {
1564 storeAppendPrintf(sentry, "client_http.allSvcTime histogram:\n");
1565 statCounter.client_http.allSvcTime.dump(sentry, NULL);
1566 storeAppendPrintf(sentry, "client_http.missSvcTime histogram:\n");
1567 statCounter.client_http.missSvcTime.dump(sentry, NULL);
1568 storeAppendPrintf(sentry, "client_http.nearMissSvcTime histogram:\n");
1569 statCounter.client_http.nearMissSvcTime.dump(sentry, NULL);
1570 storeAppendPrintf(sentry, "client_http.nearHitSvcTime histogram:\n");
1571 statCounter.client_http.nearHitSvcTime.dump(sentry, NULL);
1572 storeAppendPrintf(sentry, "client_http.hitSvcTime histogram:\n");
1573 statCounter.client_http.hitSvcTime.dump(sentry, NULL);
1574 storeAppendPrintf(sentry, "icp.querySvcTime histogram:\n");
1575 statCounter.icp.querySvcTime.dump(sentry, NULL);
1576 storeAppendPrintf(sentry, "icp.replySvcTime histogram:\n");
1577 statCounter.icp.replySvcTime.dump(sentry, NULL);
1578 storeAppendPrintf(sentry, "dns.svc_time histogram:\n");
1579 statCounter.dns.svcTime.dump(sentry, NULL);
1580 storeAppendPrintf(sentry, "select_fds_hist histogram:\n");
1581 statCounter.select_fds_hist.dump(sentry, NULL);
1582 }
1583
1584 static void
1585 statCountersDump(StoreEntry * sentry)
1586 {
1587 Mgr::CountersActionData stats;
1588 GetCountersStats(stats);
1589 DumpCountersStats(stats, sentry);
1590 }
1591
1592 void
1593 GetCountersStats(Mgr::CountersActionData& stats)
1594 {
1595 StatCounters *f = &statCounter;
1596
1597 struct rusage rusage;
1598 squid_getrusage(&rusage);
1599 f->page_faults = rusage_pagefaults(&rusage);
1600 f->cputime = rusage_cputime(&rusage);
1601
1602 stats.sample_time = f->timestamp;
1603 stats.client_http_requests = f->client_http.requests;
1604 stats.client_http_hits = f->client_http.hits;
1605 stats.client_http_errors = f->client_http.errors;
1606 stats.client_http_kbytes_in = f->client_http.kbytes_in.kb;
1607 stats.client_http_kbytes_out = f->client_http.kbytes_out.kb;
1608 stats.client_http_hit_kbytes_out = f->client_http.hit_kbytes_out.kb;
1609
1610 stats.server_all_requests = f->server.all.requests;
1611 stats.server_all_errors = f->server.all.errors;
1612 stats.server_all_kbytes_in = f->server.all.kbytes_in.kb;
1613 stats.server_all_kbytes_out = f->server.all.kbytes_out.kb;
1614
1615 stats.server_http_requests = f->server.http.requests;
1616 stats.server_http_errors = f->server.http.errors;
1617 stats.server_http_kbytes_in = f->server.http.kbytes_in.kb;
1618 stats.server_http_kbytes_out = f->server.http.kbytes_out.kb;
1619
1620 stats.server_ftp_requests = f->server.ftp.requests;
1621 stats.server_ftp_errors = f->server.ftp.errors;
1622 stats.server_ftp_kbytes_in = f->server.ftp.kbytes_in.kb;
1623 stats.server_ftp_kbytes_out = f->server.ftp.kbytes_out.kb;
1624
1625 stats.server_other_requests = f->server.other.requests;
1626 stats.server_other_errors = f->server.other.errors;
1627 stats.server_other_kbytes_in = f->server.other.kbytes_in.kb;
1628 stats.server_other_kbytes_out = f->server.other.kbytes_out.kb;
1629
1630 stats.icp_pkts_sent = f->icp.pkts_sent;
1631 stats.icp_pkts_recv = f->icp.pkts_recv;
1632 stats.icp_queries_sent = f->icp.queries_sent;
1633 stats.icp_replies_sent = f->icp.replies_sent;
1634 stats.icp_queries_recv = f->icp.queries_recv;
1635 stats.icp_replies_recv = f->icp.replies_recv;
1636 stats.icp_query_timeouts = f->icp.query_timeouts;
1637 stats.icp_replies_queued = f->icp.replies_queued;
1638 stats.icp_kbytes_sent = f->icp.kbytes_sent.kb;
1639 stats.icp_kbytes_recv = f->icp.kbytes_recv.kb;
1640 stats.icp_q_kbytes_sent = f->icp.q_kbytes_sent.kb;
1641 stats.icp_r_kbytes_sent = f->icp.r_kbytes_sent.kb;
1642 stats.icp_q_kbytes_recv = f->icp.q_kbytes_recv.kb;
1643 stats.icp_r_kbytes_recv = f->icp.r_kbytes_recv.kb;
1644
1645 #if USE_CACHE_DIGESTS
1646
1647 stats.icp_times_used = f->icp.times_used;
1648 stats.cd_times_used = f->cd.times_used;
1649 stats.cd_msgs_sent = f->cd.msgs_sent;
1650 stats.cd_msgs_recv = f->cd.msgs_recv;
1651 stats.cd_memory = f->cd.memory.kb;
1652 stats.cd_local_memory = store_digest ? store_digest->mask_size / 1024 : 0;
1653 stats.cd_kbytes_sent = f->cd.kbytes_sent.kb;
1654 stats.cd_kbytes_recv = f->cd.kbytes_recv.kb;
1655 #endif
1656
1657 stats.unlink_requests = f->unlink.requests;
1658 stats.page_faults = f->page_faults;
1659 stats.select_loops = f->select_loops;
1660 stats.cpu_time = f->cputime;
1661 stats.wall_time = tvSubDsec(f->timestamp, current_time);
1662 stats.swap_outs = f->swap.outs;
1663 stats.swap_ins = f->swap.ins;
1664 stats.swap_files_cleaned = f->swap.files_cleaned;
1665 stats.aborted_requests = f->aborted_requests;
1666 }
1667
1668 void
1669 DumpCountersStats(Mgr::CountersActionData& stats, StoreEntry* sentry)
1670 {
1671 storeAppendPrintf(sentry, "sample_time = %d.%d (%s)\n",
1672 (int) stats.sample_time.tv_sec,
1673 (int) stats.sample_time.tv_usec,
1674 mkrfc1123(stats.sample_time.tv_sec));
1675 storeAppendPrintf(sentry, "client_http.requests = %.0f\n",
1676 stats.client_http_requests);
1677 storeAppendPrintf(sentry, "client_http.hits = %.0f\n",
1678 stats.client_http_hits);
1679 storeAppendPrintf(sentry, "client_http.errors = %.0f\n",
1680 stats.client_http_errors);
1681 storeAppendPrintf(sentry, "client_http.kbytes_in = %.0f\n",
1682 stats.client_http_kbytes_in);
1683 storeAppendPrintf(sentry, "client_http.kbytes_out = %.0f\n",
1684 stats.client_http_kbytes_out);
1685 storeAppendPrintf(sentry, "client_http.hit_kbytes_out = %.0f\n",
1686 stats.client_http_hit_kbytes_out);
1687
1688 storeAppendPrintf(sentry, "server.all.requests = %.0f\n",
1689 stats.server_all_requests);
1690 storeAppendPrintf(sentry, "server.all.errors = %.0f\n",
1691 stats.server_all_errors);
1692 storeAppendPrintf(sentry, "server.all.kbytes_in = %.0f\n",
1693 stats.server_all_kbytes_in);
1694 storeAppendPrintf(sentry, "server.all.kbytes_out = %.0f\n",
1695 stats.server_all_kbytes_out);
1696
1697 storeAppendPrintf(sentry, "server.http.requests = %.0f\n",
1698 stats.server_http_requests);
1699 storeAppendPrintf(sentry, "server.http.errors = %.0f\n",
1700 stats.server_http_errors);
1701 storeAppendPrintf(sentry, "server.http.kbytes_in = %.0f\n",
1702 stats.server_http_kbytes_in);
1703 storeAppendPrintf(sentry, "server.http.kbytes_out = %.0f\n",
1704 stats.server_http_kbytes_out);
1705
1706 storeAppendPrintf(sentry, "server.ftp.requests = %.0f\n",
1707 stats.server_ftp_requests);
1708 storeAppendPrintf(sentry, "server.ftp.errors = %.0f\n",
1709 stats.server_ftp_errors);
1710 storeAppendPrintf(sentry, "server.ftp.kbytes_in = %.0f\n",
1711 stats.server_ftp_kbytes_in);
1712 storeAppendPrintf(sentry, "server.ftp.kbytes_out = %.0f\n",
1713 stats.server_ftp_kbytes_out);
1714
1715 storeAppendPrintf(sentry, "server.other.requests = %.0f\n",
1716 stats.server_other_requests);
1717 storeAppendPrintf(sentry, "server.other.errors = %.0f\n",
1718 stats.server_other_errors);
1719 storeAppendPrintf(sentry, "server.other.kbytes_in = %.0f\n",
1720 stats.server_other_kbytes_in);
1721 storeAppendPrintf(sentry, "server.other.kbytes_out = %.0f\n",
1722 stats.server_other_kbytes_out);
1723
1724 storeAppendPrintf(sentry, "icp.pkts_sent = %.0f\n",
1725 stats.icp_pkts_sent);
1726 storeAppendPrintf(sentry, "icp.pkts_recv = %.0f\n",
1727 stats.icp_pkts_recv);
1728 storeAppendPrintf(sentry, "icp.queries_sent = %.0f\n",
1729 stats.icp_queries_sent);
1730 storeAppendPrintf(sentry, "icp.replies_sent = %.0f\n",
1731 stats.icp_replies_sent);
1732 storeAppendPrintf(sentry, "icp.queries_recv = %.0f\n",
1733 stats.icp_queries_recv);
1734 storeAppendPrintf(sentry, "icp.replies_recv = %.0f\n",
1735 stats.icp_replies_recv);
1736 storeAppendPrintf(sentry, "icp.query_timeouts = %.0f\n",
1737 stats.icp_query_timeouts);
1738 storeAppendPrintf(sentry, "icp.replies_queued = %.0f\n",
1739 stats.icp_replies_queued);
1740 storeAppendPrintf(sentry, "icp.kbytes_sent = %.0f\n",
1741 stats.icp_kbytes_sent);
1742 storeAppendPrintf(sentry, "icp.kbytes_recv = %.0f\n",
1743 stats.icp_kbytes_recv);
1744 storeAppendPrintf(sentry, "icp.q_kbytes_sent = %.0f\n",
1745 stats.icp_q_kbytes_sent);
1746 storeAppendPrintf(sentry, "icp.r_kbytes_sent = %.0f\n",
1747 stats.icp_r_kbytes_sent);
1748 storeAppendPrintf(sentry, "icp.q_kbytes_recv = %.0f\n",
1749 stats.icp_q_kbytes_recv);
1750 storeAppendPrintf(sentry, "icp.r_kbytes_recv = %.0f\n",
1751 stats.icp_r_kbytes_recv);
1752
1753 #if USE_CACHE_DIGESTS
1754
1755 storeAppendPrintf(sentry, "icp.times_used = %.0f\n",
1756 stats.icp_times_used);
1757 storeAppendPrintf(sentry, "cd.times_used = %.0f\n",
1758 stats.cd_times_used);
1759 storeAppendPrintf(sentry, "cd.msgs_sent = %.0f\n",
1760 stats.cd_msgs_sent);
1761 storeAppendPrintf(sentry, "cd.msgs_recv = %.0f\n",
1762 stats.cd_msgs_recv);
1763 storeAppendPrintf(sentry, "cd.memory = %.0f\n",
1764 stats.cd_memory);
1765 storeAppendPrintf(sentry, "cd.local_memory = %.0f\n",
1766 stats.cd_local_memory);
1767 storeAppendPrintf(sentry, "cd.kbytes_sent = %.0f\n",
1768 stats.cd_kbytes_sent);
1769 storeAppendPrintf(sentry, "cd.kbytes_recv = %.0f\n",
1770 stats.cd_kbytes_recv);
1771 #endif
1772
1773 storeAppendPrintf(sentry, "unlink.requests = %.0f\n",
1774 stats.unlink_requests);
1775 storeAppendPrintf(sentry, "page_faults = %.0f\n",
1776 stats.page_faults);
1777 storeAppendPrintf(sentry, "select_loops = %.0f\n",
1778 stats.select_loops);
1779 storeAppendPrintf(sentry, "cpu_time = %f\n",
1780 stats.cpu_time);
1781 storeAppendPrintf(sentry, "wall_time = %f\n",
1782 stats.wall_time);
1783 storeAppendPrintf(sentry, "swap.outs = %.0f\n",
1784 stats.swap_outs);
1785 storeAppendPrintf(sentry, "swap.ins = %.0f\n",
1786 stats.swap_ins);
1787 storeAppendPrintf(sentry, "swap.files_cleaned = %.0f\n",
1788 stats.swap_files_cleaned);
1789 storeAppendPrintf(sentry, "aborted_requests = %.0f\n",
1790 stats.aborted_requests);
1791 }
1792
1793 void
1794 statFreeMemory(void)
1795 {
1796 int i;
1797
1798 for (i = 0; i < N_COUNT_HIST; ++i)
1799 statCountersClean(&CountHist[i]);
1800
1801 for (i = 0; i < N_COUNT_HOUR_HIST; ++i)
1802 statCountersClean(&CountHourHist[i]);
1803 }
1804
1805 static void
1806 statPeerSelect(StoreEntry * sentry)
1807 {
1808 #if USE_CACHE_DIGESTS
1809 StatCounters *f = &statCounter;
1810 peer *peer;
1811 const int tot_used = f->cd.times_used + f->icp.times_used;
1812
1813 /* totals */
1814 cacheDigestGuessStatsReport(&f->cd.guess, sentry, "all peers");
1815 /* per-peer */
1816 storeAppendPrintf(sentry, "\nPer-peer statistics:\n");
1817
1818 for (peer = getFirstPeer(); peer; peer = getNextPeer(peer)) {
1819 if (peer->digest)
1820 peerDigestStatsReport(peer->digest, sentry);
1821 else
1822 storeAppendPrintf(sentry, "\nNo peer digest from %s\n", peer->host);
1823
1824 storeAppendPrintf(sentry, "\n");
1825 }
1826
1827 storeAppendPrintf(sentry, "\nAlgorithm usage:\n");
1828 storeAppendPrintf(sentry, "Cache Digest: %7d (%3d%%)\n",
1829 f->cd.times_used, xpercentInt(f->cd.times_used, tot_used));
1830 storeAppendPrintf(sentry, "Icp: %7d (%3d%%)\n",
1831 f->icp.times_used, xpercentInt(f->icp.times_used, tot_used));
1832 storeAppendPrintf(sentry, "Total: %7d (%3d%%)\n",
1833 tot_used, xpercentInt(tot_used, tot_used));
1834 #else
1835
1836 storeAppendPrintf(sentry, "peer digests are disabled; no stats is available.\n");
1837 #endif
1838 }
1839
1840 static void
1841 statDigestBlob(StoreEntry * sentry)
1842 {
1843 storeAppendPrintf(sentry, "\nCounters:\n");
1844 statCountersDump(sentry);
1845 storeAppendPrintf(sentry, "\n5 Min Averages:\n");
1846 statAvgDump(sentry, 5, 0);
1847 storeAppendPrintf(sentry, "\nHistograms:\n");
1848 statCountersHistograms(sentry);
1849 storeAppendPrintf(sentry, "\nPeer Digests:\n");
1850 statPeerSelect(sentry);
1851 storeAppendPrintf(sentry, "\nLocal Digest:\n");
1852 storeDigestReport(sentry);
1853 }
1854
1855 static double
1856 statPctileSvc(double pctile, int interval, int which)
1857 {
1858 StatCounters *f;
1859 StatCounters *l;
1860 double x;
1861 assert(interval > 0);
1862
1863 if (interval > N_COUNT_HIST - 1)
1864 interval = N_COUNT_HIST - 1;
1865
1866 f = &CountHist[0];
1867
1868 l = &CountHist[interval];
1869
1870 assert(f);
1871
1872 assert(l);
1873
1874 switch (which) {
1875
1876 case PCTILE_HTTP:
1877 x = statHistDeltaPctile(l->client_http.allSvcTime,f->client_http.allSvcTime, pctile);
1878 break;
1879
1880 case PCTILE_HIT:
1881 x = statHistDeltaPctile(l->client_http.hitSvcTime,f->client_http.hitSvcTime, pctile);
1882 break;
1883
1884 case PCTILE_MISS:
1885 x = statHistDeltaPctile(l->client_http.missSvcTime,f->client_http.missSvcTime, pctile);
1886 break;
1887
1888 case PCTILE_NM:
1889 x = statHistDeltaPctile(l->client_http.nearMissSvcTime,f->client_http.nearMissSvcTime, pctile);
1890 break;
1891
1892 case PCTILE_NH:
1893 x = statHistDeltaPctile(l->client_http.nearHitSvcTime,f->client_http.nearHitSvcTime, pctile);
1894 break;
1895
1896 case PCTILE_ICP_QUERY:
1897 x = statHistDeltaPctile(l->icp.querySvcTime,f->icp.querySvcTime, pctile);
1898 break;
1899
1900 case PCTILE_DNS:
1901 x = statHistDeltaPctile(l->dns.svcTime,f->dns.svcTime, pctile);
1902 break;
1903
1904 default:
1905 debugs(49, 5, "statPctileSvc: unknown type.");
1906 x = 0;
1907 }
1908
1909 return x;
1910 }
1911
1912 StatCounters *
1913 snmpStatGet(int minutes)
1914 {
1915 return &CountHist[minutes];
1916 }
1917
1918 int
1919 stat5minClientRequests(void)
1920 {
1921 assert(N_COUNT_HIST > 5);
1922 return statCounter.client_http.requests - CountHist[5].client_http.requests;
1923 }
1924
1925 static double
1926 statCPUUsage(int minutes)
1927 {
1928 assert(minutes < N_COUNT_HIST);
1929 return Math::doublePercent(CountHist[0].cputime - CountHist[minutes].cputime,
1930 tvSubDsec(CountHist[minutes].timestamp, CountHist[0].timestamp));
1931 }
1932
1933 extern double
1934 statRequestHitRatio(int minutes)
1935 {
1936 assert(minutes < N_COUNT_HIST);
1937 return Math::doublePercent(CountHist[0].client_http.hits -
1938 CountHist[minutes].client_http.hits,
1939 CountHist[0].client_http.requests -
1940 CountHist[minutes].client_http.requests);
1941 }
1942
1943 extern double
1944 statRequestHitMemoryRatio(int minutes)
1945 {
1946 assert(minutes < N_COUNT_HIST);
1947 return Math::doublePercent(CountHist[0].client_http.mem_hits -
1948 CountHist[minutes].client_http.mem_hits,
1949 CountHist[0].client_http.hits -
1950 CountHist[minutes].client_http.hits);
1951 }
1952
1953 extern double
1954 statRequestHitDiskRatio(int minutes)
1955 {
1956 assert(minutes < N_COUNT_HIST);
1957 return Math::doublePercent(CountHist[0].client_http.disk_hits -
1958 CountHist[minutes].client_http.disk_hits,
1959 CountHist[0].client_http.hits -
1960 CountHist[minutes].client_http.hits);
1961 }
1962
1963 extern double
1964 statByteHitRatio(int minutes)
1965 {
1966 size_t s;
1967 size_t c;
1968 #if USE_CACHE_DIGESTS
1969
1970 size_t cd;
1971 #endif
1972 /* size_t might be unsigned */
1973 assert(minutes < N_COUNT_HIST);
1974 c = CountHist[0].client_http.kbytes_out.kb - CountHist[minutes].client_http.kbytes_out.kb;
1975 s = CountHist[0].server.all.kbytes_in.kb - CountHist[minutes].server.all.kbytes_in.kb;
1976 #if USE_CACHE_DIGESTS
1977 /*
1978 * This ugly hack is here to prevent the user from seeing a
1979 * negative byte hit ratio. When we fetch a cache digest from
1980 * a neighbor, it gets treated like a cache miss because the
1981 * object is consumed internally. Thus, we subtract cache
1982 * digest bytes out before calculating the byte hit ratio.
1983 */
1984 cd = CountHist[0].cd.kbytes_recv.kb - CountHist[minutes].cd.kbytes_recv.kb;
1985
1986 if (s < cd)
1987 debugs(18, DBG_IMPORTANT, "STRANGE: srv_kbytes=" << s << ", cd_kbytes=" << cd);
1988
1989 s -= cd;
1990
1991 #endif
1992
1993 if (c > s)
1994 return Math::doublePercent(c - s, c);
1995 else
1996 return (-1.0 * Math::doublePercent(s - c, c));
1997 }
1998
1999 static void
2000 statClientRequests(StoreEntry * s)
2001 {
2002 dlink_node *i;
2003 ClientHttpRequest *http;
2004 StoreEntry *e;
2005 char buf[MAX_IPSTRLEN];
2006
2007 for (i = ClientActiveRequests.head; i; i = i->next) {
2008 const char *p = NULL;
2009 http = static_cast<ClientHttpRequest *>(i->data);
2010 assert(http);
2011 ConnStateData * conn = http->getConn();
2012 storeAppendPrintf(s, "Connection: %p\n", conn);
2013
2014 if (conn != NULL) {
2015 const int fd = conn->clientConnection->fd;
2016 storeAppendPrintf(s, "\tFD %d, read %" PRId64 ", wrote %" PRId64 "\n", fd,
2017 fd_table[fd].bytes_read, fd_table[fd].bytes_written);
2018 storeAppendPrintf(s, "\tFD desc: %s\n", fd_table[fd].desc);
2019 storeAppendPrintf(s, "\tin: buf %p, offset %ld, size %ld\n",
2020 conn->in.buf, (long int) conn->in.notYetUsed, (long int) conn->in.allocatedSize);
2021 storeAppendPrintf(s, "\tremote: %s\n",
2022 conn->clientConnection->remote.ToURL(buf,MAX_IPSTRLEN));
2023 storeAppendPrintf(s, "\tlocal: %s\n",
2024 conn->clientConnection->local.ToURL(buf,MAX_IPSTRLEN));
2025 storeAppendPrintf(s, "\tnrequests: %d\n",
2026 conn->nrequests);
2027 }
2028
2029 storeAppendPrintf(s, "uri %s\n", http->uri);
2030 storeAppendPrintf(s, "logType %s\n", Format::log_tags[http->logType]);
2031 storeAppendPrintf(s, "out.offset %ld, out.size %lu\n",
2032 (long int) http->out.offset, (unsigned long int) http->out.size);
2033 storeAppendPrintf(s, "req_sz %ld\n", (long int) http->req_sz);
2034 e = http->storeEntry();
2035 storeAppendPrintf(s, "entry %p/%s\n", e, e ? e->getMD5Text() : "N/A");
2036 #if 0
2037 /* Not a member anymore */
2038 e = http->old_entry;
2039 storeAppendPrintf(s, "old_entry %p/%s\n", e, e ? e->getMD5Text() : "N/A");
2040 #endif
2041
2042 storeAppendPrintf(s, "start %ld.%06d (%f seconds ago)\n",
2043 (long int) http->start_time.tv_sec,
2044 (int) http->start_time.tv_usec,
2045 tvSubDsec(http->start_time, current_time));
2046 #if USE_AUTH
2047 if (http->request->auth_user_request != NULL)
2048 p = http->request->auth_user_request->username();
2049 else
2050 #endif
2051 if (http->request->extacl_user.defined()) {
2052 p = http->request->extacl_user.termedBuf();
2053 }
2054
2055 if (!p && conn != NULL && conn->clientConnection->rfc931[0])
2056 p = conn->clientConnection->rfc931;
2057
2058 #if USE_SSL
2059
2060 if (!p && conn != NULL && Comm::IsConnOpen(conn->clientConnection))
2061 p = sslGetUserEmail(fd_table[conn->clientConnection->fd].ssl);
2062
2063 #endif
2064
2065 if (!p)
2066 p = dash_str;
2067
2068 storeAppendPrintf(s, "username %s\n", p);
2069
2070 #if USE_DELAY_POOLS
2071 storeAppendPrintf(s, "delay_pool %d\n", DelayId::DelayClient(http).pool());
2072 #endif
2073
2074 storeAppendPrintf(s, "\n");
2075 }
2076 }
2077
2078 #if STAT_GRAPHS
2079 /*
2080 * urgh, i don't like these, but they do cut the amount of code down immensely
2081 */
2082
2083 #define GRAPH_PER_MIN(Y) \
2084 for (i=0;i<(N_COUNT_HIST-2);++i) { \
2085 dt = tvSubDsec(CountHist[i+1].timestamp, CountHist[i].timestamp); \
2086 if (dt <= 0.0) \
2087 break; \
2088 storeAppendPrintf(e, "%lu,%0.2f:", \
2089 CountHist[i].timestamp.tv_sec, \
2090 ((CountHist[i].Y - CountHist[i+1].Y) / dt)); \
2091 }
2092
2093 #define GRAPH_PER_HOUR(Y) \
2094 for (i=0;i<(N_COUNT_HOUR_HIST-2);++i) { \
2095 dt = tvSubDsec(CountHourHist[i+1].timestamp, CountHourHist[i].timestamp); \
2096 if (dt <= 0.0) \
2097 break; \
2098 storeAppendPrintf(e, "%lu,%0.2f:", \
2099 CountHourHist[i].timestamp.tv_sec, \
2100 ((CountHourHist[i].Y - CountHourHist[i+1].Y) / dt)); \
2101 }
2102
2103 #define GRAPH_TITLE(X,Y) storeAppendPrintf(e,"%s\t%s\t",X,Y);
2104 #define GRAPH_END storeAppendPrintf(e,"\n");
2105
2106 #define GENGRAPH(X,Y,Z) \
2107 GRAPH_TITLE(Y,Z) \
2108 GRAPH_PER_MIN(X) \
2109 GRAPH_PER_HOUR(X) \
2110 GRAPH_END
2111
2112 static void
2113 statGraphDump(StoreEntry * e)
2114 {
2115 int i;
2116 double dt;
2117
2118 GENGRAPH(client_http.requests, "client_http.requests", "Client HTTP requests/sec");
2119 GENGRAPH(client_http.hits, "client_http.hits", "Client HTTP hits/sec");
2120 GENGRAPH(client_http.errors, "client_http.errors", "Client HTTP errors/sec");
2121 GENGRAPH(client_http.kbytes_in.kb, "client_http.kbytes_in", "Client HTTP kbytes_in/sec");
2122 GENGRAPH(client_http.kbytes_out.kb, "client_http.kbytes_out", "Client HTTP kbytes_out/sec");
2123
2124 /* XXX todo: http median service times */
2125
2126 GENGRAPH(server.all.requests, "server.all.requests", "Server requests/sec");
2127 GENGRAPH(server.all.errors, "server.all.errors", "Server errors/sec");
2128 GENGRAPH(server.all.kbytes_in.kb, "server.all.kbytes_in", "Server total kbytes_in/sec");
2129 GENGRAPH(server.all.kbytes_out.kb, "server.all.kbytes_out", "Server total kbytes_out/sec");
2130
2131 GENGRAPH(server.http.requests, "server.http.requests", "Server HTTP requests/sec");
2132 GENGRAPH(server.http.errors, "server.http.errors", "Server HTTP errors/sec");
2133 GENGRAPH(server.http.kbytes_in.kb, "server.http.kbytes_in", "Server HTTP kbytes_in/sec");
2134 GENGRAPH(server.http.kbytes_out.kb, "server.http.kbytes_out", "Server HTTP kbytes_out/sec");
2135
2136 GENGRAPH(server.ftp.requests, "server.ftp.requests", "Server FTP requests/sec");
2137 GENGRAPH(server.ftp.errors, "server.ftp.errors", "Server FTP errors/sec");
2138 GENGRAPH(server.ftp.kbytes_in.kb, "server.ftp.kbytes_in", "Server FTP kbytes_in/sec");
2139 GENGRAPH(server.ftp.kbytes_out.kb, "server.ftp.kbytes_out", "Server FTP kbytes_out/sec");
2140
2141 GENGRAPH(server.other.requests, "server.other.requests", "Server other requests/sec");
2142 GENGRAPH(server.other.errors, "server.other.errors", "Server other errors/sec");
2143 GENGRAPH(server.other.kbytes_in.kb, "server.other.kbytes_in", "Server other kbytes_in/sec");
2144 GENGRAPH(server.other.kbytes_out.kb, "server.other.kbytes_out", "Server other kbytes_out/sec");
2145
2146 GENGRAPH(icp.pkts_sent, "icp.pkts_sent", "ICP packets sent/sec");
2147 GENGRAPH(icp.pkts_recv, "icp.pkts_recv", "ICP packets received/sec");
2148 GENGRAPH(icp.kbytes_sent.kb, "icp.kbytes_sent", "ICP kbytes_sent/sec");
2149 GENGRAPH(icp.kbytes_recv.kb, "icp.kbytes_recv", "ICP kbytes_received/sec");
2150
2151 /* XXX todo: icp median service times */
2152 /* XXX todo: dns median service times */
2153
2154 GENGRAPH(unlink.requests, "unlink.requests", "Cache File unlink requests/sec");
2155 GENGRAPH(page_faults, "page_faults", "System Page Faults/sec");
2156 GENGRAPH(select_loops, "select_loops", "System Select Loop calls/sec");
2157 GENGRAPH(cputime, "cputime", "CPU utilisation");
2158 }
2159
2160 #endif /* STAT_GRAPHS */
2161
2162 int
2163 statMemoryAccounted(void)
2164 {
2165 return memPoolsTotalAllocated();
2166 }
Mirror of https://github.com/squid-cache/squid.git