a7d3599bc609780de4bea66e08a34821a5cb6c6c
[mirror/dsa-puppet.git] / haproxyng
1 #!/usr/bin/perl
2
3 # haproxyng Munin Plugin
4 # Multigraph plugin which monitors the haproxy service.
5 #  (c) 2014-2015 Jonathan Wright <jon@than.io>
6 #
7 # This program is free software; you can redistribute it and/or
8 # modify it under the terms of the GNU General Public License
9 # as published by the Free Software Foundation; either version 2
10 # of the License, or (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 # GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with this program; if not, write to the Free Software
19 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20
21 # Configure the Perl Environment
22 use warnings;
23 use Carp;
24 use Switch;
25
26 # Import Modules
27 use Munin::Plugin;
28 use IO::Socket::UNIX qw( SOCK_STREAM );
29 use Data::Dumper;
30
31 # Configure Program details
32 our ($_program, $_version, $_author);
33 $_program = 'haproxyng';
34 $_version = '1.0.1';
35 $_author  = 'Jonathan Wright <jon@than.io>';
36
37 use constant {
38   # Field names to locations for all the CSV data provided by HAProxy
39   STAT_PROXY_NAME               => 0,
40   STAT_SERVICE_NAME             => 1,
41   STAT_QUEUED_REQUESTS          => 2,
42   STAT_QUEUED_MAX               => 3,
43   STAT_SESSIONS_CURRENT         => 4,
44   STAT_SESSIONS_MAX             => 5,
45   STAT_SESSIONS_LIMIT           => 6,
46   STAT_CONNECTIONS_TOTAL        => 7,
47   STAT_BYTES_IN                 => 8,
48   STAT_BYTES_OUT                => 9,
49   STAT_REQUESTS_DENIED          => 10,
50   STAT_RESPONSES_DENIED         => 11,
51   STAT_REQUESTS_ERROR           => 12,
52   STAT_CONNECTIONS_ERROR        => 13,
53   STAT_RESPONSES_ERROR          => 14,
54   STAT_CONNECTIONS_RETRIED      => 15,
55   STAT_CONNECTIONS_REDISPATCHED => 16,
56   STAT_STATUS                   => 17,
57   STAT_WEIGHT                   => 18,
58   STAT_SERVER_ACTIVE            => 19, STAT_SERVERS_ACTIVE => 19,
59   STAT_SERVER_BACKUP            => 20, STAT_SERVERS_BACKUP => 20,
60   STAT_CHECKS_FAIL              => 21,
61   STAT_CHECKS_GO_DOWN           => 22,
62   STAT_CHECKS_LAST_CHANGE       => 23,
63   STAT_CHECKS_DOWNTIME          => 24,
64   STAT_QUEUED_LIMIT             => 25,
65   STAT_PID                      => 26,
66   STAT_UID                      => 27,
67   STAT_SID                      => 28,
68   STAT_THROTTLE                 => 29,
69   STAT_SESSIONS_TOTAL           => 30,
70   STAT_TRACKED                  => 31,
71   STAT_SERVICE_TYPE             => 32,
72   STAT_SESSIONS_RATE_CURRENT    => 33,
73   STAT_SESSIONS_RATE_LIMIT      => 34,
74   STAT_SESSIONS_RATE_MAX        => 35,
75   STAT_CHECK_STATUS             => 36,
76   STAT_CHECK_CODE               => 37,
77   STAT_CHECK_DURATION           => 38,
78   STAT_RESPONSES_HTTP_1XX       => 39,
79   STAT_RESPONSES_HTTP_2XX       => 40,
80   STAT_RESPONSES_HTTP_3XX       => 41,
81   STAT_RESPONSES_HTTP_4XX       => 42,
82   STAT_RESPONSES_HTTP_5XX       => 43,
83   STAT_RESPONSES_HTTP_XXX       => 44,
84   STAT_CHECK_FAILED_DETAILS     => 45,
85   STAT_REQUESTS_RATE_CURRENT    => 46,
86   STAT_REQUESTS_RATE_MAX        => 47,
87   STAT_REQUESTS_TOTAL           => 48,
88   STAT_ABORTS_CLIENT            => 49,
89   STAT_ABORTS_SERVER            => 50,
90   STAT_COMPRESSOR_IN            => 51,
91   STAT_COMPRESSOR_OUT           => 52,
92   STAT_COMPRESSOR_BYPASSED      => 53,
93   STAT_COMPRESSOR_REQUESTS      => 54,
94   STAT_SESSIONS_LAST            => 55,
95   STAT_CHECK_HEALTH_LAST        => 56,
96   STAT_CHECK_AGENT_LAST         => 57,
97   STAT_TIME_QUEUE               => 58,
98   STAT_TIME_CONNECT             => 59,
99   STAT_TIME_RESPONSE            => 60,
100   STAT_TIME_TOTAL               => 61,
101   # Types used by HAProxy for some fields
102   TYPE_FRONTEND                 => 0,
103   TYPE_BACKEND                  => 1,
104   TYPE_SERVER                   => 2,
105   TYPE_LISTENER                 => 3,
106   # Types used to define which attributed to give a graph
107   TYPE_BANDWIDTH                => 0,
108   TYPE_TIMING                   => 1,
109   TYPE_SESSIONS                 => 2,
110   TYPE_RESPONSES                => 3,
111   TYPE_BACKENDS                 => 4,
112   # Program-specific constants
113   GRAPH_CATEGORY                => 'haproxyng',
114   GRAPH_WIDTH                   => 500,
115   FETCH                         => 0,
116   CONFIG                        => 1,
117   # Configurable limits
118   MAX_BANDWIDTH                 => (1024**3),
119   MAX_TIMING                    => (1200000),
120   MAX_SESSIONS                  => (10000),
121   MAX_RESPONSES                 => (100000),
122   MAX_BACKENDS                  => (1000),
123   # Constants to match Munin keywords
124   DERIVE                        => 'DERIVE',
125   GAUGE                         => 'GAUGE',
126   AREASTACK                     => 'AREASTACK',
127   LINE1                         => 'LINE1',
128   COLOUR_BLACK                  => '000000',
129 };
130
131 # Configure basic variables for program operation
132 our ($_socket, $_clean, %data);
133 # Get the location of the socket we'll connect to
134 $_socket = exists $ENV{'socket'} ? $ENV{'socket'} : '/var/run/haproxy.sock';
135 $_clean  = (exists $ENV{'clean'} ? quotemeta $ENV{'clean'} : '');
136
137 MAIN: {
138   # This is a special multi-graph plugin, so make sure that whatever version
139   # of Munin we're running in is enabled and configured for it.
140   need_multigraph();
141
142   # Now work out what we are being asked to do, then run it.
143   my $request = $ARGV[0] || "fetch";
144   eval "do_${request}();"
145     or croak "do_${request}: $@";
146   # and then finish
147   exit 0;
148 }
149
150 sub get_data {
151   my ($t, %v); $t = shift;
152
153   my $s = IO::Socket::UNIX->new(
154     Peer    => $_socket,
155     Type    => SOCK_STREAM,
156     Timeout => 1
157   ) or croak "Cannot connect to socket ".$_socket;
158
159   print $s "show stat\n";
160   while (<$s>) {
161     chomp; next unless length;
162     my @stat = split (',');
163
164     switch ($stat[STAT_SERVICE_TYPE]) {
165       # Process all FRONTEND type entries; these are singular and are totals
166       # only for each of the frontends configured
167       case TYPE_FRONTEND {
168         $v{$stat[STAT_PROXY_NAME]} = {
169           type => TYPE_FRONTEND,
170           connections => ($stat[STAT_CONNECTIONS_TOTAL] || 0),
171           sessions    => ($stat[STAT_SESSIONS_CURRENT] || 0),
172           queued      => 0,
173           bandwidth   => {
174             in => ($stat[STAT_BYTES_IN] || 0),
175             out => ($stat[STAT_BYTES_OUT] || 0),
176           },
177           responses   => {
178             total     => ($stat[STAT_REQUESTS_TOTAL] || 0),
179             http1xx   => ($stat[STAT_RESPONSES_HTTP_1XX] || 0),
180             http2xx   => ($stat[STAT_RESPONSES_HTTP_2XX] || 0),
181             http3xx   => ($stat[STAT_RESPONSES_HTTP_3XX] || 0),
182             http4xx   => ($stat[STAT_RESPONSES_HTTP_4XX] || 0),
183             http5xx   => ($stat[STAT_RESPONSES_HTTP_5XX] || 0),
184             httpxxx   => ($stat[STAT_RESPONSES_HTTP_XXX] || 0),
185           },
186         };
187       }
188       # Process all BACKEND type entries; these are the totals for each backend
189       # and don't have the same amount of information as SERVERs
190       case TYPE_BACKEND {
191         # We can't 'set' the hash here as the backend totals are normally after
192         # the backend's servers, so would override anything previously set
193         # in TYPE_SERVER
194         $v{$stat[STAT_PROXY_NAME]}{'type'} = TYPE_BACKEND;
195         $v{$stat[STAT_PROXY_NAME]}{'connections'} = ($stat[STAT_CONNECTIONS_TOTAL] || 0);
196         $v{$stat[STAT_PROXY_NAME]}{'sessions'} = ($stat[STAT_SESSIONS_CURRENT] || 0);
197         $v{$stat[STAT_PROXY_NAME]}{'queued'} = ($stat[STAT_QUEUED_REQUESTS] || 0);
198         $v{$stat[STAT_PROXY_NAME]}{'active'} = ($stat[STAT_SERVERS_ACTIVE] || 0);
199         $v{$stat[STAT_PROXY_NAME]}{'backup'} = ($stat[STAT_SERVERS_BACKUP] || 0);
200         $v{$stat[STAT_PROXY_NAME]}{'bandwidth'} = {
201           in => ($stat[STAT_BYTES_IN] || 0),
202           out => ($stat[STAT_BYTES_OUT] || 0),
203         };
204         $v{$stat[STAT_PROXY_NAME]}{'responses'} = {
205             total     => ($stat[STAT_RESPONSES_HTTP_1XX] || 0)
206                       +  ($stat[STAT_RESPONSES_HTTP_2XX] || 0)
207                       +  ($stat[STAT_RESPONSES_HTTP_3XX] || 0)
208                       +  ($stat[STAT_RESPONSES_HTTP_4XX] || 0)
209                       +  ($stat[STAT_RESPONSES_HTTP_5XX] || 0)
210                       +  ($stat[STAT_RESPONSES_HTTP_XXX] || 0),
211             http1xx   => ($stat[STAT_RESPONSES_HTTP_1XX] || 0),
212             http2xx   => ($stat[STAT_RESPONSES_HTTP_2XX] || 0),
213             http3xx   => ($stat[STAT_RESPONSES_HTTP_3XX] || 0),
214             http4xx   => ($stat[STAT_RESPONSES_HTTP_4XX] || 0),
215             http5xx   => ($stat[STAT_RESPONSES_HTTP_5XX] || 0),
216             httpxxx   => ($stat[STAT_RESPONSES_HTTP_XXX] || 0),
217         };
218       }
219       # Process all SERVER type entries, which are the most details and give
220       # information about how each server is responding
221       case TYPE_SERVER {
222         # Only set the server itself directly, otherwise we may override
223         # anything previously set
224         $v{$stat[STAT_PROXY_NAME]}{'servers'}{$stat[STAT_SERVICE_NAME]} = {
225           active      => ($stat[STAT_SERVER_ACTIVE] ? 1 : 0),
226           backup      => ($stat[STAT_SERVER_BACKUP] ? 1 : 0),
227           up          => ($stat[STAT_STATUS] eq 'UP' ? 1 : 0),
228           down        => ($stat[STAT_STATUS] eq 'DOWN' ? 1 : 0),
229           disabled    => ($stat[STAT_STATUS] =~ /^(MAINT|DRAIN|NOLB)/i ? 1 : 0),
230           connections => ($stat[STAT_CONNECTIONS_TOTAL] || 0),
231           sessions    => ($stat[STAT_SESSIONS_CURRENT] || 0),
232           queued      => ($stat[STAT_QUEUED_REQUESTS] || 0),
233           bandwidth   => {
234             in => ($stat[STAT_BYTES_IN] || 0),
235             out => ($stat[STAT_BYTES_OUT] || 0),
236           },
237           status      => ($stat[STAT_STATUS] || 0),
238           timing      => {
239             queue     => ($stat[STAT_TIME_QUEUE] || 0),
240             connect   => ($stat[STAT_TIME_CONNECT] || 0),
241             response  => ($stat[STAT_TIME_RESPONSE] || 0),
242             total     => ($stat[STAT_TIME_TOTAL] || 0)
243           },
244           responses   => {
245             total     => ($stat[STAT_RESPONSES_HTTP_1XX] || 0)
246                       +  ($stat[STAT_RESPONSES_HTTP_2XX] || 0)
247                       +  ($stat[STAT_RESPONSES_HTTP_3XX] || 0)
248                       +  ($stat[STAT_RESPONSES_HTTP_4XX] || 0)
249                       +  ($stat[STAT_RESPONSES_HTTP_5XX] || 0)
250                       +  ($stat[STAT_RESPONSES_HTTP_XXX] || 0),
251             http1xx   => ($stat[STAT_RESPONSES_HTTP_1XX] || 0),
252             http2xx   => ($stat[STAT_RESPONSES_HTTP_2XX] || 0),
253             http3xx   => ($stat[STAT_RESPONSES_HTTP_3XX] || 0),
254             http4xx   => ($stat[STAT_RESPONSES_HTTP_4XX] || 0),
255             http5xx   => ($stat[STAT_RESPONSES_HTTP_5XX] || 0),
256             httpxxx   => ($stat[STAT_RESPONSES_HTTP_XXX] || 0),
257           },
258         };
259       }
260     }
261   }
262
263   # print Dumper(\%v);
264   return %v;
265 }
266
267 sub mg_fetch {
268   my ($type, $name, $values) = (shift, shift, shift);
269
270   my %values_ = %{$values};
271   my $type_ = $type eq TYPE_FRONTEND ? '_fe' :
272               $type eq TYPE_BACKEND  ? '_be' : '';
273
274   my $name_;
275   foreach my $level (@{$name}) {
276     $level =~ s/[^a-z0-9]+/_/g;
277     $name_ .= ($name_ ? '.' : '').$level;
278   }
279
280   printf "multigraph %s%s_%s\n", GRAPH_CATEGORY, $type_, $name_;
281   foreach my $key (sort keys %values_) {
282     (my $key_ = $key) =~ s/[^a-z0-9]+/_/g;
283     printf "%s.value %0.0f\n", $key_, $values_{$key};
284   }
285   print "\n";
286 }
287
288 sub mg_config {
289   my ($graph, $type, $name, $title, $metrics) = (shift, shift, shift, shift, shift, shift);
290
291   my %metrics_ = %{$metrics};
292
293   my $type_  = $type eq TYPE_FRONTEND ? '_fe' :
294                $type eq TYPE_BACKEND  ? '_be' : '';
295
296      $title  =~ s/$_clean//g if $_clean;
297   my $title_ = $type eq TYPE_FRONTEND ? ' Frontend' :
298                $type eq TYPE_BACKEND  ? ' Backend' : '';
299
300   my $name_;
301   foreach my $level (@{$name}) {
302     next unless $level;
303     $level =~ s/[^a-z0-9]+/_/g;
304     $name_ .= ($name_ ? '.' : '').$level;
305   }
306
307   my $max = undef;
308
309   printf "multigraph %s%s_%s\n", GRAPH_CATEGORY, $type_, $name_;
310   printf "graph_category %s\n", GRAPH_CATEGORY;
311   printf "graph_title HAProxy%s %s\n", $title_, $title;
312   printf "graph_width %d\n", GRAPH_WIDTH;
313
314   switch ($graph) {
315     case TYPE_BANDWIDTH {
316       print "graph_args --base 1024\n".
317             "graph_vlabel bits/second [in(-); out(+)]\n";
318       $max = MAX_BANDWIDTH;
319     }
320     case TYPE_TIMING {
321       print "graph_args --base 1000\n".
322             "graph_vlabel Time in Seconds\n";
323       $max = MAX_TIMING;
324     }
325     case TYPE_SESSIONS {
326       print "graph_args --base 1000\n".
327             "graph_vlabel [Queued(-); Sessions(+)]\n";
328       $max = MAX_SESSIONS;
329     }
330     case TYPE_RESPONSES {
331       print "graph_args --base 1000\n".
332             "graph_vlabel Responses per Second\n";
333       $max = MAX_RESPONSES;
334     }
335     case TYPE_BACKENDS {
336       print "graph_args --base 1000\n".
337             "graph_vlabel Total Backends\n";
338       $max = MAX_BACKENDS;
339     }
340   }
341
342   foreach my $metric (sort keys %metrics_) {
343     (my $metric_ = $metric) =~ s/[^a-z0-9]+/_/g;
344     foreach my $key (keys %{$metrics_{$metric}}) {
345       switch ($key) {
346         case 'label' {
347           my $value = $metrics_{$metric}{$key};
348              $value =~ s/$_clean//g if $_clean;
349           printf "%s.%s %s\n", $metric_, $key, $value;
350         }
351         case 'cdef' {
352           printf "%s.%s %s\n", $metric_, $key, $metric_.','.$metrics_{$metric}{$key};
353         }
354         case 'negative' {
355           my $value = $metrics_{$metric}{$key};
356              $value =~ s/[^a-z0-9]+/_/g;
357           printf "%s.%s %s\n", $metric_, $key, $value;
358         }
359
360         printf "%s.%s %s\n", $metric_, $key, $metrics_{$metric}{$key};
361       }
362     }
363     # Always add min/max if max has been defined
364     if ($max) {
365       printf "%s.%s %s\n", $metric_, 'min', 0;
366       printf "%s.%s %s\n", $metric_, 'max', $max if $max;
367     }
368   }
369   print "\n";
370 }
371
372 # frontend(bandwidth)
373 # backend(bandwidth)
374 # frontend(bandwidth/service)
375 # backend(bandwidth/service)
376 # backend(bandwidth/service/host)
377
378 sub haproxy_bandwidth {
379   my ($operation, $data_) = (shift, shift);
380   my %data = %{$data_};
381
382   switch ($operation) {
383
384     case CONFIG {
385
386       my (%fe_metrics, %be_metrics, %submetrics);
387
388       foreach my $service (sort keys %data) {
389         undef %submetrics;
390
391         # Prepare the field configuration
392         my %in = (
393           label     => $service,
394           type      => DERIVE,
395           cdef      => '8,*',
396           graph     => 'no',
397         );
398         my %out = (
399           label     => $service,
400           type      => DERIVE,
401           cdef      => '8,*',
402           draw      => AREASTACK,
403           negative  => "${service}_in",
404         );
405
406         # This will copy the hash for the main metric
407         switch ($data{$service}{'type'}) {
408           case TYPE_FRONTEND {
409             %{$fe_metrics{"${service}_in"}} = %in;
410             %{$fe_metrics{"${service}_out"}} = %out;
411
412           }
413           case TYPE_BACKEND {
414             %{$be_metrics{"${service}_in"}} = %in;
415             %{$be_metrics{"${service}_out"}} = %out;
416           }
417         }
418
419         # next unless $data{$service}{'type'} eq TYPE_BACKEND;
420
421         # Override these for the totals in the sub metric graph
422         $in{'label'} = $out{'label'} = 'Total';
423         $out{'negative'} = 'total_in';
424         $out{'draw'} = LINE1;
425
426         # This will copy the hash for the submetric
427         %{$submetrics{'total_in'}} = %in;
428         %{$submetrics{'total_out'}} = %out;
429           $submetrics{'total_out'}{'colour'} = COLOUR_BLACK;
430
431         # Loop through each of the available servers
432         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
433           next if $data{$service}{'servers'}{$server}{'backup'};
434           # Override these for the per-Service graph
435           $in{'label'} = $out{'label'} = $server;
436           $out{'negative'} = "${server}_in";
437           $out{'draw'} = AREASTACK;
438
439           # This will copy the hash for the submetric
440           %{$submetrics{"${server}_in"}} = %in;
441           %{$submetrics{"${server}_out"}} = %out;
442
443           # Override these for the per-Host graph
444           $in{'label'} = $out{'label'} = 'Bandwidth';
445           $out{'negative'} = 'total_in';
446           $out{'draw'} = LINE1;
447           $out{'colour'} = COLOUR_BLACK;
448
449           mg_config(TYPE_BANDWIDTH, $data{$service}{'type'}, ['bandwidth', $service, $server],
450                     'Bandwidth for '.$service.' via '.$server, {
451             total_in  => \%in,
452             total_out => \%out,
453           });
454
455           delete $out{'colour'};
456         }
457
458         mg_config(TYPE_BANDWIDTH, $data{$service}{'type'}, ['bandwidth', $service],
459                   'Bandwidth for '.$service, \%submetrics);
460       }
461
462       mg_config(TYPE_BANDWIDTH, TYPE_FRONTEND, ['bandwidth'],
463                 'Bandwidth Overview', \%fe_metrics);
464       mg_config(TYPE_BANDWIDTH, TYPE_BACKEND, ['bandwidth'],
465                 'Bandwidth Overview', \%be_metrics);
466
467     }
468
469     case FETCH {
470
471       my (%values);
472       foreach my $service (sort keys %data) {
473         next unless $data{$service}{'type'} eq TYPE_FRONTEND;
474         $values{"${service}_in"}  = $data{$service}{'bandwidth'}{'in'};
475         $values{"${service}_out"} = $data{$service}{'bandwidth'}{'out'};
476       }
477
478       mg_fetch(TYPE_FRONTEND, ['bandwidth'], \%values);
479
480       undef %values;
481
482       foreach my $service (sort keys %data) {
483         next unless $data{$service}{'type'} eq TYPE_BACKEND;
484         $values{"${service}_in"}  = $data{$service}{'bandwidth'}{'in'};
485         $values{"${service}_out"} = $data{$service}{'bandwidth'}{'out'};
486       }
487
488       mg_fetch(TYPE_BACKEND, ['bandwidth'], \%values);
489
490       foreach my $service (sort keys %data) {
491         %values = (
492           total_in  => $data{$service}{'bandwidth'}{'in'},
493           total_out => $data{$service}{'bandwidth'}{'out'},
494         );
495
496         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
497           next if $data{$service}{'servers'}{$server}{'backup'};
498           $values{"${server}_in"}  = $data{$service}{'servers'}{$server}{'bandwidth'}{'in'};
499           $values{"${server}_out"} = $data{$service}{'servers'}{$server}{'bandwidth'}{'out'};
500           mg_fetch($data{$service}{'type'}, ['bandwidth', $service, $server], {
501             total_in  => $data{$service}{'servers'}{$server}{'bandwidth'}{'in'},
502             total_out => $data{$service}{'servers'}{$server}{'bandwidth'}{'out'},
503           });
504         }
505
506         mg_fetch($data{$service}{'type'}, ['bandwidth', $service], \%values);
507
508       }
509
510     }
511   }
512 }
513
514 # backend(timing)
515 # backend(timing/service)
516 # backend(timing/service/host)
517
518 sub haproxy_timing {
519   my ($operation, $data_) = (shift, shift);
520   my %data = %{$data_};
521
522   switch ($operation) {
523
524     case CONFIG {
525
526       my (%metrics, %submetrics);
527
528       foreach my $service (sort keys %data) {
529         next unless $data{$service}{'type'} eq TYPE_BACKEND;
530
531         undef %submetrics;
532
533         # Prepare the field configuration
534         my %time = (
535           label     => $service,
536           type      => GAUGE,
537           cdef      => '1000,/',
538           draw      => LINE1,
539         );
540
541         # This will copy the hash for the main metric
542         %{$metrics{$service}} = %time;
543
544         # Loop through each of the available servers
545         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
546           next if $data{$service}{'servers'}{$server}{'backup'};
547           # Override these for the per-Service graph
548           $time{'label'} = $server;
549
550           # This will copy the hash for the submetric
551           %{$submetrics{$server}} = %time;
552
553           # Copy and override these for the per-Host graph
554           my %queue     = %time; $queue{'label'}    = 'Queue';
555           my %connect   = %time; $connect{'label'}  = 'Connect';
556           my %response  = %time; $response{'label'} = 'Response';
557           my %total     = %time; $total{'label'}    = 'Total';
558
559           mg_config(TYPE_TIMING, TYPE_BACKEND, ['timing', $service, $server],
560                     'Server Timing for '.$service.' via '.$server, {
561             queue     => \%queue,
562             connect   => \%connect,
563             response  => \%response,
564             total     => \%total,
565           });
566         }
567
568         mg_config(TYPE_TIMING, TYPE_BACKEND, ['timing', $service],
569                   'Server Timing for '.$service, \%submetrics);
570       }
571
572       mg_config(TYPE_TIMING, TYPE_BACKEND, ['timing'],
573                 'Server Timing Overview', \%metrics);
574
575     }
576
577     case FETCH {
578
579       my (%values);
580
581       foreach my $service (sort keys %data) {
582         next unless $data{$service}{'type'} eq TYPE_BACKEND;
583         my ($count, $total) = (0,0);
584         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
585           ++$count;
586           $total+=$data{$service}{'servers'}{$server}{'timing'}{'total'};
587         }
588
589         $values{$service} = ($count > 0 ? $total/$count : 0);
590       }
591
592       mg_fetch(TYPE_BACKEND, ['timing'], \%values);
593
594
595       foreach my $service (sort keys %data) {
596         next unless $data{$service}{'type'} eq TYPE_BACKEND;
597         undef %values;
598
599         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
600           next if $data{$service}{'servers'}{$server}{'backup'};
601           $values{$server} = $data{$service}{'servers'}{$server}{'timing'}{'total'};
602           mg_fetch(TYPE_BACKEND, ['timing', $service, $server],
603                    $data{$service}{'servers'}{$server}{'timing'});
604         }
605
606         mg_fetch(TYPE_BACKEND, ['timing', $service], \%values);
607
608       }
609
610     }
611   }
612 }
613
614 # frontend(sessions)
615 # frontend(sessions/service)
616 # backend(sessions)
617 # backend(sessions/service)
618 # backend(sessions/service/host)
619
620 sub haproxy_sessions {
621   my ($operation, $data_) = (shift, shift);
622   my %data = %{$data_};
623
624   switch ($operation) {
625
626     case CONFIG {
627
628       my (%metrics, %submetrics);
629
630       foreach my $service (sort keys %data) {
631         next unless $data{$service}{'type'} eq TYPE_FRONTEND;
632
633         my %sessions = (
634           label     => $service,
635           type      => GAUGE,
636           draw      => LINE1,
637         );
638
639         %{$metrics{"${service}_sessions"}} = %sessions;
640
641         # Override these for the per-Service graph
642         $sessions{'label'} = 'Sessions';
643
644         mg_config(TYPE_SESSIONS, TYPE_FRONTEND, ['sessions', $service],
645                   'Sessions for '.$service, {
646           sessions => \%sessions,
647         });
648       }
649
650       mg_config(TYPE_SESSIONS, TYPE_FRONTEND, ['sessions'],
651                 'Sessions Overview', \%metrics);
652
653       undef %metrics;
654
655       foreach my $service (sort keys %data) {
656         next unless $data{$service}{'type'} eq TYPE_BACKEND;
657
658         undef %submetrics;
659
660         # Prepare the field configuration
661         my %queued    = (
662           label     => $service,
663           type      => GAUGE,
664           graph     => 'no',
665         );
666         my %sessions  = (
667           label     => $service,
668           type      => GAUGE,
669           draw      => LINE1,
670           negative  => "${service}_queued",
671         );
672
673         # This will copy the hash for the main metric
674         %{$metrics{"${service}_queued"}} = %queued;
675         %{$metrics{"${service}_sessions"}} = %sessions;
676
677         # Override these for the totals in the sub metric graph
678         $queued{'label'} = $sessions{'label'} = 'Total';
679         $out{'negative'} = 'total_queued';
680         $out{'draw'} = LINE1;
681
682         # This will copy the hash for the submetric
683         %{$submetrics{'total_queued'}} = %queued;
684         %{$submetrics{'total_sessions'}} = %sessions;
685
686         # Loop through each of the available servers
687         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
688           next if $data{$service}{'servers'}{$server}{'backup'};
689           # Override these for the per-Service graph
690           $in{'label'} = $out{'label'} = $server;
691           $out{'negative'} = "${server}_queued";
692           $out{'draw'} = AREASTACK;
693
694           # This will copy the hash for the submetric
695           %{$submetrics{"${server}_queued"}} = %queued;
696           %{$submetrics{"${server}_sessions"}} = %sessions;
697
698           # Override these for the per-Host graph
699           $in{'label'} = $out{'label'} = 'Sessions';
700           $out{'negative'} = 'queued';
701           $out{'draw'} = LINE1;
702
703           mg_config(TYPE_SESSIONS, TYPE_BACKEND, ['sessions', $service, $server],
704                     'Sessions for '.$service.' via '.$server, {
705             queued    => \%queued,
706             sessions  => \%sessions,
707           });
708         }
709
710         mg_config(TYPE_SESSIONS, TYPE_BACKEND, ['sessions', $service],
711                   'Sessions for '.$service, \%submetrics);
712       }
713
714       mg_config(TYPE_SESSIONS, TYPE_BACKEND, ['sessions'],
715                 'Sessions Overview', \%metrics);
716
717     }
718
719     case FETCH {
720
721       my (%values);
722
723       foreach my $service (sort keys %data) {
724         next unless $data{$service}{'type'} eq TYPE_FRONTEND;
725         $values{"${service}_sessions"} = $data{$service}{'sessions'};
726         mg_fetch(TYPE_FRONTEND, ['sessions', $service], {
727           sessions => $data{$service}{'sessions'},
728         });
729       }
730
731       mg_fetch(TYPE_FRONTEND, ['sessions'], \%values);
732
733       undef %values;
734
735       foreach my $service (sort keys %data) {
736         next unless $data{$service}{'type'} eq TYPE_BACKEND;
737         $values{"${service}_sessions"} = $data{$service}{'sessions'};
738         $values{"${service}_queued"} = $data{$service}{'queued'};
739       }
740
741       mg_fetch(TYPE_BACKEND, ['sessions'], \%values);
742
743       foreach my $service (sort keys %data) {
744         next unless $data{$service}{'type'} eq TYPE_BACKEND;
745
746         %values = (
747           total_sessions => $data{$service}{'sessions'},
748           total_queued => $data{$service}{'queued'},
749         );
750
751         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
752           next if $data{$service}{'servers'}{$server}{'backup'};
753
754           $values{"${server}_sessions"} = $data{$service}{'servers'}{$server}{'sessions'};
755           $values{"${server}_queued"} = $data{$service}{'servers'}{$server}{'queued'};
756
757           mg_fetch(TYPE_BACKEND, ['sessions', $service, $server], {
758             sessions  => $data{$service}{'servers'}{$server}{'sessions'},
759             queued    => $data{$service}{'servers'}{$server}{'queued'},
760           });
761         }
762
763         mg_fetch(TYPE_BACKEND, ['sessions', $service], \%values);
764
765       }
766
767     }
768   }
769 }
770
771 # frontend(responses)
772 # frontend(responses/service(status))
773 # frontend(responses/service(status)/status)
774 # backend(responses)
775 # backend(responses/service(server))
776 # backend(responses/service(server)/server)
777 # backend(responses/service(status))
778 # backend(responses/service(status)/status)
779 # backend(responses/service(status)/status/server)
780
781 sub haproxy_responses {
782   my ($operation, $data_) = (shift, shift);
783   my %data = %{$data_};
784
785   switch ($operation) {
786
787     case CONFIG {
788
789       my (%fe_metrics, %be_metrics, %submetrics, $subsubmetrics);
790
791       foreach my $service (sort keys %data) {
792         my %response = (
793           label     => $service,
794           type      => DERIVE,
795           draw      => LINE1,
796         );
797
798         switch ($data{$service}{'type'}) {
799           case TYPE_FRONTEND {
800             %{$fe_metrics{$service}} = %response;
801           }
802           case TYPE_BACKEND {
803             %{$be_metrics{$service}} = %response;
804           }
805         }
806
807         undef %submetrics;
808
809         foreach my $response (sort keys %{$data{$service}{'responses'}}) {
810           $response_ = ($response  =~ /([12345])xx$/ ? "HTTP ${1}xx" :
811                         $response  eq 'total'        ? "Total"       : "Other");
812           $draw_     = ($response_ eq 'Total'        ? LINE1       : AREASTACK);
813
814           %{$submetrics{$response}} = (
815             label   => $response_,
816             type    => DERIVE,
817             draw    => $draw_,
818           );
819
820           $submetrics{$response}{'colour'} = COLOUR_BLACK if $response eq 'total';
821
822           switch ($data{$service}{'type'}) {
823             case TYPE_FRONTEND {
824               mg_config(TYPE_RESPONSES, $data{$service}{'type'}, ['responses', $service, $response],
825                         "${response_} Responses for ${service}", {
826                 responses => {
827                   label   => 'Responses',
828                   type    => DERIVE,
829                   draw    => LINE1,
830                 }
831               });
832             }
833             case TYPE_BACKEND {
834
835               undef %subsubmetrics;
836
837               foreach my $server (sort keys %{$data{$service}{'servers'}}) {
838                 next if $data{$service}{'servers'}{$server}{'backup'};
839                 %{$subsubmetrics{$server}} = (
840                   label   => $server,
841                   type    => DERIVE,
842                   draw    => AREASTACK,
843                 );
844                 mg_config(TYPE_RESPONSES, $data{$service}{'type'}, ['responses', $service, $response, $server],
845                           "${response_} Responses for ${service} via ${server}", {
846                   responses => {
847                     label   => 'Responses',
848                     type    => DERIVE,
849                     draw    => LINE1,
850                   }
851                 });
852               }
853
854               %{$subsubmetrics{'total'}} = (
855                 label   => 'Total',
856                 type    => DERIVE,
857                 draw    => LINE1,
858                 colour  => COLOUR_BLACK,
859               );
860
861               mg_config(TYPE_RESPONSES, $data{$service}{'type'}, ['responses', $service, $response],
862                         "${response_} Responses for ${service}", \%subsubmetrics);
863             }
864           }
865
866         }
867
868         mg_config(TYPE_RESPONSES, $data{$service}{'type'}, ['responses', $service],
869                   'Responses for '.$service, \%submetrics);
870       }
871
872       mg_config(TYPE_RESPONSES, TYPE_FRONTEND, ['responses'],
873                 'Responses Overview', \%fe_metrics);
874       mg_config(TYPE_RESPONSES, TYPE_BACKEND, ['responses'],
875                 'Responses Overview', \%be_metrics);
876
877     }
878
879     case FETCH {
880
881       my (%values, %subvalues);
882
883       foreach my $service (sort keys %data) {
884         next unless $data{$service}{'type'} eq TYPE_FRONTEND;
885         $values{$service} = $data{$service}{'responses'}{'total'};
886         mg_fetch(TYPE_FRONTEND, ['responses', $service], $data{$service}{'responses'});
887         foreach my $response (sort keys %{$data{$service}{'responses'}}) {
888           mg_fetch(TYPE_FRONTEND, ['responses', $service, $response], {
889             responses => $data{$service}{'responses'}{$response}
890           });
891         }
892       }
893
894       mg_fetch(TYPE_FRONTEND, ['responses'], \%values);
895
896       undef %values;
897
898       foreach my $service (sort keys %data) {
899         next unless $data{$service}{'type'} eq TYPE_BACKEND;
900
901         $values{$service} = $data{$service}{'responses'}{'total'};
902
903         %subvalues = (
904           total => $data{$service}{'responses'}{'total'},
905         );
906
907         mg_fetch(TYPE_BACKEND, ['responses', $service], $data{$service}{'responses'});
908
909         foreach my $response (sort keys %{$data{$service}{'responses'}}) {
910           undef %subvalues;
911
912           foreach my $server (sort keys %{$data{$service}{'servers'}}) {
913             next if $data{$service}{'servers'}{$server}{'backup'};
914
915             $subvalues{$server} = $data{$service}{'servers'}{$server}{'responses'}{$response};
916             mg_fetch(TYPE_BACKEND, ['responses', $service, $response, $server], {
917               responses => $data{$service}{'servers'}{$server}{'responses'}{$response},
918             });
919           }
920
921           $subvalues{'total'} = $data{$service}{'responses'}{$response};
922
923           mg_fetch(TYPE_BACKEND, ['responses', $service, $response], \%subvalues);
924         }
925       }
926
927       mg_fetch(TYPE_BACKEND, ['responses'], \%values);
928
929     }
930
931   }
932 }
933
934 sub haproxy_count {
935   my ($operation, $data_) = (shift, shift);
936   my %data = %{$data_};
937
938   switch ($operation) {
939
940     case CONFIG {
941
942       my (%metrics, %submetrics);
943
944       foreach my $service (sort keys %data) {
945         next unless $data{$service}{'type'} eq TYPE_BACKEND;
946
947         # Prepare the field configuration
948         my %count = (
949           label     => $service,
950           type      => GAUGE,
951           draw      => AREASTACK,
952         );
953
954         # This will copy the hash for the main metric
955         %{$metrics{$service}} = %count;
956           $metrics{$service}{'draw'} = LINE1;
957
958         # Copy and override these for the per-Service graph
959         my %backup    = %count; $backup{'label'}    = 'Backup';
960         my %down      = %count; $down{'label'}      = 'Down';
961         my %disabled  = %count; $disabled{'label'}  = 'Disabled';
962         my %up        = %count; $up{'label'}        = 'Up';
963
964         mg_config(TYPE_BACKEND, TYPE_BACKEND, ['count', $service],
965                   'Server Count for '.$service, {
966           backup    => \%backup,
967           down      => \%down,
968           disabled  => \%disabled,
969           up        => \%up,
970         });
971       }
972
973       mg_config(TYPE_BACKEND, TYPE_BACKEND, ['count'],
974                 'Server Count Overview', \%metrics);
975
976     }
977
978     case FETCH {
979
980       my (%values);
981
982       foreach my $service (sort keys %data) {
983         next unless $data{$service}{'type'} eq TYPE_BACKEND;
984
985         my ($backup, $disabled, $down, $up) = (0,0,0,0);
986         foreach my $server (sort keys %{$data{$service}{'servers'}}) {
987           ++$backup   if $data{$service}{'servers'}{$server}{'backup'}
988                      and not $data{$service}{'servers'}{$server}{'down'}
989                      and not $data{$service}{'servers'}{$server}{'disabled'};
990           ++$disabled if $data{$service}{'servers'}{$server}{'disabled'};
991           ++$down     if $data{$service}{'servers'}{$server}{'down'};
992           ++$up       if $data{$service}{'servers'}{$server}{'up'}
993                      and not $data{$service}{'servers'}{$server}{'backup'};
994         }
995
996         $values{$service} = $up;
997
998         mg_fetch(TYPE_BACKEND, ['count', $service], {
999           backup    => $backup,
1000           disabled  => $disabled,
1001           down      => $down,
1002           up        => $up,
1003         });
1004       }
1005
1006       mg_fetch(TYPE_BACKEND, ['count'], \%values);
1007
1008     }
1009
1010   }
1011 }
1012
1013 sub do_fetch {
1014   my %data = get_data;
1015   exit 1 unless scalar(keys %data);
1016
1017   haproxy_bandwidth FETCH, \%data;
1018   haproxy_timing FETCH, \%data;
1019   haproxy_sessions FETCH, \%data;
1020   haproxy_count FETCH, \%data;
1021   haproxy_responses FETCH, \%data;
1022
1023   # Return something or the eval() will fail above
1024   return 1;
1025 }
1026
1027 sub do_config {
1028   my %data = get_data;
1029   exit 1 unless scalar(keys %data);
1030
1031   haproxy_bandwidth CONFIG, \%data;
1032   haproxy_timing CONFIG, \%data;
1033   haproxy_sessions CONFIG, \%data;
1034   haproxy_count CONFIG, \%data;
1035   haproxy_responses CONFIG, \%data;
1036
1037   return 1;
1038 }
1039
1040 sub do_autoconf {
1041   # All Munin wants to know is will this plugin provide all the configuration
1042   # settings and options itself? Well, yes...
1043   print "".(-S $_socket ? "yes" : "no")."\n";
1044   return 1;
1045 }