aspera-cli 4.9.0 → 4.11.0

data/lib/aspera/fasp/agent_base.rb

@@ -13,7 +13,7 @@ module Aspera
       BOOLEAN_FIELDS = %w[Encryption Remote RateLock MinRateLock PolicyLock FilesEncrypt FilesDecrypt VLinkLocalEnabled VLinkRemoteEnabled
                           MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
       EXPECTED_METHODS = %i[text struct enhanced].freeze
-      private_constant :INTEGER_FIELDS,:BOOLEAN_FIELDS,:EXPECTED_METHODS
+      private_constant :INTEGER_FIELDS, :BOOLEAN_FIELDS, :EXPECTED_METHODS
 
       class << self
         # This checks the validity of the value returned by wait_for_transfers_completion
@@ -28,13 +28,13 @@ module Aspera
 
       # translates legacy event into enhanced (JSON) event
       def enhanced_event_format(event)
-        return event.keys.each_with_object({}) do |e,h|
+        return event.keys.each_with_object({}) do |e, h|
           # capital_to_snake_case
-          new_name = e.
-              gsub(/([a-z\d])([A-Z])/,'\1_\2').
-              gsub(/([a-z\d])(usec)$/,'\1_\2').
-              gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-              downcase
+          new_name = e
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .gsub(/([a-z\d])(usec)$/, '\1_\2')
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .downcase
           value = event[e]
           value = value.to_i if INTEGER_FIELDS.include?(e)
           value = value.eql?('Yes') if BOOLEAN_FIELDS.include?(e)
@@ -46,7 +46,7 @@ module Aspera
         @listeners = []
       end
 
-      def notify_listeners(current_event_text,current_event_data)
+      def notify_listeners(current_event_text, current_event_data)
         Log.log.debug('send event to listeners')
         enhanced_event = nil
         @listeners.each do |listener|
@@ -59,16 +59,16 @@ module Aspera
         end
       end # notify_listeners
 
-      def notify_begin(id,size)
-        notify_listeners('emulated',{LISTENER_SESSION_ID_B => id,'Type' => 'NOTIFICATION','PreTransferBytes' => size})
+      def notify_begin(id, size)
+        notify_listeners('emulated', {LISTENER_SESSION_ID_B => id, 'Type' => 'NOTIFICATION', 'PreTransferBytes' => size})
       end
 
-      def notify_progress(id,size)
-        notify_listeners('emulated',{LISTENER_SESSION_ID_B => id,'Type' => 'STATS','Bytescont' => size})
+      def notify_progress(id, size)
+        notify_listeners('emulated', {LISTENER_SESSION_ID_B => id, 'Type' => 'STATS', 'Bytescont' => size})
       end
 
       def notify_end(id)
-        notify_listeners('emulated',{LISTENER_SESSION_ID_B => id,'Type' => 'DONE'})
+        notify_listeners('emulated', {LISTENER_SESSION_ID_B => id, 'Type' => 'DONE'})
       end
 
       public
@@ -78,13 +78,13 @@ module Aspera
 
       # listener receives events
       def add_listener(listener)
-        raise "expect one of #{EXPECTED_METHODS}" if EXPECTED_METHODS.inject(0){|m,e|m += listener.respond_to?("event_#{e}") ? 1 : 0;m}.eql?(0)
+        raise "expect one of #{EXPECTED_METHODS}" if EXPECTED_METHODS.inject(0){|m, e|m + (listener.respond_to?("event_#{e}") ? 1 : 0)}.eql?(0)
         @listeners.push(listener)
         self
       end
 
       # the following methods must be implemented by subclass:
-      # start_transfer(transfer_spec,options) : start and wait for completion
+      # start_transfer(transfer_spec) : start and wait for completion
       # wait_for_transfers_completion : wait for termination of all transfers, @return list of : :success or error message
       # optional: shutdown
     end

data/lib/aspera/fasp/agent_connect.rb

@@ -8,10 +8,10 @@ require 'tty-spinner'
 
 module Aspera
   module Fasp
-    class AgentConnect < AgentBase
-      MAX_CONNECT_START_RETRY = 3
-      SLEEP_SEC_BETWEEN_RETRY = 2
-      private_constant :MAX_CONNECT_START_RETRY,:SLEEP_SEC_BETWEEN_RETRY
+    class AgentConnect < Aspera::Fasp::AgentBase
+      MAX_CONNECT_START_RETRY = 4
+      SLEEP_SEC_BETWEEN_RETRY = 3
+      private_constant :MAX_CONNECT_START_RETRY, :SLEEP_SEC_BETWEEN_RETRY
       def initialize(_options)
         super()
         @connect_settings = {
@@ -21,28 +21,30 @@ module Aspera
         trynumber = 0
         begin
           connect_url = Installation.instance.connect_uri
-          Log.log.debug("found: #{connect_url}")
-          @connect_api = Rest.new({base_url: "#{connect_url}/v5/connect",headers: {'Origin' => Rest.user_agent}}) # could use v6 also now
+          Log.log.debug{"found: #{connect_url}"}
+          @connect_api = Rest.new({base_url: "#{connect_url}/v5/connect", headers: {'Origin' => Rest.user_agent}}) # could use v6 also now
           cinfo = @connect_api.read('info/version')[:data]
-          Log.dump(:connect_version,cinfo)
+          Log.log.info('Connect was reached') if trynumber > 0
+          Log.dump(:connect_version, cinfo)
         rescue StandardError => e # Errno::ECONNREFUSED
-          raise StandardError,"Unable to start connect after #{trynumber} try" if trynumber >= MAX_CONNECT_START_RETRY
-          Log.log.warn("connect is not started. Retry ##{trynumber}, err=#{e}")
+          raise StandardError, "Unable to start connect #{trynumber} times" if trynumber >= MAX_CONNECT_START_RETRY
+          Log.log.warn{"Aspera Connect is not started (#{e}). Trying to start it ##{trynumber}..."}
           trynumber += 1
-          if !OpenApplication.uri_graphical('fasp://initialize')
+          start_url = trynumber <= 2 ? 'fasp://initialize' : 'https://test-connect.ibmaspera.com/'
+          if !OpenApplication.uri_graphical(start_url)
             OpenApplication.uri_graphical('https://downloads.asperasoft.com/connect2/')
-            raise StandardError,'Connect is not installed'
+            raise StandardError, 'Connect is not installed'
           end
           sleep(SLEEP_SEC_BETWEEN_RETRY)
           retry
         end
       end
 
-      def start_transfer(transfer_spec,_options=nil)
+      def start_transfer(transfer_spec)
         if transfer_spec['direction'] == 'send'
-          Log.log.warn("Connect requires upload selection using GUI, ignoring #{transfer_spec['paths']}".red)
+          Log.log.warn{"Connect requires upload selection using GUI, ignoring #{transfer_spec['paths']}".red}
           transfer_spec.delete('paths')
-          resdata = @connect_api.create('windows/select-open-file-dialog/',{
+          resdata = @connect_api.create('windows/select-open-file-dialog/', {
             'aspera_connect_settings' => @connect_settings,
             'title'                   => 'Select Files',
             'suggestedName'           => '',
@@ -53,7 +55,7 @@ module Aspera
         @request_id = SecureRandom.uuid
         # if there is a token, we ask connect client to use well known ssh private keys
         # instead of asking password
-        transfer_spec['authentication'] = 'token' if transfer_spec.has_key?('token')
+        transfer_spec['authentication'] = 'token' if transfer_spec.key?('token')
         connect_transfer_args = {
           'aspera_connect_settings' => @connect_settings.merge({
             'request_id'    => @request_id,
@@ -63,7 +65,7 @@ module Aspera
             'transfer_spec' => transfer_spec
           }]}
         # asynchronous anyway
-        res = @connect_api.create('transfers/start',connect_transfer_args)[:data]
+        res = @connect_api.create('transfers/start', connect_transfer_args)[:data]
         @xfer_id = res['transfer_specs'].first['transfer_spec']['tags']['aspera']['xfer_id']
       end
 
@@ -73,7 +75,7 @@ module Aspera
         spinner = nil
         begin
           loop do
-            tr_info = @connect_api.create("transfers/info/#{@xfer_id}",connect_activity_args)[:data]
+            tr_info = @connect_api.create("transfers/info/#{@xfer_id}", connect_activity_args)[:data]
             if tr_info['transfer_info'].is_a?(Hash)
               trdata = tr_info['transfer_info']
               if trdata.nil?
@@ -85,7 +87,7 @@ module Aspera
               when 'completed'
                 notify_end(@connect_settings['app_id'])
                 break
-              when 'initiating','queued'
+              when 'initiating', 'queued'
                 if spinner.nil?
                   spinner = TTY::Spinner.new('[:spinner] :title', format: :classic)
                   spinner.start
@@ -93,13 +95,13 @@ module Aspera
                 spinner.update(title: trdata['status'])
                 spinner.spin
               when 'running'
-                #puts "running: sessions:#{trdata['sessions'].length}, #{trdata['sessions'].map{|i| i['bytes_transferred']}.join(',')}"
+                # puts "running: sessions:#{trdata['sessions'].length}, #{trdata['sessions'].map{|i| i['bytes_transferred']}.join(',')}"
                 if !started && (trdata['bytes_expected'] != 0)
                   spinner&.success
-                  notify_begin(@connect_settings['app_id'],trdata['bytes_expected'])
+                  notify_begin(@connect_settings['app_id'], trdata['bytes_expected'])
                   started = true
                 else
-                  notify_progress(@connect_settings['app_id'],trdata['bytes_written'])
+                  notify_progress(@connect_settings['app_id'], trdata['bytes_written'])
                 end
               when 'failed'
                 spinner&.error

data/lib/aspera/fasp/agent_direct.rb

@@ -16,12 +16,12 @@ require 'shellwords'
 module Aspera
   module Fasp
     # executes a local "ascp", connects mgt port, equivalent of "Fasp Manager"
-    class AgentDirect < AgentBase
+    class AgentDirect < Aspera::Fasp::AgentBase
       # options for initialize (same as values in option transfer_info)
       DEFAULT_OPTIONS = {
         spawn_timeout_sec: 3,
         spawn_delay_sec:   2,
-        wss:               false,
+        wss:               true, # true: if both SSH and wss in ts: prefer wss
         multi_incr_udp:    true,
         resume:            {},
         quiet:             true # by default no interactive progress bar
@@ -31,12 +31,8 @@ module Aspera
       # start ascp transfer (non blocking), single or multi-session
       # job information added to @jobs
       # @param transfer_spec [Hash] aspera transfer specification
-      # @param options [Hash] :resumer, :regenerate_token
-      def start_transfer(transfer_spec,options={})
-        raise 'option: must be hash (or nil)' unless options.is_a?(Hash)
-        job_options = options.clone
-        job_options[:resumer] ||= @resume_policy
-        job_options[:job_id] ||= SecureRandom.uuid
+      def start_transfer(transfer_spec)
+        the_job_id = SecureRandom.uuid
         # clone transfer spec because we modify it (first level keys)
         transfer_spec = transfer_spec.clone
         # if there is aspera tags
@@ -46,16 +42,16 @@ module Aspera
           # using a non unique id results in discard of tags in AoC, and a package is never finalized
           # all sessions in a multi-session transfer must have the same xfer_id (see admin manual)
           transfer_spec['tags']['aspera']['xfer_id'] ||= SecureRandom.uuid
-          Log.log.debug("xfer id=#{transfer_spec['xfer_id']}")
+          Log.log.debug{"xfer id=#{transfer_spec['xfer_id']}"}
           # TODO: useful ? node only ?
           transfer_spec['tags']['aspera']['xfer_retry'] ||= 3600
         end
-        Log.dump('ts',transfer_spec)
+        Log.dump('ts', transfer_spec)
 
         # add bypass keys when authentication is token and no auth is provided
-        if transfer_spec.has_key?('token') &&
-        !transfer_spec.has_key?('remote_password') &&
-        !transfer_spec.has_key?('EX_ssh_key_paths')
+        if transfer_spec.key?('token') &&
+            !transfer_spec.key?('remote_password') &&
+            !transfer_spec.key?('EX_ssh_key_paths')
           # transfer_spec['remote_password'] = Installation.instance.bypass_pass # not used
           transfer_spec['EX_ssh_key_paths'] = Installation.instance.bypass_keys
         end
@@ -63,21 +59,21 @@ module Aspera
         # Compute this before using transfer spec because it potentially modifies the transfer spec
         # (even if the var is not used in single session)
         multi_session_info = nil
-        if transfer_spec.has_key?('multi_session')
+        if transfer_spec.key?('multi_session')
           multi_session_info = {
             count: transfer_spec['multi_session'].to_i
           }
           # Managed by multi-session, so delete from transfer spec
           transfer_spec.delete('multi_session')
           if multi_session_info[:count].negative?
-            Log.log.error("multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0")
+            Log.log.error{"multi_session(#{transfer_spec['multi_session']}) shall be integer >= 0"}
             multi_session_info = nil
           elsif multi_session_info[:count].eql?(0)
             Log.log.debug('multi_session count is zero: no multisession')
             multi_session_info = nil
           elsif @options[:multi_incr_udp] # multi_session_info[:count] > 0
             # if option not true: keep default udp port for all sessions
-            multi_session_info[:udp_base] = transfer_spec.has_key?('fasp_port') ? transfer_spec['fasp_port'] : TransferSpec::UDP_PORT
+            multi_session_info[:udp_base] = transfer_spec.key?('fasp_port') ? transfer_spec['fasp_port'] : TransferSpec::UDP_PORT
             # delete from original transfer spec, as we will increment values
             transfer_spec.delete('fasp_port')
             # override if specified, else use default value
@@ -85,19 +81,19 @@ module Aspera
         end
 
         # compute known args
-        env_args = Parameters.ts_to_env_args(transfer_spec,wss: @options[:wss])
+        env_args = Parameters.ts_to_env_args(transfer_spec, wss: @options[:wss])
 
         # add fallback cert and key as arguments if needed
         if %w[1 force].include?(transfer_spec['http_fallback'])
-          env_args[:args].unshift('-Y',Installation.instance.path(:fallback_key))
-          env_args[:args].unshift('-I',Installation.instance.path(:fallback_cert))
+          env_args[:args].unshift('-Y', Installation.instance.path(:fallback_key))
+          env_args[:args].unshift('-I', Installation.instance.path(:fallback_cert))
         end
 
         env_args[:args].unshift('-q') if @options[:quiet]
 
         # transfer job can be multi session
         xfer_job = {
-          id:       job_options[:job_id],
+          id:       the_job_id,
           sessions: [] # all sessions as below
         }
 
@@ -107,8 +103,7 @@ module Aspera
           error:    nil,         # exception if failed
           io:       nil,         # management port server socket
           id:       nil,         # SessionId from INIT message in mgt port
-          env_args: env_args,    # env vars and args to ascp (from transfer spec)
-          options:  job_options  # [Hash]
+          env_args: env_args     # env vars and args to ascp (from transfer spec)
         }
 
         if multi_session_info.nil?
@@ -127,7 +122,7 @@ module Aspera
             this_session[:env_args][:args] = this_session[:env_args][:args].clone
             this_session[:env_args][:args].unshift("-C#{i}:#{multi_session_info[:count]}")
             # option: increment (default as per ascp manual) or not (cluster on other side ?)
-            this_session[:env_args][:args].unshift('-O',(multi_session_info[:udp_base] + i - 1).to_s) if @options[:multi_incr_udp]
+            this_session[:env_args][:args].unshift('-O', (multi_session_info[:udp_base] + i - 1).to_s) if @options[:multi_incr_udp]
             this_session[:thread] = Thread.new(this_session) {|s|transfer_thread_entry(s)}
             xfer_job[:sessions].push(this_session)
           end
@@ -135,10 +130,10 @@ module Aspera
         Log.log.debug('started session thread(s)')
 
         # add job to list of jobs
-        @jobs[job_options[:job_id]] = xfer_job
-        Log.log.debug("jobs: #{@jobs.keys.count}")
+        @jobs[the_job_id] = xfer_job
+        Log.log.debug{"jobs: #{@jobs.keys.count}"}
 
-        return job_options[:job_id]
+        return the_job_id
       end # start_transfer
 
       # wait for completion of all jobs started
@@ -147,9 +142,9 @@ module Aspera
         Log.log.debug('wait_for_transfers_completion')
         # set to non-nil to exit loop
         result = []
-        @jobs.each do |_id,job|
+        @jobs.each do |_id, job|
           job[:sessions].each do |session|
-            Log.log.debug("join #{session[:thread]}")
+            Log.log.debug{"join #{session[:thread]}"}
             session[:thread].join
             result.push(session[:error] || :success)
           end
@@ -173,13 +168,13 @@ module Aspera
       # @param env_args a hash containing :args :env :ascp_version
       # @param session this session information
       # could be private method
-      def start_transfer_with_args_env(env_args,session)
+      def start_transfer_with_args_env(env_args, session)
         raise 'env_args must be Hash' unless env_args.is_a?(Hash)
         raise 'session must be Hash' unless session.is_a?(Hash)
         # by default we assume an exception will be raised (for ensure block)
         exception_raised = true
         begin
-          Log.log.debug("env_args=#{env_args.inspect}")
+          Log.log.debug{"env_args=#{env_args.inspect}"}
           # get location of ascp executable
           ascp_path = @mutex.synchronize do
             Fasp::Installation.instance.path(env_args[:ascp_version])
@@ -187,24 +182,24 @@ module Aspera
           # (optional) check it exists
           raise Fasp::Error, "no such file: #{ascp_path}" unless File.exist?(ascp_path)
           # open random local TCP port for listening for ascp management
-          mgt_sock = TCPServer.new('127.0.0.1',0)
+          mgt_sock = TCPServer.new('127.0.0.1', 0)
           # clone arguments as we eed to modify with mgt port
           ascp_arguments = env_args[:args].clone
           # add management port
           ascp_arguments.unshift('-M', mgt_sock.addr[1].to_s)
           # start ascp in sub process
           Log.log.debug do
-            'execute: '+
-            env_args[:env].map{|k,v| "#{k}=#{Shellwords.shellescape(v)}"}.join(' ')+
-            ' '+
-            Shellwords.shellescape(ascp_path)+
-            ' '+
-            ascp_arguments.map{|a|Shellwords.shellescape(a)}.join(' ')
+            'execute: ' +
+              env_args[:env].map{|k, v| "#{k}=#{Shellwords.shellescape(v)}"}.join(' ') +
+              ' ' +
+              Shellwords.shellescape(ascp_path) +
+              ' ' +
+              ascp_arguments.map{|a|Shellwords.shellescape(a)}.join(' ')
           end
           # start process
-          ascp_pid = Process.spawn(env_args[:env],[ascp_path,ascp_path],*ascp_arguments)
+          ascp_pid = Process.spawn(env_args[:env], [ascp_path, ascp_path], *ascp_arguments)
           # in parent, wait for connection to socket max 3 seconds
-          Log.log.debug("before accept for pid (#{ascp_pid})")
+          Log.log.debug{"before accept for pid (#{ascp_pid})"}
           # init management socket
           ascp_mgt_io = nil
           Timeout.timeout(@options[:spawn_timeout_sec]) do
@@ -214,7 +209,7 @@ module Aspera
             # TODO: use same value as Encoding.default_external
             ascp_mgt_io.set_encoding(Encoding::UTF_8)
           end
-          Log.log.debug("after accept (#{ascp_mgt_io})")
+          Log.log.debug{"after accept (#{ascp_mgt_io})"}
           session[:io] = ascp_mgt_io
           # exact text for event, with \n
           current_event_text = ''
@@ -230,7 +225,7 @@ module Aspera
             break if line.nil?
             current_event_text += line
             line.chomp!
-            Log.log.debug("line=[#{line}]")
+            Log.log.debug{"line=[#{line}]"}
             case line
             when 'FASPMGR 2'
               # begin event
@@ -243,12 +238,12 @@ module Aspera
               # empty line is separator to end event information
               raise 'unexpected empty line' if current_event_data.nil?
               current_event_data[AgentBase::LISTENER_SESSION_ID_B] = ascp_pid
-              notify_listeners(current_event_text,current_event_data)
+              notify_listeners(current_event_text, current_event_data)
               case current_event_data['Type']
               when 'INIT'
                 session[:id] = current_event_data['SessionId']
-                Log.log.debug("session id: #{session[:id]}")
-              when 'DONE','ERROR'
+                Log.log.debug{"session id: #{session[:id]}"}
+              when 'DONE', 'ERROR'
                 # TODO: check if this is always the last event
                 last_status_event = current_event_data
               end # event type
@@ -263,16 +258,20 @@ module Aspera
               # all went well
               exception_raised = false
             when 'ERROR'
-              Log.log.error("code: #{last_status_event['Code']}")
+              Log.log.error{"code: #{last_status_event['Code']}"}
               if /bearer token/i.match?(last_status_event['Description'])
                 Log.log.error('need to regenerate token'.red)
-                if session[:options].is_a?(Hash) && session[:options].has_key?(:regenerate_token)
+                if !@token_regenerator.nil?
                   # regenerate token here, expired, or error on it
                   # Note: in multi-session, each session will have a different one.
-                  env_args[:env]['ASPERA_SCP_TOKEN'] = session[:options][:regenerate_token].call(true)
+                  env_args[:env]['ASPERA_SCP_TOKEN'] = @token_regenerator.call(true)
                 end
               end
-              raise Fasp::Error.new(last_status_event['Description'],last_status_event['Code'].to_i)
+              # cannot resolve address
+              # if last_status_event['Code'].to_i.eql?(14)
+              #  Log.log.warn{"host: #{}"}
+              # end
+              raise Fasp::Error.new(last_status_event['Description'], last_status_event['Code'].to_i)
             else # case
               raise "unexpected last event type: #{last_status_event['Type']}"
             end
@@ -312,22 +311,24 @@ module Aspera
       # @param data command on mgt port, examples:
       # {'type'=>'START','source'=>_path_,'destination'=>_path_}
       # {'type'=>'DONE'}
-      def send_command(job_id,session_index,data)
+      def send_command(job_id, session_index, data)
         job = @jobs[job_id]
         raise 'no such job' if job.nil?
         session = job[:sessions][session_index]
         raise 'no such session' if session.nil?
-        Log.log.debug("command: #{data}")
+        Log.log.debug{"command: #{data}"}
         # build command
-        command = data.
-          keys.
-          map{|k|"#{k.capitalize}: #{data[k]}"}.
-          unshift('FASPMGR 2').
-          push('','').
-          join("\n")
+        command = data
+          .keys
+          .map{|k|"#{k.capitalize}: #{data[k]}"}
+          .unshift('FASPMGR 2')
+          .push('', '')
+          .join("\n")
         session[:io].puts(command)
       end
 
+      attr_writer :token_regenerator
+
       private
 
       # @param options : keys(symbol): see DEFAULT_OPTIONS
@@ -341,13 +342,14 @@ module Aspera
         @options = DEFAULT_OPTIONS.dup
         if !options.nil?
           raise "expecting Hash (or nil), but have #{options.class}" unless options.is_a?(Hash)
-          options.each do |k,v|
-            raise "Unknown local agent parameter: #{k}, expect one of #{DEFAULT_OPTIONS.keys.map(&:to_s).join(',')}" unless DEFAULT_OPTIONS.has_key?(k)
+          options.each do |k, v|
+            raise "Unknown local agent parameter: #{k}, expect one of #{DEFAULT_OPTIONS.keys.map(&:to_s).join(',')}" unless DEFAULT_OPTIONS.key?(k)
             @options[k] = v
           end
         end
-        Log.log.debug("local options= #{options}")
+        Log.log.debug{"local options= #{options}"}
         @resume_policy = ResumePolicy.new(@options[:resume].symbolize_keys)
+        @token_regenerator = nil
       end
 
       # transfer thread entry
@@ -356,17 +358,17 @@ module Aspera
         begin
           # set name for logging
           Thread.current[:name] = 'transfer'
-          Log.log.debug("ENTER (#{Thread.current[:name]})")
+          Log.log.debug{"ENTER (#{Thread.current[:name]})"}
           # start transfer with selected resumer policy
-          session[:options][:resumer].execute_with_resume do
-            start_transfer_with_args_env(session[:env_args],session)
+          @resume_policy.execute_with_resume do
+            start_transfer_with_args_env(session[:env_args], session)
           end
           Log.log.debug('transfer ok'.bg_green)
         rescue StandardError => e
           session[:error] = e
-          Log.log.error("Transfer thread error: #{e.class}:\n#{e.message}:\n#{e.backtrace.join("\n")}".red) if Log.instance.level.eql?(:debug)
+          Log.log.error{"Transfer thread error: #{e.class}:\n#{e.message}:\n#{e.backtrace.join("\n")}".red} if Log.instance.level.eql?(:debug)
         end
-        Log.log.debug("EXIT (#{Thread.current[:name]})")
+        Log.log.debug{"EXIT (#{Thread.current[:name]})"}
       end
     end # AgentDirect
   end