electric_slide 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b7f9f14186f1dee1e5d75e38e79f6c1c127522e
-  data.tar.gz: 4f44af8a5750560e6f802227e36227142fba373f
+  metadata.gz: 018120f529e0824da4b7fb13d5ce713b53c16ec7
+  data.tar.gz: 7172bc885ad750962da497dd0d1afa560f5d5729
 SHA512:
-  metadata.gz: 7d3f04f5f1ce98f47913ba04fed0da9cf827c9e1bed80e9e6731e0e22e371b6214e1e03550213a7f48abcf3259732b538ea75a71b8d65fc436311cd240d2747f
-  data.tar.gz: 6cf73dd16a211f07e738e0cbd779e1a099e88786e57ec087763cfa58c1b77a84917c2e39020354fad302ee4a11de36a0907d002925da38a1276b9a571aafdd4a
+  metadata.gz: 8b3f3a9fd91292a2582f60c53f1d27a924b9ecb43d66013140f9c41ade3708fc2f6793a06cb3300bff0a4641116b1a9cef8afdcca84a120e3eff9fdf52043b1f
+  data.tar.gz: 8d9a3b56211a774348a0f7b953308415a69ae662e40355a63782786d9ce525350d9662ab4bec9be55edefb33bdab4fda8ff5d8248ba467125d6161ac2ba3dda6

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.2.1
+  - 2.2.2
+  - jruby-9.0.0.0
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+sudo: false

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# [develop](https://github.com/adhearsion/electric_slide)
+  * Trigger an agent "presence change" callback when the agent is removed from the queue
+  * Bugfix: Fix `NameError` exception when referencing namespaced constant `Adhearsion::Call::ExpiredError` in injected `Adhearsion::Call#active?` method
+  * Provide Electric Slide with a way to check if a queue with a given set of attributes is valid/can be instantiated before Electric Slide adds it to the supervision group. The supervisor will crash if its attempt to create the queue raises an exception.
+  * Add support for changing queue attributes
+    * API Breakage: Setting queue connection type to an invalid value will now raise an `ElectricSlide::CallQueue::InvalidConnectionType` exception instead of `ArgumentError`
+    * API Breakage: Setting queue agent return method to an invalid value will now raise an `ElectricSlide::CallQueue::InvalidRequeueMethod` exception instead of `ArgumentError`
+  * List created queues by name via `ElectricSlide.queues_by_name`
+  * Set `:agent` call variable on queued call when connecting calls
+  * API Breakage: Queues must now be Celluloid actors responding to the standard actor API. `ElectricSlide::CallQueue.work` is removed in favour of `.new`.
+  * API Breakage: Prevent an unqueued agent from being returned to the queue - this avoids calls after logging out
+  * API Breakage: An agent's presence should be :after_call if they are not automatically returned to being available
+  * API Breakage: Store queued/connected timestamps on calls
+  * API Breakage: Remove abandoned calls from the queue
+  * Set agent `#call` attribute to outbound call made to agent in :call mode
+  * Prevent an agent from being added to the queue more than once
+  * Added Travis CI configuration
+  * Lots more test coverage - still bad
+
+# [0.2.0](https://github.com/adhearsion/electric_slide/compare/bb3b1b3e7f6d0926d0a9f462520e1f6d0c277adf...v0.2.0) - [2015-07-23](https://rubygems.org/gems/adhearsion/versions/0.2.0)
+  * ¯\\_(ツ)_/¯

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 The Adhearsion Foundation, Inc.
+Copyright (c) 2011-2015 The Adhearsion Foundation, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/README.markdown

@@ -1,7 +1,7 @@
 Electric Slide - Simple Call Distribution for Adhearsion
 ====================================================================
 
-This library implements a simple FIFO (First-In, First-Out) call queue for Adhearsion.
+This library implements a simple call queue for Adhearsion.
 
 To ensure proper operation, a few things are assumed:
 
@@ -63,7 +63,7 @@ end
 Adding an Agent to the Queue
 ----------------------------
 
-ElectricSlide expects to be given a objects that quack like an agent. You can use the built-in `ElectricSlide::Agent` class, or you can provide your own.
+ElectricSlide expects to be instances of the `ElectricSlide::Agent` class. This is designed to be extended with custom functionality when necessary.
 
 To add an agent who will receive calls whenever a call is enqueued, do something like this:
 
@@ -72,7 +72,7 @@ agent = ElectricSlide::Agent.new id: 1, address: 'sip:agent1@example.com', prese
 ElectricSlide.get_queue(:my_queue).add_agent agent
 ```
 
-To inform the queue that the agent is no longer available you *must* use the ElectricSlide queue interface. /Do not attempt to alter agent objects directly!/
+To inform the queue that the agent is no longer available you *must* use the ElectricSlide queue interface. **_Do not attempt to change agent objects directly!_**
 
 ```ruby
 ElectricSlide.update_agent 1, presence: offline
@@ -84,12 +84,21 @@ If it is more convenient, you may also pass `#update_agent` an Agent-like object
 options = {
   id: 1,
   address: 'sip:agent1@example.com',
-  presence: offline
+  presence: :unavailable
 }
 agent = ElectricSlide::Agent.new options
 ElectricSlide.update_agent 1, agent
 ```
 
+The possible presence states for an Agent are:
+
+* `:available` - Waiting for a call
+* `:on_call` - Currently connected to a call
+* `:after_call` - In a quiet period after completing a call and before being made available again. This is only encountered with a manual agent return strategy.
+* `:unavailable` - Agent is not available (on break, offline, etc)
+
+Note that an `:unavailable` agent still counts as an agent in the queue, but will not be sent any calls. Make sure to remove agents, even unavailable ones, when agents sign out by using the `#remove_agent` method.
+
 Switching connection types
 --------------------------
 
@@ -124,8 +133,10 @@ Custom Agent Behavior
 
 If you need custom functionality to occur whenever an Agent is selected to take a call, you can use the callbacks on the Agent object:
 
-* `on_connect`
-* `on_disconnect`
+* `on_connect`: Args: [Queue, Agent Call, Client Call] Called as the agent is being connected to the client call
+* `on_disconnect`: Args: [Queue, Agent Call, Client Call] Called after the agent is disconnected from the client for any reason (eg. hangup)
+* `connection_failed`: Args: [Queue, Agent Call, Client Call] Called when the agent fails to connect with the client for any reason (eg. no answer)
+* `presence_change`: Args: [Queue, Agent Call, New Presence] Called after the agent's presence changes
 
 Confirmation Controllers
 ------------------------
@@ -151,3 +162,19 @@ call.join metadata[:caller] if confirm!
 ```
 
 where `confirm!` is your logic for deciding if you want the call to be connected or not. Hanging up during the confirmation controller or letting it finish without any action will result in the call being sent to the next agent.
+
+Credits
+-------
+
+Electric Slide Copyright 2011-2015 Adhearsion Foundation Inc.
+See the LICENSE file for more information.
+
+Original Author [Ben Klang](https://github.com/bklang) - Mojo Lingo
+
+Contributors:
+* [Ben Langfeld](https://github.com/benlangfeld) - Mojo Lingo
+* [Neil Decapia](https://github.com/neildecapia) - Mojo Lingo
+* [Lloyd Hughes](https://github.com/system123) - Teleforge
+* [Luca Pradovera](https://github.com/polysics) - Mojo Lingo
+
+Also thanks to [Power Home Remodeling Group](http://powerhrg.com), [Teleforge](http://teleforge.co.za), and Atlanta Game Adventures for sponsoring development.

data/electric_slide.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
 
   s.has_rdoc = true
   s.homepage = "http://github.com/adhearsion/electric_slide"
+  s.license = "MIT"
   s.require_paths = ["lib"]
   s.rubygems_version = "1.2.0"
   s.summary = "Automatic Call Distributor for Adhearsion"
@@ -25,7 +26,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'adhearsion'
   s.add_runtime_dependency 'countdownlatch'
   s.add_runtime_dependency 'activesupport'
-  s.add_development_dependency 'rspec', ['>= 2.5.0']
+  s.add_development_dependency 'rspec', ['~> 3.0']
+  s.add_development_dependency 'timecop'
   s.add_development_dependency 'ci_reporter'
   s.add_development_dependency 'guard'
   s.add_development_dependency 'guard-rspec'

data/lib/electric_slide.rb

@@ -1,68 +1,68 @@
 # encoding: utf-8
 require 'celluloid'
-require 'singleton'
 
 require 'adhearsion/version'
 
 if Gem::Version.new(Adhearsion::VERSION) < Gem::Version.new('3.0.0')
   # Backport https://github.com/adhearsion/adhearsion/commit/8c6855612c70dd822fb4e4c2006d1fdc9d05fe23 to avoid confusion around dead calls
   require 'adhearsion/call'
-  class Adhearsion::Call::ActorProxy < Celluloid::ActorProxy
-    def active?
-      alive? && super
-    rescue Adhearsion::Call::ExpiredError
-      false
+  class Adhearsion::Call
+    class ActorProxy
+      def active?
+        alive? && super
+      rescue ExpiredError
+        false
+      end
     end
   end
 end
 
 %w(
+  agent
   call_queue
   plugin
 ).each { |f| require "electric_slide/#{f}" }
 
 class ElectricSlide
-  include Singleton
+  class Supervisor < Celluloid::SupervisionGroup
+    def [](name)
+      @registry[name]
+    end
 
-  def initialize
-    @mutex = Mutex.new
-    @queues = {}
+    def names
+      @registry.names
+    end
   end
 
-  def create(name, queue_class = nil, *args)
-    fail "Queue with name #{name} already exists!" if @queues.key? name
+  @supervisor = Supervisor.run!(Celluloid::Registry.new)
 
-    queue_class ||= CallQueue
-    @queues[name] = queue_class.work *args
-    # Return the queue instance or current actor
-    get_queue name
+  def self.queues_by_name
+    @supervisor.names.inject({}) do |queues, name|
+      queues[name] = get_queue(name)
+      queues
+    end
   end
 
-  def get_queue!(name)
-    fail "Queue #{name} not found!" unless @queues.key?(name)
-    get_queue name
-  end
+  def self.create(name, queue_class = nil, *args)
+    fail "Queue with name #{name} already exists!" if get_queue(name)
 
-  def get_queue(name)
-    queue = @queues[name]
-    if queue.respond_to? :actors
-      # In case we have a Celluloid supervision group, get the current actor
-      queue.actors.first
-    else
-      queue
+    queue_class ||= CallQueue
+    if !queue_class.respond_to?(:valid_with?) || queue_class.valid_with?(*args)
+      @supervisor.supervise_as name, (queue_class || CallQueue), *args
+      get_queue name
     end
   end
 
-  def shutdown_queue(name)
-    queue = get_queue name
-    queue.terminate
-    @queues.delete name
+  def self.get_queue!(name)
+    get_queue(name) || fail("Queue #{name} not found!")
   end
 
-  def self.method_missing(method, *args, &block)
-    @@mutex ||= Mutex.new
-    @@mutex.synchronize do
-      instance.send method, *args, &block
-    end
+  def self.get_queue(name)
+    @supervisor[name]
+  end
+
+  def self.shutdown_queue(name)
+    queue = get_queue name
+    queue.terminate if queue
   end
 end

data/lib/electric_slide/agent.rb

@@ -1,48 +1,71 @@
 # encoding: utf-8
-class ElectricSlide::Agent
-  attr_accessor :id, :address, :presence, :call, :connect_callback, :disconnect_callback
-
-  # @param [Hash] opts Agent parameters
-  # @option opts [String] :id The Agent's ID
-  # @option opts [String] :address The Agent's contact address
-  # @option opts [Symbol] :presence The Agent's current presence. Must be one of :available, :on_call, :away, :offline
-  def initialize(opts = {})
-    @id = opts[:id]
-    @address = opts[:address]
-    @presence = opts[:presence]
-  end
 
-  def callback(type, *args)
-    callback = self.class.instance_variable_get "@#{type}_callback"
-    instance_exec *args, &callback if callback && callback.respond_to?(:call)
-  end
+class ElectricSlide
+  class Agent
+    attr_accessor :id, :address, :presence, :call, :queue
 
+    # @param [Hash] opts Agent parameters
+    # @option opts [String] :id The Agent's ID
+    # @option opts [String] :address The Agent's contact address
+    # @option opts [Symbol] :presence The Agent's current presence. Must be one of :available, :on_call, :after_call, :unavailable
+    def initialize(opts = {})
+      @id = opts[:id]
+      @address = opts[:address]
+      @presence = opts[:presence] || :available
+    end
 
-  # Provide a block to be called when this agent is connected to a caller
-  # The block will be passed the queue, the agent call and the client call
-  def self.on_connect(&block)
-    @connect_callback = block
-  end
+    def presence=(new_presence)
+      old_presence = @presence
+      @presence = new_presence
+      callback :presence_change, queue, @call, new_presence, old_presence
+    end
 
-  # Provide a block to be called when this agent is disconnected to a caller
-  # The block will be passed the queue, the agent call and the client call
-  def self.on_disconnect(&block)
-    @disconnect_callback = block
-  end
+    def callback(type, *args)
+      callback = self.class.instance_variable_get "@#{type}_callback"
+      instance_exec *args, &callback if callback && callback.respond_to?(:call)
+    end
 
-  # Called to provide options for calling this agent that are passed to #dial
-  def dial_options_for(queue, queued_call)
-    {}
-  end
+    # Provide a block to be called when this agent is connected to a caller
+    # The block will be passed the queue, the agent call and the client call
+    def self.on_connect(&block)
+      @connect_callback = block
+    end
 
-  def join(queued_call)
-    # For use in queues that need bridge connections
-    @call.join queued_call
-  end
+    # Provide a block to be called when this agent is disconnected to a caller
+    # The block will be passed the queue, the agent call and the client call
+    def self.on_disconnect(&block)
+      @disconnect_callback = block
+    end
 
-  # FIXME: Use delegator?
-  def from
-    @call.from
+    # Provide a block to be called when this agent's presence changes
+    # The block will be passed the queue, the agent call, and the new presence
+    def self.on_presence_change(&block)
+      @presence_change_callback = block
+    end
+
+    # Provide a block to be called when the agent connection to the callee fails
+    # The block will be passed the queue, the agent call and the client call
+    def self.on_connection_failed(&block)
+      @connection_failed_callback = block
+    end
+
+    def on_call?
+      @presence == :on_call
+    end
+
+    # Called to provide options for calling this agent that are passed to #dial
+    def dial_options_for(queue, queued_call)
+      {}
+    end
+
+    def join(queued_call)
+      # For use in queues that need bridge connections
+      @call.join queued_call
+    end
+
+    # FIXME: Use delegator?
+    def from
+      @call.from
+    end
   end
 end
-

data/lib/electric_slide/agent_strategy/longest_idle.rb

@@ -20,7 +20,7 @@ class ElectricSlide
         { total: @free_agents.count }
       end
 
-      # Assigns the first available agent, marking the agent :busy
+      # Assigns the first available agent, marking the agent :on_call
       # @return {Agent}
       def checkout_agent
         @free_agents.shift

data/lib/electric_slide/call_queue.rb

@@ -6,6 +6,7 @@ require 'electric_slide/agent_strategy/longest_idle'
 class ElectricSlide
   class CallQueue
     include Celluloid
+
     ENDED_CALL_EXCEPTIONS = [
       Adhearsion::Call::Hangup,
       Adhearsion::Call::ExpiredError,
@@ -24,23 +25,90 @@ class ElectricSlide
       :manual,
     ].freeze
 
-    def self.work(*args)
-      self.supervise *args
+    Error = Class.new(StandardError)
+
+    MissingAgentError = Class.new(Error)
+    DuplicateAgentError = Class.new(Error)
+
+    class InvalidConnectionType < Error
+      def message
+        "Invalid connection type; must be one of #{CONNECTION_TYPES.join ','}"
+      end
     end
 
-    def initialize(opts = {})
-      agent_strategy   = opts[:agent_strategy]  || AgentStrategy::LongestIdle
-      @connection_type = opts[:connection_type] || :call
-      @agent_return_method = opts[:agent_return_method] || :auto
+    class InvalidRequeueMethod < Error
+      def message
+        "Invalid requeue method; must be one of #{AGENT_RETURN_METHODS.join ','}"
+      end
+    end
+
+    attr_reader :agent_strategy, :connection_type, :agent_return_method
+
+    def self.valid_with?(attrs = {})
+      return false unless Hash === attrs
 
-      raise ArgumentError, "Invalid connection type; must be one of #{CONNECTION_TYPES.join ','}" unless CONNECTION_TYPES.include? @connection_type
-      raise ArgumentError, "Invalid requeue method; must be one of #{AGENT_RETURN_METHODS.join ','}" unless AGENT_RETURN_METHODS.include? @agent_return_method
+      if agent_strategy = attrs[:agent_strategy]
+        begin
+          agent_strategy.new
+        rescue Exception
+          return false
+        end
+      end
+      if connection_type = attrs[:connection_type]
+        return false unless valid_connection_type? connection_type
+      end
+      if agent_return_method = attrs[:agent_return_method]
+        return false unless valid_agent_return_method? agent_return_method
+      end
 
-      @free_agents = [] # Needed to keep track of waiting order
+      true
+    end
+
+    def self.valid_connection_type?(connection_type)
+      CONNECTION_TYPES.include? connection_type
+    end
+
+    def self.valid_agent_return_method?(agent_return_method)
+      AGENT_RETURN_METHODS.include? agent_return_method
+    end
+
+    def initialize(opts = {})
       @agents = []      # Needed to keep track of global list of agents
       @queue = []       # Calls waiting for an agent
 
-      @strategy = agent_strategy.new
+      update(
+        agent_strategy: opts[:agent_strategy] || AgentStrategy::LongestIdle,
+        connection_type: opts[:connection_type] || :call,
+        agent_return_method: opts[:agent_return_method] || :auto
+      )
+    end
+
+    def update(attrs)
+      attrs.each do |attr, value|
+        setter = "#{attr}="
+        send setter, value if respond_to?(setter)
+      end unless attrs.nil?
+    end
+
+    def agent_strategy=(new_agent_strategy)
+      @agent_strategy = new_agent_strategy
+
+      @strategy = @agent_strategy.new
+      @agents.each do |agent|
+        return_agent agent, agent.presence
+      end
+
+      @agent_strategy
+    end
+
+    def connection_type=(new_connection_type)
+      abort InvalidConnectionType.new unless CallQueue.valid_connection_type? new_connection_type
+      @connection_type = new_connection_type
+    end
+
+    def agent_return_method=(new_agent_return_method)
+      abort InvalidRequeueMethod.new unless CallQueue.valid_agent_return_method? new_agent_return_method
+      @agent_return_method = new_agent_return_method
     end
 
     # Checks whether an agent is available to take a call
@@ -58,11 +126,13 @@ class ElectricSlide
       @strategy.available_agent_summary
     end
 
-    # Assigns the first available agent, marking the agent :busy
+    # Assigns the first available agent, marking the agent :on_call
     # @return {Agent}
     def checkout_agent
       agent = @strategy.checkout_agent
-      agent.presence = :busy
+      if agent
+        agent.presence = :on_call
+      end
       agent
     end
 
@@ -87,46 +157,68 @@ class ElectricSlide
 
     # Registers an agent to the queue
     # @param [Agent] agent The agent to be added to the queue
+    # @raise ArgumentError if the agent is malformed
+    # @raise DuplicateAgentError if this agent ID already exists
+    # @see #update_agent
     def add_agent(agent)
       abort ArgumentError.new("#add_agent called with nil object") if agent.nil?
+      abort DuplicateAgentError.new("Agent is already in the queue") if get_agent(agent.id)
+
+      agent.queue = self
+
       case @connection_type
       when :call
         abort ArgumentError.new("Agent has no callable address") unless agent.address
       when :bridge
-        abort ArgumentError.new("Agent has no active call") unless agent.call && agent.call.active?
-        unless agent.call[:electric_slide_callback_set]
-          agent.call.on_end { remove_agent agent }
-          agent.call[:electric_slide_callback_set] = true
-        end
+        bridged_agent_health_check agent
       end
 
       logger.info "Adding agent #{agent} to the queue"
-      @agents << agent unless @agents.include? agent
+      @agents << agent
       @strategy << agent if agent.presence == :available
+      # Fake the presence callback since this is a new agent
+      agent.callback :presence_change, self, agent.call, agent.presence, :unavailable
+
       check_for_connections
     end
 
     # Marks an agent as available to take a call. To be called after an agent completes a call
     # and is ready to take the next call.
     # @param [Agent] agent The {Agent} that is being returned to the queue
-    # @param [Symbol] status The {Agent}'s new status
+    # @param [Symbol] new_presence The {Agent}'s new presence
     # @param [String, Optional] address The {Agent}'s address. Only specified if it has changed
-    def return_agent(agent, status = :available, address = nil)
+    def return_agent(agent, new_presence = :available, address = nil)
       logger.debug "Returning #{agent} to the queue"
-      agent.presence = status
+
+      return false unless get_agent(agent.id)
+
+      agent.presence = new_presence
       agent.address = address if address
 
-      if agent.presence == :available
+      case agent.presence
+      when :available
+        bridged_agent_health_check agent
+
         @strategy << agent
         check_for_connections
+      when :unavailable
+        @strategy.delete agent
       end
       agent
     end
 
+    # Marks an agent as available to take a call.
+    # @see #return_agent
+    # @raises [ElectricSlide::CallQueue::MissingAgentError] when the agent cannot be returned because they have been explicitly removed.
+    def return_agent!(*args)
+      return_agent(*args) || abort(MissingAgentError.new('Agent is not in the queue. Unable to return agent.'))
+    end
+
     # Removes an agent from the queue entirely
     # @param [Agent] agent The {Agent} to be removed from the queue
     # @return [Agent, Nil] The Agent object if removed, Nil otherwise
     def remove_agent(agent)
+      agent.presence = :unavailable
       @strategy.delete agent
       @agents.delete agent
       logger.info "Removing agent #{agent} from the queue"
@@ -143,8 +235,13 @@ class ElectricSlide
     # to an agent, but the connection fails because the agent is not available.
     # @param [Adhearsion::Call] call Caller to be added to the queue
     def priority_enqueue(call)
-      # Don't reset the enqueue time in case this is a re-insert on agent failure
-      call[:enqueue_time] ||= Time.now
+      # In case this is a re-insert on agent failure...
+      # ... reset `:agent` call variable
+      call[:agent] = nil
+      # ... set, but don't reset, the enqueue time
+      call[:electric_slide_enqueued_at] ||= DateTime.now
+
+      call.on_end { remove_call call }
       @queue.unshift call
 
       check_for_connections
@@ -155,7 +252,8 @@ class ElectricSlide
     def enqueue(call)
       ignoring_ended_calls do
         logger.info "Adding call from #{remote_party call} to the queue"
-        call[:enqueue_time] = Time.now
+        call[:electric_slide_enqueued_at] = DateTime.now
+        call.on_end { remove_call call }
         @queue << call unless @queue.include? call
 
         check_for_connections
@@ -164,8 +262,12 @@ class ElectricSlide
 
     # Remove a waiting call from the queue. Used if the caller hangs up or is otherwise removed.
     # @param [Adhearsion::Call] call Caller to be removed from the queue
-    def abandon(call)
-      ignoring_ended_calls { logger.info "Caller #{remote_party call} has abandoned the queue" }
+    def remove_call(call)
+      ignoring_ended_calls do
+        unless call[:electric_slide_connected_at]
+          logger.info "Caller #{remote_party call} has abandoned the queue"
+        end
+      end
       @queue.delete call
     end
 
@@ -178,12 +280,14 @@ class ElectricSlide
         return_agent agent
       end
 
+      queued_call[:agent] = agent
+
       logger.info "Connecting #{agent} with #{remote_party queued_call}"
       case @connection_type
       when :call
         call_agent agent, queued_call
       when :bridge
-        unless agent.call.active?
+        unless agent.call && agent.call.active?
           logger.warn "Inactive agent call found in #connect, returning caller to queue"
           priority_enqueue queued_call
         end
@@ -199,6 +303,8 @@ class ElectricSlide
       ignoring_ended_calls do
         if agent.call && agent.call.active?
           logger.warn "Dead call exception in #connect but agent call still alive, reinserting into queue"
+          agent.callback :connection_failed, self, agent.call, queued_call
+
           return_agent agent
         end
       end
@@ -207,11 +313,12 @@ class ElectricSlide
     def conditionally_return_agent(agent, return_method = @agent_return_method)
       raise ArgumentError, "Invalid requeue method; must be one of #{AGENT_RETURN_METHODS.join ','}" unless AGENT_RETURN_METHODS.include? return_method
 
-      if agent && @agents.include?(agent) && agent.presence == :busy && return_method == :auto
+      if agent && @agents.include?(agent) && agent.on_call? && return_method == :auto
         logger.info "Returning agent #{agent.id} to queue"
         return_agent agent
       else
         logger.debug "Not returning agent #{agent.inspect} to the queue"
+        return_agent agent, :after_call
       end
     end
 
@@ -234,6 +341,7 @@ class ElectricSlide
     end
 
   private
+
     # Get the caller ID of the remote party.
     # If this is an OutboundCall, use Call#to
     # Otherwise, use Call#from
@@ -241,7 +349,6 @@ class ElectricSlide
       call.is_a?(Adhearsion::OutboundCall) ? call.to : call.from
     end
 
-
     # @private
     def ignoring_ended_calls
       yield
@@ -254,6 +361,8 @@ class ElectricSlide
       agent_call[:agent]  = agent
       agent_call[:queued_call] = queued_call
 
+      agent.call = agent_call
+
       # Stash the caller ID so we don't have to try to get it from a dead call object later
       queued_caller_id = remote_party queued_call
 
@@ -273,17 +382,24 @@ class ElectricSlide
 
       # Track whether the agent actually talks to the queued_call
       connected = false
-      queued_call.on_joined { connected = true }
+      queued_call.register_tmp_handler :event, Punchblock::Event::Joined do |event|
+        connected = true
+        queued_call[:electric_slide_connected_at] = event.timestamp
+      end
 
       agent_call.on_end do |end_event|
         # Ensure we don't return an agent that was removed or paused
         conditionally_return_agent agent
 
+        agent.call = nil
+
         agent.callback :disconnect, self, agent_call, queued_call
 
         unless connected
-          if queued_call.alive? && queued_call.active?
+          if queued_call.active?
             ignoring_ended_calls { priority_enqueue queued_call }
+            agent.callback :connection_failed, self, agent_call, queued_call
+
             logger.warn "Call did not connect to agent! Agent #{agent.id} call ended with #{end_event.reason}; reinserting caller #{queued_caller_id} into queue"
           else
             logger.warn "Caller #{queued_caller_id} hung up before being connected to an agent."
@@ -306,8 +422,12 @@ class ElectricSlide
       agent.call.register_tmp_handler :event, Punchblock::Event::Unjoined do
         agent.callback :disconnect, self, agent.call, queued_call
         ignoring_ended_calls { queued_call.hangup }
-        ignoring_ended_calls { conditionally_return_agent agent if agent.call.active? }
-        agent.call[:queued_call] = nil
+        ignoring_ended_calls { conditionally_return_agent agent if agent.call && agent.call.active? }
+        agent.call[:queued_call] = nil if agent.call
+      end
+
+      queued_call.register_tmp_handler :event, Punchblock::Event::Joined do |event|
+        queued_call[:electric_slide_connected_at] = event.timestamp
       end
 
       agent.callback :connect, self, agent.call, queued_call
@@ -315,12 +435,11 @@ class ElectricSlide
       agent.join queued_call if queued_call.active?
     rescue *ENDED_CALL_EXCEPTIONS
       ignoring_ended_calls do
-        if agent.call.active?
+        if agent.call && agent.call.active?
+          agent.callback :connection_failed, self, agent.call, queued_call
+
           logger.info "Caller #{queued_caller_id} failed to connect to Agent #{agent.id} due to caller hangup"
           conditionally_return_agent agent, :auto
-        else
-          # Agent's call has ended, so remove him from the queue
-          remove_agent agent
         end
       end
 
@@ -331,5 +450,20 @@ class ElectricSlide
         end
       end
     end
+
+    # @private
+    def bridged_agent_health_check(agent)
+      if agent.presence == :available && @connection_type == :bridge
+        abort ArgumentError.new("Agent has no active call") unless agent.call && agent.call.active?
+        unless agent.call[:electric_slide_callback_set]
+          agent.call[:electric_slide_callback_set] = true
+          queue = self
+          agent.call.on_end do
+            agent.call = nil
+            queue.return_agent agent, :unavailable
+          end
+        end
+      end
+    end
   end
 end