module Polyseerio

Default agent configuration.

Introduces a logger into the main module.

Main Polyseerio module.

Constants

CLIENT_RESOURCE_PATHS: Maps resources to paths within a Client
DEFAULT_CLIENT_OPTIONS: Default client options.
REQUIRED_RESOURCES: Required resources for constructing a client.

Attributes

logger[W]

Public Class Methods

level_to_severity(level) click to toggle source

Convert a string log level to a severity.

# File lib/log.rb, line 9
def level_to_severity(level) # rubocop:disable all
  case level
  when 'debug'
    Logger::DEBUG
  when 'error'
    Logger::ERROR
  when 'fatal'
    Logger::FATAL
  when 'info'
    Logger::INFO
  when 'unknown'
    Logger::UNKNOWN
  when 'warn'
    Logger::WARN
  else
    raise ArgumentError, "Unsupported log level: #{level}."
  end
end

log(severity, *args) click to toggle source

Convenience logging method.

# File lib/log.rb, line 42
def log(severity, *args)
  severity = if severity.is_a? String
               level_to_severity severity
             else
               severity
             end

  logger.log(severity, *args)
end

logger() click to toggle source

Gem logger.

# File lib/log.rb, line 29
def logger
  @logger ||= Logger.new($stdout).tap do |log|
    log.level = if ENV.key? 'POLYSEERIO_LOG_LEVEL'
                  level_to_severity ENV['POLYSEERIO_LOG_LEVEL']
                else
                  Logger::ERROR
                end

    log.progname = name
  end
end

make(options = {}) click to toggle source

Create a client.

# File lib/polyseerio.rb, line 67
def self.make(options = {})
  options = Helper.defaults(options, DEFAULT_CLIENT_OPTIONS)

  cid = @make_call_count

  token = Helper.resolve_token options

  base_url = URL.get_base_url(
    Constant::DEFAULT_API_BASE_URL,
    Constant::DEFAULT_API_PROTOCOL,
    options[:version]
  )

  if token.nil?
    raise ArgumentError, 'Could not find an access token. None was passed' \
      'and non could be found in the environment variable: ' \
      "#{options[:token_env]}."
  end

  headers = {
    Constant::ACCESS_TOKEN_HEADER => token,
    :content_type => 'application/json'
  }

  rest_resource = RestClient::Resource.new(
    base_url,
    headers: headers,
    timeout: Helper.ms_to_seconds(options[:timeout])
  )

  # Create a request instance that uses middleware.
  request = Request.new(
    rest_resource,
    pre: [Middleware::Pre.format_arguments],
    post: [Middleware::Post.to_response, Middleware::Post.parse_response]
  )

  resources = REQUIRED_RESOURCES.each_with_object({}) do |resource, acc|
    acc[resource] = Resource::Factory.make(resource, request, cid, options)

    acc
  end

  resources = Helper.rekey(resources, CLIENT_RESOURCE_PATHS)

  client = Client.new(cid, request: request, resources: resources)

  @make_call_count += 1

  client
end

start(options = {}) click to toggle source

Create a client and start it's agent.

# File lib/polyseerio.rb, line 56
def self.start(options = {})
  options = Helper.defaults(options, DEFAULT_CLIENT_OPTIONS)

  client = make(options)

  client.start_agent(options[:agent])
end