File Coverage

blib/lib/Plack/Middleware/AccessLog/Structured.pm

Criterion	Covered	Total	%
statement	61	62	98.3
branch	12	12	100.0
condition	9	14	64.2
subroutine	15	15	100.0
pod	2	2	100.0
total	99	105	94.2

package Plack::Middleware::AccessLog::Structured;
{
  $Plack::Middleware::AccessLog::Structured::VERSION = '0.001000';
}
use parent qw(Plack::Middleware);

# ABSTRACT: Access log middleware which creates structured log messages

use strict;
use warnings;

use Carp;
use MRO::Compat;
use Time::HiRes;
use Plack::Util::Accessor qw(logger callback extra_field);
use Net::Domain qw(hostname hostfqdn);
use DateTime;
use Time::HiRes;
use JSON;


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

	my $self = $class->next::method($arg_ref);
	if (defined $self->callback() && ref $self->callback() ne 'CODE') {
		croak("Passed 'callback' parameter must be a code reference");
	}
	if (defined $self->extra_field() && ref $self->extra_field() ne 'HASH') {
		croak("Passed 'extra_field' parameter must be a hash reference");
	}

	return $self;
}



sub call {
	my ($self, $env) = @_;

	my $t_before = Time::HiRes::time();
	my $res = $self->app->($env);
	my $t_after = Time::HiRes::time();

	return $self->response_cb($res, sub {
		my ($cb_res) = @_;

		my $h = Plack::Util::headers($res->[1]);
		my $content_type = $h->get('Content-Type');
		my $log_entry = {
			class            => ref($self),
			# Request data
			remote_addr      => $env->{REMOTE_ADDR},
			request_method   => _safe($env->{REQUEST_METHOD}),
			request_uri      => _safe($env->{REQUEST_URI}),
			server_protocol  => $env->{SERVER_PROTOCOL},
			http_user_agent  => _safe($env->{HTTP_USER_AGENT}),
			http_host        => $env->{HTTP_HOST} || $env->{SERVER_NAME},
			http_referer     => $env->{HTTP_REFERER},
			remote_user      => $env->{REMOTE_USER},
			# Server information
			pid              => $$,
			hostfqdn         => hostfqdn(),
			hostname         => hostname(),
			# Response data
			response_status  => $cb_res->[0],
			content_length   => Plack::Util::content_length($res->[2]) || $h->get('Content-Length'),
			content_type     => defined $content_type ? "$content_type" : undef,
			# Timing
			request_duration => ( $t_after - $t_before ) * 1000,
			date             => DateTime->from_epoch(epoch => $t_before)->strftime('%Y-%m-%dT%H:%M:%S.%3NZ'),
			epochtime        => $t_before,
		};

		if ($self->extra_field()) {
			for my $env_field (keys %{$self->extra_field}) {
				$log_entry->{$self->extra_field()->{$env_field}}
					= $env->{$env_field};
			}
		}

		if ($self->callback()) {
			$log_entry = $self->callback()->($env, $log_entry);
		}

		my $logger = $self->logger() || sub { $env->{'psgi.errors'}->print($_[0] . "\n") };
		$logger->(encode_json($log_entry));

		return;
	});
}


# Taken from Plack::Middleware::AccessLog
sub _safe {
	my ($string) = @_;
	$string =~ s/([^[:print:]])/"\\x" . unpack("H*", $1)/xeg
		if defined $string;
	return $string;
}



1;

__END__