class ElasticAPM::Transport::Connection

def build_headers
  (
    @config.http_compression? ? GZIP_HEADERS : HEADERS
  ).dup.tap do |headers|
    if (token = @config.secret_token)
      headers['Authorization'] = "Bearer #{token}"
    end
  end
end

def build_ssl_context
  return unless @config.use_ssl? && @config.server_ca_cert
  OpenSSL::SSL::SSLContext.new.tap do |context|
    context.ca_file = @config.server_ca_cert
  end
end

def connect
  schedule_closing if @config.api_request_time
  @http =
    Http.open(
      @config, @url,
      headers: @headers,
      ssl_context: @ssl_context
    ).tap { |http| http.write(@metadata) }
end

def flush(reason = :force)
  # Could happen from the timertask so we need to sync
  @mutex.synchronize do
    return if http.nil?
    http.close(reason)
  end
end

def initialize(config, metadata)
  @config = config
  @metadata = JSON.fast_generate(metadata)
  @url = config.server_url + '/intake/v2/events'
  @headers = build_headers
  @ssl_context = build_ssl_context
  @mutex = Mutex.new
end

def inspect
  format(
    '@%s http connection closed? :%s>',
    super.split.first,
    http.closed?
  )
end

def schedule_closing
  @close_task&.cancel
  @close_task =
    Concurrent::ScheduledTask.execute(@config.api_request_time) do
      flush(:timeout)
    end
end

def write(str)
  return false if @config.disable_send
  begin
    bytes_written = 0
    # The request might get closed from timertask so let's make sure we
    # hold it open until we've written.
    @mutex.synchronize do
      connect if http.nil? || http.closed?
      bytes_written = http.write(str)
    end
    flush(:api_request_size) if bytes_written >= @config.api_request_size
  rescue IOError => e
    error('Connection error: %s', e.inspect)
    flush(:ioerror)
  rescue Errno::EPIPE => e
    error('Connection error: %s', e.inspect)
    flush(:broken_pipe)
  rescue Exception => e
    error('Connection error: %s', e.inspect)
    flush(:connection_error)
  end
end