File Coverage

blib/lib/Mojolicious/Plugin/Log/Elasticsearch.pm

Criterion	Covered	Total	%
statement	43	58	74.1
branch	11	22	50.0
condition	5	14	35.7
subroutine	6	6	100.0
pod	1	1	100.0
total	66	101	65.3

package Mojolicious::Plugin::Log::Elasticsearch;
$Mojolicious::Plugin::Log::Elasticsearch::VERSION = '1.162530';
# ABSTRACT: Mojolicious Plugin to log requests to an Elasticsearch instance

use Mojo::Base 'Mojolicious::Plugin';

use Time::HiRes qw/time/;
use Mojo::JSON  qw/encode_json/;

sub register {
  my ($self, $app, $conf) = @_;

  my $index = $conf->{index} || die "no elasticsearch index provided";
  my $type  = $conf->{type}  || die "no elasticsearch type provided";
  my $ts_name = $conf->{timestamp_field};
  my $es_url = $conf->{elasticsearch_url} || die "no elasticsearch url provided";
  my $log_stash_keys = $conf->{log_stash_keys} || [];
  my $extra_keys_sub = $conf->{extra_keys_hook};

  my $geoip;
  if ($conf->{geo_ip_citydb}) {
    require Geo::IP;
    $geoip = Geo::IP->open($conf->{geo_ip_citydb});
  }

  # We should be smarter and only create this index if it isn't already
  # in existence. There's no harm here, it's just poor form.
  my $tx_c = $app->ua->put("${es_url}/${index}");

  my $index_meta = {
    $type => {
      # let ES generate timestamps if they haven't specified a ts field name
      ! $ts_name ? ("_timestamp" => { enabled => 1, store => 1 }) : (),
      "properties" => {
        'ip'        => { 'type' => 'ip', 'store' => 1 },
        'path'      => { 'type' => 'string',  index => 'not_analyzed' },
        'location'  => { 'type' => 'geo_point' },
      }
    }
  };

  my $url = "${es_url}/${index}/${type}/_mapping";
  my $tx = $app->ua->post($url, json => $index_meta);

  $app->hook(before_dispatch => sub {
    my $c = shift;
    $c->stash->{'mojolicious-plugin-log-elasticsearch.start'} = time();
  });

  $app->hook(after_dispatch => sub {
    my $c = shift;
    my @n = gmtime();
    my $t = sprintf("%04d-%02d-%02dT%02d:%02d:%02dZ", $n[5]+1900, $n[4]+1, $n[3],
                                                      @n[2,1,0]);
    my $dur = time() - $c->stash->{'mojolicious-plugin-log-elasticsearch.start'};

    # perhaps look up Geo::IP stuff
    my %geo_ip_data;
    my ($lat, $long, $country_code);
    eval {
      return 1 if (! $geoip);
      return 1 if (! $c->tx->remote_address);

      my $rec = $geoip->record_by_addr($c->tx->remote_address);
      return 1 if (! $rec);

      $lat          = $rec->latitude;
      $long         = $rec->longitude;
      $country_code = $rec->country_code;

      %geo_ip_data = ( location => "$lat, $long", country_code => $country_code );

      1;
    } or do {
      $c->app->log->warn("could not lookup lat/long for ip: $@");
    };

    my $data = { ip     => $c->tx->remote_address,
                 path   => $c->req->url->to_abs->path,
                 code   => $c->res->code,
                 method => $c->req->method,
                 time   => $dur,
                 $ts_name ? ( $ts_name => int(time() * 1000) ) : (),
                 %geo_ip_data,
    };
    foreach (@{ $log_stash_keys}) {
      $data->{$_} = $c->stash->{$_} if (exists $c->stash->{$_});
    }

    if ($extra_keys_sub) {
      my %new_values = $extra_keys_sub->($c);
      $data = { %$data, %new_values };
    }

    my $url = "${es_url}/${index}/${type}/?timestamp=${t}";
    $c->app->ua->post($url, json => $data, sub {
      my ($ua, $tx) = @_;
      if (! $tx) {
        $c->app->log->warn("could not log to elasticsearch");
      }
      elsif ($tx->res && $tx->res->code && $tx->res->code !~ /^20./) {
        $c->app->log->warn("could not log to elasticsearch - " . $tx->res->body);
      }
    });
  });
}

1;

__END__