require 'stackify/version'

require 'stackify/utils/methods'

require 'core_ext/core_ext' unless defined? Rails

module Stackify

INTERNAL_LOG_PREFIX = '[Stackify]'.freeze

STATUSES = { working: 'working', terminating: 'terminating', terminated: 'terminated'}

MODES = { logging: :logging, metrics: :metrics, both: :both }

TRANSPORT = [DEFAULT = 'default', UNIX_SOCKET = 'agent_socket', AGENT_HTTP = 'agent_http']

autoload :Backtrace, 'stackify/utils/backtrace'

autoload :MsgObject, 'stackify/utils/msg_object'

autoload :Configuration, 'stackify/utils/configuration'

autoload :HttpClient, 'stackify/http_client'

autoload :Authorizable, 'stackify/authorization/authorizable'

autoload :EnvDetails, 'stackify/env_details'

autoload :Scheduler, 'stackify/scheduler'

autoload :ScheduleTask, 'stackify/schedule_task'

autoload :ScheduleDelay, 'stackify/schedule_delay'

autoload :Worker, 'stackify/workers/worker'

autoload :AuthWorker, 'stackify/workers/auth_worker'

autoload :LogsSenderWorker, 'stackify/workers/logs_sender_worker'

autoload :MsgsQueueWorker, 'stackify/workers/msgs_queue_worker'

autoload :AddMsgWorker, 'stackify/workers/add_msg_worker'

autoload :MsgsQueue, 'stackify/msgs_queue'

autoload :LoggerClient, 'stackify/logger_client'

autoload :AgentClient, 'stackify/agent_client'

autoload :TransportSelector, 'stackify/transport_selector'

autoload :LogsSender, 'stackify/logs_sender'

autoload :AgentBaseSender, 'stackify/agent_base_sender'

autoload :UnixSocketSender, 'stackify/unix_socket_sender'

autoload :AgentHTTPSender, 'stackify/agent_http_sender'

autoload :LoggerProxy, 'stackify/logger_proxy'

autoload :StackifiedError, 'stackify/error'

autoload :StringException, 'stackify/error'

autoload :ErrorsGovernor, 'stackify/errors_governor'

autoload :Metrics, 'stackify/metrics/metrics'

autoload :Rum, 'stackify/rum'

include Authorizable

class << self

attr_writer :config

def configuration

@config ||= Stackify::Configuration.new

end

def rum

@rum ||= Stackify::Rum.new(configuration)

end

def setup

@workers = []

yield(configuration) if block_given?

configuration.validate_transport_type

if configuration.is_valid?

@status = STATUSES[:working]

else

msg = "Stackify's configuration is not valid!"

configuration.errors.each do |error_msg|

msg += "\n" + error_msg

end

raise msg

end

end

def msgs_queue

@msgs_queue ||= Stackify::MsgsQueue.new

end

def logger_client

@logger_client ||= Stackify::LoggerClient.new

end

def agent_client

@agent_client ||= Stackify::AgentClient.new

end

def get_transport

@logger_client.get_transport

end

def send_unix_socket

@unix_socket ||= Stackify::UnixSocketSender.new

end

def logger

self.configuration.logger

end

def shutdown_all caller_obj=nil

Stackify.status = Stackify::STATUSES[:terminating]

@workers.each do |worker|

worker.shutdown! unless worker.equal? caller_obj

end

end

def alive_adding_msg_workers

@workers.select{ |w| w.alive? && w.type == :add_msg }

end

def delete_worker worker

@workers.delete worker

end

def add_dependant_worker worker

@workers << worker

end

def status

@status

end

def log_internal_error msg

Stackify.logger.error (::Stackify::INTERNAL_LOG_PREFIX){ msg }

end

def internal_log level, msg

Stackify.logger.send(level.downcase.to_sym, Stackify::INTERNAL_LOG_PREFIX){ msg }

end

def run

Stackify::Utils.is_api_enabled

Stackify.internal_log :info, "Stackify.run() transportType: #{Stackify.configuration.transport} | API version: #{Stackify::VERSION} | Ruby version: #{RUBY_VERSION}"

if Stackify.configuration.api_enabled

if Stackify.is_valid?

# check transport types

case Stackify.configuration.transport

when Stackify::DEFAULT

if Stackify.is_valid?

at_exit { make_remained_job }

t1 = Thread.new { Stackify.authorize }

case Stackify.configuration.mode

when MODES[:both]

t2 = start_logging

t3 = start_metrics

when MODES[:logging]

t2 = start_logging

when MODES[:metrics]

t3 = start_metrics

end

t1.join

t3.join if t3

else

Stackify.log_internal_error "Stackify is not properly configured! Errors: #{Stackify.configuration.errors}"

end

when Stackify::UNIX_SOCKET, Stackify::AGENT_HTTP

case Stackify.configuration.mode

when MODES[:logging]

start_logging

when MODES[:both]

start_logging

start_metrics

when MODES[:metrics]

start_metrics

end

else

Stackify.log_internal_error "Stackify is not properly configured! Errors: #{Stackify.configuration.errors}"

end

end

end

end

def start_logging

msgs_queue

end

def start_metrics

Thread.new { Stackify::Metrics.metrics_client.start }

end

def workers

@workers

end

def make_remained_job

@status = STATUSES[:terminating]

Stackify.msgs_queue.push_remained_msgs

end

def is_valid?

configuration.is_valid?

end

def terminating?

@status == STATUSES[:terminating]

end

def terminated?

@status == STATUSES[:terminated]

end

def working?

@status == STATUSES[:working]

end

def status= status

if STATUSES.has_value? status

@status = status

else

raise "method 'status=' should get one of arguments #{STATUSES.values}, not a #{status}"

end

end

end

end

require 'stackify/engine' if defined? Rails