module Core

# # Log Formatters

#

# Log formatters receive a {AWS::Core::Response} object and return

# a log message. When you construct a {LogFormatter}, you provide

# a pattern string with substitutions.

#

# pattern = '[AWS :http_response_status] :service :operation :duration'

# formatter = AWS::Core::LogFormatter.new(pattern)

# formatter.format(response)

# #=> '[AWS 200] EC2 get_bucket 0.0352'

#

# # AWS Configuration

#

# AWS.config provides a {LogFormatter.default} log formatter. You can

# repace this formatter by building your own and then passing it

# to {AWS.config}.

#

# pattern = '[AWS :http_response_status] :service :operation :duration'

# AWS.config(:log_formatter => AWS::Core::LogFormatter.new(pattern)

#

# ## Canned Formatters

#

# Instead of providing your own pattern, you can choose a canned log

# formatter.

#

# AWS.config(:log_formatter => AWS::Core::LogFormatter.colored)

#

# Here is the list of canned formatters.

#

# * {LogFormatter.default}

# * {LogFormatter.short}

# * {LogFormatter.debug}

# * {LogFormatter.colored}

#

# # Pattern Substitutions

#

# You can put any of these placeholders into you pattern.

#

# * `:service` - The AWS service name (e.g. 'S3', 'EC2', 'SimpleDB', etc)

# * `:region` - The AWS region name (e.g. 'us-west-1', 'us-west-2', etc)

# * `:operation` - The name of the client request method. This maps to

# the name of the serivce API operation (e.g. :describe_instances).

# * `:options` - The hash of options passed to the client request method.

# Long strings are truncated/summarized if they excede the log

# formatters {#max_string_size}. Other objects are inspected.

# * `:retry_count` - The number of times a client request was retried.

# Throttlings and service errors trigger the automatic retry logic.

# This value indicates how many extra attempts were made before

# getting a successful response or giving up.

# * `:duration` - The time it took to generate a response, expressed

# in decimal seconds. This time includes everything from

# calling the client request method, until that method returns

# a value (event retries and retry delays).

# * `:error_class` - The class name of the error returned by the

# service. If no error was returned, this will be replcaed by

# an empty string.

# * `:error_message` - The message of the error returned. If

# no error was returned by the service, this will be an empty

# string.

# * `:http_request_method` - The HTTP request verb (e.g. 'POST',

# 'PUT', 'GET', etc).

# * `:http_request_protocol` - This is replaced by 'http' or 'https'.

# * `:http_request_host` - The host name of the http request

# endpoint (e.g. 's3.amazon.com').

# * `:http_request_port` - The port number (e.g. '443' or '80').

# * `:http_request_uri` - The http request uri folling the host (e.g.

# '/bucket_name/objects/key?versions').

# * `:http_request_body` - The http request payload.

# * `:http_request_headers` - The http request headers, inspected.

# * `:http_request_proxy_uri` - The proxy uri used, or an empty string.

# * `:http_response_status` - The http response status

# code (e.g. '200', '404', '500', etc).

# * `:http_response_headers` - The http response headers, inspected.

# * `:http_response_body` - The http response body contents.

#

class LogFormatter

# @param [String] pattern The log format pattern should be a string

# and may contain any of the following placeholders:

#

# * `:service`

# * `:region`

# * `:operation`

# * `:options`

# * `:retry_count`

# * `:duration`

# * `:error_class`

# * `:error_message`

# * `:http_request_method`

# * `:http_request_protocol`

# * `:http_request_host`

# * `:http_request_port`

# * `:http_request_uri`

# * `:http_request_body`

# * `:http_request_headers`

# * `:http_request_proxy_uri`

# * `:http_response_status`

# * `:http_response_headers`

# * `:http_response_body`

#

# @param [Hash] options

#

# @option options [Integer] :max_string_size (1000)

#

def initialize pattern, options = {}

@pattern = pattern

@max_string_size = options[:max_string_size] || 1000

end

# @return [String]

attr_reader :pattern

# @return [Integer]

attr_reader :max_string_size

# @param [Response] response

# @return [String]

def format response

pattern.gsub(/:(\w+)/) {|sym| send("_#{sym[1..-1]}", response) }

end

# @api private

def eql? other

other.is_a?(self.class) and other.pattern == self.pattern

end

alias_method :==, :eql?

protected

def method_missing method_name, *args

if method_name.to_s.chars.first == '_'

":#{method_name.to_s[1..-1]}"

else

super

end

end

def _service response

response.http_request.service

end

def _region response

response.http_request.region

end

def _operation response

response.request_type

end

def _options response

summarize_hash(response.request_options) if response.request_options

end

def _retry_count response

response.retry_count

end

def _duration response

("%.06f" % response.duration).sub(/0+$/, '')

end

def _error_class response

response.error.class.name if response.error

end

def _error_message response

response.error.message if response.error

end

def _http_request_method response

response.http_request.http_method

end

def _http_request_protocol response

response.http_request.use_ssl? ? 'https' : 'http'

end

def _http_request_host response

response.http_request.host

end

def _http_request_port response

response.http_request.port

end

def _http_request_uri response

response.http_request.uri

end

def _http_request_headers response

response.http_request.headers.inspect

end

def _http_request_body response

response.http_request.body

end

def _http_request_proxy_uri response

response.config.proxy_uri

end

def _http_response_status response

response.http_response.status

end

def _http_response_headers response

response.http_response.headers.inspect

end

def _http_response_body response

response.http_response.body

end

# The following methods are for summarizing request options that have

# symbolized keys and a mix of values. The summarizing is important

# because large request options (e.g. s3 data) can cause memory usage

# to spike if it is inspected.

# @param [Hash] hash

# @return [String]

def summarize_hash hash

hash.map do |key,v|

"#{key.inspect}=>#{summarize_value(v)}"

end.sort.join(",")

end

# @param [Object] value

# @return [String]

def summarize_value value

case value

when String then summarize_string(value)

when Hash then '{' + summarize_hash(value) + '}'

when Array then summarize_array(value)

when File then summarize_file(value.path)

when Pathname then summarize_file(value)

else value.inspect

end

end

# @param [String] str

# @return [String]

def summarize_string str

max = max_string_size

if str.size > max

"#<String #{str[0...max].inspect} ... (#{str.size} bytes)>"

else

str.inspect

end

end

# Given the path to a file on disk, this method returns a summarized

# inspecton string that includes the file size.

# @param [String] path

# @return [String]

def summarize_file path

"#<File:#{path} (#{File.size(path)} bytes)>"

end

# @param [Array] array

# @return [String]

def summarize_array array

"[" + array.map{|v| summarize_value(v) }.join(",") + "]"

end

class << self

# The default log format.

#

# @example A sample of the default format.

#

# [AWS SimpleEmailService 200 0.580066 0 retries] list_verified_email_addresses()

#

# @return [LogFormatter]

#

def default

pattern = []

pattern << "[AWS"

pattern << ":service"

pattern << ":http_response_status"

pattern << ":duration"

pattern << ":retry_count retries]"

pattern << ":operation(:options)"

pattern << ":error_class"

pattern << ":error_message"

LogFormatter.new(pattern.join(' ') + "\n")

end

# The short log format. Similar to default, but it does not

# inspect the request params or report on retries.

#

# @example A sample of the short format

#

# [AWS SimpleEmailService 200 0.494532] list_verified_email_addresses

#

# @return [LogFormatter]

#

def short

pattern = []

pattern << "[AWS"

pattern << ":service"

pattern << ":http_response_status"

pattern << ":duration]"

pattern << ":operation"

pattern << ":error_class"

LogFormatter.new(pattern.join(' ') + "\n")

end

# A debug format that dumps most of the http request and response

# data.

#

# @example A truncated sample of the debug format.

#

# +-------------------------------------------------------------------------------

# | AWS us-east-1 SimpleEmailService list_verified_email_addresses 0.429189 0 retries

# +-------------------------------------------------------------------------------

# | REQUEST

# +-------------------------------------------------------------------------------

# | METHOD: POST

# | URL: https://email.us-east-1.amazonaws.com::443:/

# | HEADERS: {"content-type"=>"application/x-www-form-urlencoded" ...

# | BODY: Action=ListVerifiedEmailAddresses&Timestamp= ...

# +-------------------------------------------------------------------------------

# | RESPONSE

# +-------------------------------------------------------------------------------

# | STATUS: 200

# | HEADERS: {"x-amzn-requestid"=>["..."], ...

# | BODY: <ListVerifiedEmailAddressesResponse ...

#

# @return [LogFormatter]

#

def debug

sig_pattern = []

sig_pattern << ':region'

sig_pattern << ':service'

sig_pattern << ':operation'

sig_pattern << ':duration'

sig_pattern << ':retry_count retries'

uri_pattern = []

uri_pattern << ':http_request_protocol'

uri_pattern << '://'

uri_pattern << ':http_request_host'

uri_pattern << '::'

uri_pattern << ':http_request_port'

uri_pattern << ':'

uri_pattern << ':http_request_uri'

line = "+" + '-' * 79

pattern = []

pattern << line

pattern << "| AWS #{sig_pattern.join(' ')}"

pattern << line

pattern << "| REQUEST"

pattern << line

pattern << "| METHOD: :http_request_method"

pattern << "| URL: #{uri_pattern.join}"

pattern << "| HEADERS: :http_request_headers"

pattern << "| BODY: :http_request_body"

pattern << line

pattern << "| RESPONSE"

pattern << line

pattern << "| STATUS: :http_response_status"

pattern << "| HEADERS: :http_response_headers"

pattern << "| BODY: :http_response_body"

LogFormatter.new(pattern.join("\n") + "\n")

end

# The default log format with ANSI colors.

#

# @example A sample of the colored format (sans the ansi colors).

#

# [AWS SimpleEmailService 200 0.580066 0 retries] list_verified_email_addresses()

#

# @return [LogFormatter]

#

def colored

bold = "\x1b[1m"

color = "\x1b[34m"

reset = "\x1b[0m"

pattern = []

pattern << "#{bold}#{color}[AWS"

pattern << ":service"

pattern << ":http_response_status"

pattern << ":duration"

pattern << ":retry_count retries]#{reset}#{bold}"

pattern << ":operation(:options)"

pattern << ":error_class"

pattern << ":error_message#{reset}"

LogFormatter.new(pattern.join(' ') + "\n")

end

end

end

end