File Coverage

blib/lib/Mojolicious/Plugin/Prometheus.pm

Criterion	Covered	Total	%
statement	112	115	97.3
branch	19	24	79.1
condition	16	21	76.1
subroutine	28	29	96.5
pod	1	1	100.0
total	176	190	92.6

package Mojolicious::Plugin::Prometheus;
use Mojo::Base 'Mojolicious::Plugin', -signatures;
use Mojolicious::Plugin::Prometheus::Collector::Perl;
use IPC::ShareLite;
use Net::Prometheus;
use Time::HiRes qw/gettimeofday tv_interval/;
use Mojo::Collection;
use Mojolicious::Plugin::Prometheus::Guard;
use Prometheus::MetricRenderer;

our $VERSION = '1.5.1';

has prometheus => \&_prometheus;
has guard   => \&_guard;
has share   => \&_share;
has route   => sub { undef };
has shm_key => sub { $$ };

has global_collectors => sub { Mojo::Collection->new };

# Attributes to hold the different metrics that are registered
has http_request_duration_seconds => sub { undef };
has http_request_size_bytes       => sub { undef };
has http_response_size_bytes      => sub { undef };
has http_requests_total           => sub { undef };

# Configuration for the default metric types
has config => sub {
  {
    http_request_duration_seconds => {
      buckets => [.005, .01, .025, .05, .075, .1, .25, .5, .75, 1.0, 2.5, 5.0, 7.5, 10],
      labels  => [qw/worker method/],
      cb      => sub($c) { $$, $c->req->method, tv_interval($c->stash('prometheus.start_time')) },
    },
    http_request_size_bytes => {
      buckets => [1, 50, 100, 1_000, 10_000, 50_000, 100_000, 500_000, 1_000_000],
      labels  => [qw/worker method/],
      cb      => sub($c) { $$, $c->req->method, $c->req->content->body_size },
    },
    http_response_size_bytes => {
      buckets => [5, 50, 100, 1_000, 10_000, 50_000, 100_000, 500_000, 1_000_000],
      labels  => [qw/worker method code/],
      cb      => sub($c) { $$, $c->req->method, $c->res->code, $c->res->content->body_size },
    },
    http_requests_total => {
      labels  => [qw/worker method code/],
      cb      => sub($c) { $$, $c->req->method, $c->res->code },
    },
    perl_collector => {
      enabled   => 1,
      labels_cb => sub { { worker => $$ } },
    },
    process_collector => {
      enabled   => 1,
      labels_cb => sub { { worker => $$ } },
    },
  }
};

sub register($self, $app, $config = {}) {
  $self->shm_key($config->{shm_key}) if $config->{shm_key};

  for(keys $self->config->%*) {
    next unless $config->{$_};
    $self->config->{$_} = { $self->config->{$_}->%*, $config->{$_}->%* };
  }

  # Present _only_ for a short while for backward compat
  $self->config->{http_request_duration_seconds}{buckets} = $config->{duration_buckets} if $config->{duration_buckets};
  $self->config->{http_request_size_bytes}{buckets}       = $config->{request_buckets}  if $config->{request_buckets};
  $self->config->{http_response_size_bytes}{buckets}      = $config->{response_buckets} if $config->{response_buckets};

  # Net::Prometheus instance can be overridden in its entirety
  $self->prometheus($config->{prometheus}) if $config->{prometheus};

  # Only the two built-in servers are supported for now
  $app->hook(before_server_start => sub { $self->_start(@_, $config) });

  $self->http_request_duration_seconds(
    $self->prometheus->new_histogram(
      namespace => $config->{namespace}        // undef,
      subsystem => $config->{subsystem}        // undef,
      name      => "http_request_duration_seconds",
      help      => "Histogram with request processing time",
      labels    => $self->config->{http_request_duration_seconds}{labels},
      buckets   => $self->config->{http_request_duration_seconds}{buckets},
    )
  );

  $self->http_request_size_bytes(
    $self->prometheus->new_histogram(
      namespace => $config->{namespace} // undef,
      subsystem => $config->{subsystem} // undef,
      name      => "http_request_size_bytes",
      help      => "Histogram containing request sizes",
      labels    => $self->config->{http_request_size_bytes}{labels},
      buckets   => $self->config->{http_request_size_bytes}{buckets},
    )
  );

  $self->http_response_size_bytes(
    $self->prometheus->new_histogram(
      namespace => $config->{namespace} // undef,
      subsystem => $config->{subsystem} // undef,
      name      => "http_response_size_bytes",
      help      => "Histogram containing response sizes",
      labels    => $self->config->{http_response_size_bytes}{labels},
      buckets   => $self->config->{http_response_size_bytes}{buckets},
    )
  );

  $self->http_requests_total(
    $self->prometheus->new_counter(
      namespace => $config->{namespace} // undef,
      subsystem => $config->{subsystem} // undef,
      name      => "http_requests_total",
      help      => "How many HTTP requests processed, partitioned by status code and HTTP method.",
      labels    => $self->config->{http_requests_total}{labels},
    )
  );

  $app->hook(
    before_dispatch => sub {
      my ($c) = @_;
      $c->stash('prometheus.start_time' => [gettimeofday]);
      $self->http_request_size_bytes->observe($self->config->{http_request_size_bytes}{cb}->($c));
    }
  );

  $app->hook(
    after_render => sub {
      my ($c) = @_;
      $self->http_request_duration_seconds->observe($self->config->{http_request_duration_seconds}{cb}->($c));
    }
  );

  $app->hook(
    after_dispatch => sub {
      my ($c) = @_;
      $self->http_requests_total->inc($self->config->{http_requests_total}{cb}->($c));
      $self->http_response_size_bytes->observe($self->config->{http_response_size_bytes}{cb}->($c));
    }
  );

  # Create common helper methods
  $app->helper('prometheus.instance' => sub { $self->prometheus });
  $app->helper('prometheus.register' => \&_register);

	# Plugin-internal helper methods
  $app->helper('prometheus.collect' => \&_collect);
  $app->helper('prometheus.guard'   => sub { $self->guard });
  $app->helper('prometheus.global_collectors' => sub { $self->global_collectors });

  # Create the endpoint that should serve metrics
  my $prefix = $config->{route} // $app->routes->under('/');
  $self->route($prefix->get($config->{path} // '/metrics'));
  $self->route->to(cb => \&_metrics);
}

sub _metrics($c) {
  $c->render(text => $c->prometheus->collect, format => 'txt');
}

sub _register($c, $collector, $scope = 'worker') {
  return $c->prometheus->instance->register($collector) if $scope eq 'worker';
  return push $c->prometheus->global_collectors->@*, $collector;
}

sub _collect($c) {
  # Update stats for current worker
  $c->prometheus->guard->_change(sub { $_->{$$} = $c->prometheus->instance->render });

  # Fetch stats for all worker-specific collectors
  my $worker_stats = Mojo::Collection->new(keys %{$c->prometheus->guard->_fetch})
    ->sort
    ->map(sub { ($c->prometheus->guard->_fetch->{$_}) })
    ->join("\n");

  # Fetch stats for global / on-demand collectors
  my $renderer = Prometheus::MetricRenderer->new;
  my $global_stats = $c->prometheus->global_collectors
    ->map(sub { [ $_->collect({}) ] })
    ->map(sub { $renderer->render($_) })
    ->join("\n");

  return $worker_stats."\n".$global_stats."\n";
}

sub _share($self) {
  IPC::ShareLite->new(-key => $self->shm_key, -create => 1, -destroy => 0) || die $!;
}

sub _guard($self) {
  Mojolicious::Plugin::Prometheus::Guard->new(share => $self->share);
}

sub _start {
  my ($self, $server, $app, $config) = @_;
  return unless $server->isa('Mojo::Server::Daemon');

  Mojo::IOLoop->next_tick(
    sub {
      my $labels    = $self->config->{process_collector}{labels_cb}->();
      my $collector = Net::Prometheus::ProcessCollector->new(labels => [%$labels]);
      $app->prometheus->register($collector);
    }
  ) if $self->config->{process_collector}{enabled};

  # Remove stopped workers
  $server->on(
    reap => sub {
      my ($server, $pid) = @_;
      $self->guard->_change(sub { delete $_->{$pid} });
    }
  ) if $server->isa('Mojo::Server::Prefork');
}

sub _prometheus($self) {
  my $prometheus = Net::Prometheus->new(disable_process_collector => 1, disable_perl_collector => 1);

  # Adding the Perl-collector, if enabled
  if($self->config->{perl_collector}{enabled}) {
    my $perl_collector = Mojolicious::Plugin::Prometheus::Collector::Perl->new($self->config->{perl_collector});
    $prometheus->register($perl_collector);
  }
  return $prometheus;
};

1;

__END__