File Coverage

blib/lib/HealthCheck/Diagnostic/RabbitMQ.pm

Criterion	Covered	Total	%
statement	102	104	98.0
branch	48	54	88.8
condition	40	44	90.9
subroutine	11	11	100.0
pod	3	3	100.0
total	204	216	94.4

package HealthCheck::Diagnostic::RabbitMQ;

# ABSTRACT: Check connectivity and queues on a RabbitMQ server
use version;
our $VERSION = 'v1.3.0'; # VERSION

use 5.010;
use strict;
use warnings;
use parent 'HealthCheck::Diagnostic';

use Carp;

sub new {
    my ($class, @params) = @_;

    # Allow either a hashref or even-sized list of params
    my %params = @params == 1 && ( ref $params[0] || '' ) eq 'HASH'
        ? %{ $params[0] } : @params;

    return $class->SUPER::new(
        label => 'rabbit_mq',
        %params
    );
}

sub check {
    my ( $self, %params ) = @_;

    # The method the object needs to have for us to proceed
    my $method = 'get_server_properties';

    # These are the params that we actually use to make our decisions
    # and that we're going to return in the result to make that clear.
    my %decision_params = ( rabbit_mq => undef );

    my @limits = qw(
        listeners_min_critical
        listeners_min_warning
        listeners_max_critical
        listeners_max_warning

        messages_critical
        messages_warning
    );

    # If we have a queue to check, that changes our requirements
    if ( defined $params{queue}
        or ( ref $self and defined $self->{queue} ) )
    {
        $method = 'queue_declare';
        $decision_params{$_} = undef for qw(
            queue
            channel
        ), @limits;
    }

    # Now we prefer the params passed to check,
    # and fall back to what is on the instance.
    foreach my $param ( keys %decision_params ) {
        $decision_params{$param}
            = exists $params{$param} ? $params{$param}
            : ref $self              ? $self->{$param}
            :                          undef;
    }

    # No need to return the limits we aren't using in the result
    delete @decision_params{ grep { !defined $decision_params{$_} } @limits };

    # The rabbit_mq param was only "known" so we could choose between
    # one that was passed to check and the one on the instance.
    my $rabbit_mq = delete $decision_params{rabbit_mq};
    my $should_disconnect = 0;
    if (ref $rabbit_mq eq 'CODE') {
        local $@;
        ($rabbit_mq, $should_disconnect) = eval {
            local $SIG{__DIE__};
            $rabbit_mq->(%params);
        };
        if ($@) {
            return $self->summarize({ status => 'CRITICAL', info => "$@" })
        }
    }

    croak("'rabbit_mq' must have '$method' method") unless $rabbit_mq and do {
        local $@; eval { local $SIG{__DIE__}; $rabbit_mq->can($method) } };

    # Any "should_disconnect" in the params or the instance should take
    # precedence over what might have been returned by a coderef:
    #
    $should_disconnect = exists $params{should_disconnect}
                              ? $params{should_disconnect}
                              : (ref $self && exists $self->{should_disconnect})
                                     ? $self->{should_disconnect}
                                     : $should_disconnect;

    # In theory we could default to random channel in the
    # range of 1..$rabbit_mq->get_max_channel
    # but then we would have to:
    # 1. Hope it's not in use
    # 2. Open and then close it.
    # Instead we default to 1 as that's what our internal code does.
    $decision_params{channel} //= 1
        if exists $decision_params{channel};

    my $res = $self->SUPER::check(
        %params,
        %decision_params,
        rabbit_mq => $rabbit_mq,
        should_disconnect => $should_disconnect,
    );

    # Make sure we report what we actually *used*
    # not what our parent may have copied out of %{ $self }
    $res->{data} = { %{ $res->{data} || {} }, %decision_params }
        if %decision_params;
    delete $res->{rabbit_mq};    # don't include the object in the result

    return $res;
}

sub run {
    my ( $self, %params ) = @_;
    my $rabbit_mq = $params{rabbit_mq};

    my $cb = sub { $rabbit_mq->get_server_properties };

    if ( defined $params{queue} ) {
        my $queue   = $params{queue};
        my $channel = $params{channel};

        $cb = sub {
            my ( $name, $messages, $listeners )
                = $rabbit_mq->queue_declare( $channel, $queue,
                { passive => 1 } );

            my $server_properties;
            if ($rabbit_mq->can("get_server_properties")) {
                $server_properties = $rabbit_mq->get_server_properties;
            }

            return {
                (   $server_properties
                    ? (server_properties => $server_properties)
                    : ()
                ),
                name      => $name,
                messages  => $messages,
                listeners => $listeners,
            };
        };
    }

    my $data;
    {
        local $@;
        eval {
            local $SIG{__DIE__};
            $data = $cb->();
            $rabbit_mq->disconnect if $params{should_disconnect};
        };

        if ( my $e = $@ ) {
            my $file = quotemeta __FILE__;
            $e =~ s/ at $file line \d+\.?\n\Z//ms;
            $e =~ s/^Declaring queue: //;
            return { status => 'CRITICAL', info => $e };
        }
    }

    my %res = ( status => 'OK', data => $data );

    if ( defined $data->{listeners} ) {
        my $listeners = $data->{listeners};
        if ((   defined $params{listeners_max_critical}
                and $params{listeners_max_critical} <= $listeners
            )
            or ( defined $params{listeners_min_critical}
                and $params{listeners_min_critical} >= $listeners )
            )
        {
            my $min = $params{listeners_min_critical};
            my $max = $params{listeners_max_critical};
            $res{status} = 'CRITICAL';
            my $info = "Listeners out of range! Expected";
            $info .= " min: $min" if defined $min;
            $info .= " max: $max" if defined $max;
            $res{info} = "$info have: $listeners";
        }
        elsif (
            (   defined $params{listeners_max_warning}
                and $params{listeners_max_warning} <= $listeners
            )
            or ( defined $params{listeners_min_warning}
                and $params{listeners_min_warning} >= $listeners )
            )
        {
            my $min = $params{listeners_min_warning};
            my $max = $params{listeners_max_warning};
            $res{status} = 'WARNING';
            my $info = "Listeners out of range! Expected";
            $info .= " min: $min" if defined $min;
            $info .= " max: $max" if defined $max;
            $res{info} = "$info have: $listeners";
        }
    }

    if ( $res{status} ne 'CRITICAL' and defined $data->{messages} ) {
        my $messages = $data->{messages};
        if ( defined $params{messages_critical}
            and $params{messages_critical} <= $messages )
        {
            $res{status} = 'CRITICAL';
            $res{info} = sprintf(
                "Messages out of range! Expected max: %d have: %d",
                $params{messages_critical},
                $messages,
            );
        }
        elsif ( defined $params{messages_warning}
            and $params{messages_warning} <= $messages )
        {
            $res{status} = 'WARNING';
            $res{info} = sprintf(
                "Messages out of range! Expected max: %d have: %d",
                $params{messages_warning},
                $messages,
            );
        }
    }

    return \%res;
}

1;

__END__