postjob 0.5.11 → 0.5.12

data/lib/postjob/migrations/013a_checkout_runnable.sql

@@ -1,3 +1,35 @@
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.session_should_shutdown(p_worker_session_id UUID)
+  RETURNS BOOLEAN
+AS $$
+DECLARE
+  session {SCHEMA_NAME}.worker_sessions;
+  host {SCHEMA_NAME}.hosts;
+BEGIN
+  SELECT * INTO session
+  FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
+
+  SELECT * INTO host
+  FROM {SCHEMA_NAME}.hosts WHERE id=session.host_id;
+
+  IF host.status != 'shutdown' THEN
+    RETURN FALSE;
+  END IF;
+
+  -- If there unfinished sticky jobs on this host we do not shutdown this session.
+
+  IF EXISTS (
+    SELECT 1 FROM postjob.postjobs WHERE
+      status NOT IN ('ok', 'failed', 'timeout')
+      AND sticky_host_id=host.id
+  ) THEN
+    RETURN FALSE;
+  END IF;
+
+  RETURN TRUE;
+END;
+$$ LANGUAGE plpgsql;
+
+
 DROP FUNCTION IF EXISTS {SCHEMA_NAME}.time_to_next_job(workflows_with_versions varchar[]);  -- removed in 0.5.0
 DROP FUNCTION IF EXISTS {SCHEMA_NAME}.time_to_next_job(p_worker_session_id UUID);           -- removed in 0.5.7
 CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.time_to_next_job(p_worker_session_id UUID, p_queue varchar[])
@@ -6,16 +38,20 @@ AS $$
 DECLARE
   p_processable_at timestamp;
   session {SCHEMA_NAME}.worker_sessions;
+  host {SCHEMA_NAME}.hosts;
   p_current_greedy_job {SCHEMA_NAME}.postjobs;
 BEGIN
   SELECT * INTO session
   FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
 
+  SELECT * INTO host
+  FROM {SCHEMA_NAME}.hosts WHERE id=session.host_id;
+
   SELECT * INTO p_current_greedy_job
   FROM {SCHEMA_NAME}.postjobs WHERE
-    status NOT IN ('ok', 'failed') AND
-    id=root_id AND
-    is_greedy
+    status NOT IN ('ok', 'failed', 'timeout')
+    AND id=root_id
+    AND is_greedy
   LIMIT 1;
 
   SELECT MIN(processable_at) INTO p_processable_at FROM (
@@ -34,6 +70,7 @@ BEGIN
           p_current_greedy_job.id IS NULL OR root_id=p_current_greedy_job.root_id                                 -- if there is a greedy job on this host_id which is not finished yet,
                                                                                                                   -- only jobs belonging to this root jobs are allowed.
         )
+        AND ((host.status != 'shutdown') OR root_id=p_current_greedy_job.root_id)                                 -- during shutdown only get greedy jobs.
   ) sq;
 
   RETURN EXTRACT(EPOCH FROM p_processable_at - (now() at time zone 'utc'));
@@ -52,11 +89,14 @@ AS $$
 DECLARE
   job {SCHEMA_NAME}.postjobs;
   session {SCHEMA_NAME}.worker_sessions;
+  host {SCHEMA_NAME}.hosts;
   p_current_greedy_job {SCHEMA_NAME}.postjobs;
 BEGIN
   SELECT * INTO session
   FROM {SCHEMA_NAME}.worker_sessions WHERE id=p_worker_session_id;
 
+  --
+  -- Note on "FOR UPDATE":
   --
   -- We don't want multiple sessions to run this function in parallel. This can lead to a situation
   -- where multiple greedy root jobs could be selected for different workers with identical host ids
@@ -64,11 +104,12 @@ BEGIN
   -- hosts table for locking. This look will be released automatically with the current transaction,
   -- i.e. typically after the "SELECT * FROM checkout(..)" returns.
   --
-  PERFORM * FROM {SCHEMA_NAME}.hosts WHERE id=session.host_id FOR UPDATE;
+  SELECT * INTO host
+  FROM {SCHEMA_NAME}.hosts WHERE id=session.host_id FOR UPDATE;
 
   SELECT * INTO p_current_greedy_job
   FROM {SCHEMA_NAME}.postjobs WHERE
-    status NOT IN ('ok', 'failed')
+    status NOT IN ('ok', 'failed', 'timeout')
     AND id=root_id
     AND sticky_host_id=session.host_id
     AND is_greedy
@@ -95,6 +136,7 @@ BEGIN
           p_current_greedy_job.id IS NULL OR s.root_id=p_current_greedy_job.root_id                               -- if there is a greedy job on this host_id which is not finished yet,
                                                                                                                   -- only jobs belonging to this root jobs are allowed.
         )
+        AND ((host.status != 'shutdown') OR root_id=p_current_greedy_job.root_id)                                 -- during shutdown only get greedy jobs.
       )
     ORDER BY (LEAST(s.next_run_at, s.timing_out_at))
     FOR UPDATE SKIP LOCKED

data/lib/postjob/migrations/016_sessions_functions.sql

@@ -1,6 +1,8 @@
 -- worker_session_start: starts or reuses a worker_session ----------------------------------
 
-CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.worker_session_start(p_host_id UUID, p_workflows VARCHAR[])
+DROP FUNCTION IF EXISTS {SCHEMA_NAME}.worker_session_start(p_host_id UUID, p_workflows VARCHAR[]);
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}.worker_session_start(p_host_id UUID, p_workflows VARCHAR[], p_queues VARCHAR[])
 RETURNS SETOF {SCHEMA_NAME}.worker_sessions AS $$
 DECLARE
   v_worker_session_id UUID;
@@ -8,8 +10,8 @@ DECLARE
 BEGIN
   SELECT client_addr || ':' || client_port INTO v_client_socket FROM pg_stat_activity WHERE pid = pg_backend_pid();
 
-  INSERT INTO {SCHEMA_NAME}.worker_sessions (host_id, client_socket, workflows)
-    VALUES (p_host_id, v_client_socket, p_workflows) RETURNING id INTO v_worker_session_id;
+  INSERT INTO {SCHEMA_NAME}.worker_sessions (host_id, client_socket, workflows, queues)
+    VALUES (p_host_id, v_client_socket, p_workflows, p_queues) RETURNING id INTO v_worker_session_id;
 
   RETURN QUERY SELECT * FROM {SCHEMA_NAME}.worker_sessions WHERE id = v_worker_session_id;
 END;

data/lib/postjob/migrations/017_zombie_check.sql

@@ -1,5 +1,37 @@
 -- zombie checks --------------------------------------------------------------
 
+
+CREATE OR REPLACE FUNCTION {SCHEMA_NAME}._set_job_zombie(
+  job_id BIGINT,
+  p_fast_mode BOOLEAN) RETURNS VOID AS $$
+DECLARE
+  p_worker_session_id UUID;
+  session {SCHEMA_NAME}.worker_sessions;
+BEGIN
+  SELECT * INTO session
+    FROM {SCHEMA_NAME}.worker_sessions worker_sessions
+    INNER JOIN {SCHEMA_NAME}.postjobs postjobs ON postjobs.last_worker_session_id=worker_sessions.id
+    WHERE postjobs.id=job_id;
+
+  p_worker_session_id := {SCHEMA_NAME}._null_uuid();
+  PERFORM {SCHEMA_NAME}._reset_job_processing(p_worker_session_id, job_id);
+
+  -- write error info
+  UPDATE {SCHEMA_NAME}.postjobs
+  SET
+    error='Zombie',
+    error_message='host ' || session.host_id || ' disappeared',
+    error_backtrace=NULL,
+    failed_attempts=failed_attempts+1,
+    next_run_at=NULL
+  WHERE id=job_id;
+
+  -- prepare next run, if any
+  PERFORM {SCHEMA_NAME}._prepare_rerun(job_id, 'err', p_fast_mode);
+  PERFORM {SCHEMA_NAME}._wakeup_parent_job(p_worker_session_id, job_id);
+END;
+$$ LANGUAGE plpgsql;
+
 -- This method runs a zombie check. Its result is written into the database as
 -- a 'zombie' event. A zombie check should only happen once per minute.
 --
@@ -15,12 +47,11 @@ DECLARE
 BEGIN
   zombie_count := 0;
   FOR zombie_id, _one IN
-    -- select jobs that have a last_worker_session_id, which points to a
-    -- host whose latest heartbeat is older than +zombie_threshold+.
+    -- select jobs that have a last_worker_session_id, which points to a host
+    -- whose latest heartbeat is older than +zombie_threshold+.
     --
-    -- note that we ignore hosts (and, for that matter, jobs) that don't
-    -- have any heartbeats, since this scenario should only appear during
-    -- tests.
+    -- We ignore hosts (and, for that matter, jobs) that don't  have any heartbeats,
+    -- since this scenario should only appear during tests.
     SELECT jobs.id, 1
     FROM {SCHEMA_NAME}.postjobs jobs
     LEFT JOIN {SCHEMA_NAME}.worker_sessions sessions ON jobs.last_worker_session_id=sessions.id
@@ -30,10 +61,9 @@ BEGIN
       FROM {SCHEMA_NAME}.events
       WHERE name = 'heartbeat'
       GROUP BY host_id
-    ) heartbeat ON sessions.host_id = heartbeat.host_id
-    WHERE
-      jobs.status IN ('processing')
-      AND heartbeat.created_at < ((now() at time zone 'utc') - zombie_threshold)
+    ) latest_heartbeat ON sessions.host_id = latest_heartbeat.host_id
+    WHERE jobs.status IN ('processing')
+      AND latest_heartbeat.created_at < ((now() at time zone 'utc') - zombie_threshold)
   LOOP
     PERFORM {SCHEMA_NAME}._set_job_zombie(zombie_id, p_fast_mode);
     zombie_count := zombie_count + 1;
@@ -49,15 +79,31 @@ DECLARE
   zombie_check_interval interval := '1 minute';
   p_zombie_count int;
 BEGIN
-
-  -- once per minute run a zombie check. This is marked in the database as a zombie
-  -- event, which has a zombie count value in its attributes.
-  IF NOT EXISTS (SELECT 1 FROM {SCHEMA_NAME}.events WHERE name='zombie' AND created_at > (now() at time zone 'utc') - zombie_check_interval) THEN
-    p_zombie_count := {SCHEMA_NAME}._zombie_check(p_fast_mode);
-    IF p_zombie_count > 0 THEN
-      INSERT INTO {SCHEMA_NAME}.events(name, host_id, attributes)
-        VALUES('zombie', {SCHEMA_NAME}._null_uuid(), jsonb_build_object('zombie_count', p_zombie_count));
-    END IF;
+  -- In order to properly throttle the zombie check we keep the latest zombie
+  -- check result in the database. If this is younger than 1 minute we do not
+  -- run the zombie check.
+  IF EXISTS (
+    SELECT 1 FROM {SCHEMA_NAME}.events
+    WHERE name='zombie'
+      AND created_at > (now() at time zone 'utc') - zombie_check_interval
+  ) THEN
+    RETURN;
   END IF;
+
+  -- Historically we do not need zombie_check results with 0 zombies. We do
+  -- write them, initially, for the throttling to be effective, but later on
+  -- we can remove them again. We only look for events younger then a 1 hour
+  -- threshold, for optimization reasons.
+
+  DELETE FROM {SCHEMA_NAME}.events
+    WHERE name='zombie'
+      AND created_at > (now() at time zone 'utc') - interval '1 hour'
+      AND attributes @> '{"zombie_count": 0}';
+  
+  -- run the zombie checker and keep the result.
+  p_zombie_count := {SCHEMA_NAME}._zombie_check(p_fast_mode);
+
+  INSERT INTO {SCHEMA_NAME}.events(name, host_id, attributes)
+    VALUES('zombie', {SCHEMA_NAME}._null_uuid(), jsonb_build_object('zombie_count', p_zombie_count));
 END;
 $$ LANGUAGE plpgsql;

data/lib/postjob/migrations/018_heartbeat.sql

@@ -12,17 +12,50 @@ DECLARE
   p_latest_zombie_event_id bigint;
   p_zombie_count int;
 BEGIN
-  -- We perform the zombie_check first. This should not make any difference,
-  -- functionality-wise, but helps us test this.
+  -- RAISE NOTICE '*** heartbeat % %', p_host_id, p_metrics;
+
+  -- We perform the zombie_check before we insert the heartbeats event. This
+  -- should not make any difference functionality-wise, but helps us building
+  -- tests for this feature..
+  --
+  -- Note: The zombie_check function throttles itself.
   PERFORM {SCHEMA_NAME}.zombie_check(p_fast_mode);
 
   IF NOT EXISTS (
       SELECT 1 FROM {SCHEMA_NAME}.events
-      WHERE (name,host_id)=('heartbeat', p_host_id) AND created_at > (now() at time zone 'utc') - interval '1 minute'
+      WHERE (name,host_id)=('heartbeat', p_host_id)
+        AND created_at > (now() at time zone 'utc') - interval '1 minute'
     )
   THEN
+    -- The code below is throttled to run only once per host and minute. 
     INSERT INTO {SCHEMA_NAME}.events(name, host_id, attributes)
       VALUES ('heartbeat', p_host_id, p_metrics);
+
+    -- This host is set to 'running' if it currently was stopped. This would
+    -- only happen if a host was manually stopped and then restarted again.
+    -- Note: we do not touch the status of a host during 'shutdown', since
+    -- even in this mode the is expected to send in heartbeats.
+    UPDATE {SCHEMA_NAME}.hosts
+      SET status='running' WHERE status='stopped' AND id=p_host_id;
+
+    -- Find hosts that are not stopped that don't have a heartbeat in the
+    -- last 5 minutes, and set those to 'stopped'.
+    UPDATE {SCHEMA_NAME}.hosts
+      SET status='stopped'
+      WHERE
+      id IN (
+        SELECT hosts.id
+        FROM {SCHEMA_NAME}.hosts hosts
+        LEFT JOIN (
+          SELECT id, host_id
+          FROM postjob.events events
+          WHERE name='heartbeat'
+            AND created_at > now() at time zone 'utc' - interval '5 minutes'
+        ) heartbeats ON hosts.id=heartbeats.host_id
+        WHERE status IN ('running', 'shutdown')
+          AND heartbeats.id IS NULL
+      );
+
   END IF;
 END;
 $$ LANGUAGE plpgsql;

data/lib/postjob/migrations/021_cron_jobs.sql

@@ -8,7 +8,7 @@ $$;
 
 --- define triggers to automatically restart cron jobs ------------------------
 
--- This method is called whenever a job's status changes. It enqueues a fresh 
+-- This method is called whenever a job's status changes. It enqueues a fresh
 
 --
 -- An event is created whenever a job's status changes.
@@ -33,24 +33,25 @@ BEGIN
   END IF;
 
   SELECT id INTO p_new_jonb_id FROM {SCHEMA_NAME}.enqueue(
-    NEW.last_worker_session_id,                                                     -- p_worker_session_id 
-    NEW.queue,                                                                      -- queue 
-    NEW.workflow,                                                                   -- workflow 
-    NEW.workflow_method,                                                            -- workflow_method 
-    NULL,                                                                           -- workflow_version 
-    NEW.args,                                                                       -- args 
-    NULL,                                                                           -- parent_id 
-    NEW.tags,                                                                       -- tags 
+    NEW.last_worker_session_id,                                                     -- p_worker_session_id
+    NEW.queue,                                                                      -- queue
+    NEW.workflow,                                                                   -- workflow
+    NEW.workflow_method,                                                            -- workflow_method
+    NULL,                                                                           -- workflow_version
+    NEW.args,                                                                       -- args
+    NULL,                                                                           -- parent_id
+    NEW.tags,                                                                       -- tags
     NEW.max_attempts,                                                               -- max_attempts
     (EXTRACT(EPOCH FROM NEW.timing_out_at) - EXTRACT(EPOCH FROM NEW.created_at)),   -- timeout
     NEW.cron_interval,
-    NEW.is_sticky
+    NEW.is_sticky,
+    NEW.is_greedy
   );
 
   UPDATE {SCHEMA_NAME}.postjobs
   SET next_run_at = now() at time zone 'utc' + NEW.cron_interval * interval '1 second'
   WHERE id=p_new_jonb_id;
-  
+
   RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;

data/lib/postjob/migrations.rb

@@ -47,7 +47,7 @@ module Postjob
 
     def run_migration_sql(file)
       sql = File.read(file)
-      sql.gsub!(/\{([^\}]+)\}/) { |_| const_get(Regexp.last_match(1)) }
+      sql.gsub!(/\{([_A-Za-z0-9+]+)\}/) { |_| const_get(Regexp.last_match(1)) }
       SQL.exec sql
     end
   end

data/lib/postjob/queue/notifications.rb

@@ -1,4 +1,5 @@
-#
+# rubocop:disable Metrics/PerceivedComplexity
+
 # The Postjob::Queue manages enqueueing and fetching jobs from a job queue.
 module Postjob::Queue::Notifications
   extend self
@@ -8,16 +9,21 @@ module Postjob::Queue::Notifications
   SCHEMA_NAME = ::Postjob::Queue::SCHEMA_NAME
   MAX_WAIT_TIME = 120
 
-  def wait_for_new_job(worker_session_id, queue:)
+  def wait_for_new_job(worker_session_id, queues:)
     started_at = Time.now
 
     start_listening
 
     # Determine when the next job is up. If we don't have a next job within MAX_WAIT_TIME
     # we wake up regardless.
-    wait_time = time_to_next_job(worker_session_id, queue: queue)
+    wait_time = time_to_next_job(worker_session_id, queues: queues)
     return if wait_time && wait_time <= 0
 
+    if !wait_time && ::Postjob::Queue.should_shutdown?(worker_session_id)
+      Postjob.logger.warn "Shutting down runner: host is set to 'shutdown'"
+      return :shutdown
+    end
+
     wait_time = MAX_WAIT_TIME if !wait_time || wait_time > MAX_WAIT_TIME
     Postjob.logger.debug "postjob: waiting for notification for up to #{wait_time} seconds"
     Simple::SQL.wait_for_notify(wait_time)
@@ -30,6 +36,9 @@ module Postjob::Queue::Notifications
     end
 
     Postjob.logger.debug "postjob: awoke after #{format('%.03f secs', (Time.now - started_at))}"
+  rescue Interrupt
+    Postjob.logger.info "postjob: shutdown after receiving Interrupt"
+    :shutdown
   end
 
   private
@@ -43,11 +52,10 @@ module Postjob::Queue::Notifications
 
   # returns the maximum number of seconds to wait until the
   # next runnable or timeoutable job comes up.
-  def time_to_next_job(worker_session_id, queue:)
+  def time_to_next_job(worker_session_id, queues:)
     expect! worker_session_id => /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
-    expect! queue => [ String, Array, nil ]
+    expect! queues => Array
 
-    queue = Array(queue)
-    Simple::SQL.ask "SELECT * FROM #{SCHEMA_NAME}.time_to_next_job($1::uuid, $2)", worker_session_id, queue
+    Simple::SQL.ask "SELECT * FROM #{SCHEMA_NAME}.time_to_next_job($1::uuid, $2)", worker_session_id, queues
   end
 end

data/lib/postjob/queue.rb

@@ -91,17 +91,27 @@ module Postjob::Queue
     Simple::SQL.ask sql, workflow, Encoder.encode(args)
   end
 
+  # Asks the database whether this session should be shut down.
+  def should_shutdown?(worker_session_id)
+    SQL.ask "SELECT #{SCHEMA_NAME}.session_should_shutdown($1::uuid)", worker_session_id
+  end
+
   def set_job_result(worker_session_id, job, value, version:)
+    expect! worker_session_id => UUID_REGEXP
+
     value = Encoder.encode([value]) unless value.nil?
     SQL.ask "SELECT #{SCHEMA_NAME}.set_job_result($1::uuid, $2, $3, $4)", worker_session_id, job.id, value, version
   end
 
   def set_job_pending(worker_session_id, job, version:)
+    expect! worker_session_id => UUID_REGEXP
+
     SQL.ask "SELECT #{SCHEMA_NAME}.set_job_pending($1::uuid, $2, $3)", worker_session_id, job.id, version
   end
 
   def set_job_error(worker_session_id, job, error, error_message, error_backtrace = nil, status:, version:)
     expect! status => [ :failed, :err, :timeout ]
+    expect! worker_session_id => UUID_REGEXP
 
     SQL.ask "SELECT #{SCHEMA_NAME}.set_job_error($1::uuid, $2, $3, $4, $5, $6, $7, $8)",
       worker_session_id, job.id, error, error_message, Encoder.encode(error_backtrace), status, version, Postjob.fast_mode
@@ -164,13 +174,12 @@ module Postjob::Queue
 
   UUID_REGEXP = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
 
-  def checkout(worker_session_id, queue:)
+  def checkout(worker_session_id, queues:)
     expect! worker_session_id => UUID_REGEXP
-    expect! queue => [ nil, Array, String ]
+    expect! queues => [ nil, Array ]
 
-    queue = Array(queue) if queue
     SQL.ask "SELECT * FROM #{SCHEMA_NAME}.checkout($1::uuid, $2::boolean, $3)",
-      worker_session_id, Postjob.fast_mode, queue, into: Job
+      worker_session_id, Postjob.fast_mode, queues, into: Job
   end
 
   def find_or_create_token(job)
@@ -184,18 +193,22 @@ module Postjob::Queue
   # -- registers a host -------------------------------------------------------
 
   # returns the host id
-  def host_register(attributes)
+  def host_register(attributes, host_id:)
     expect! attributes => [ nil, Hash ]
-    Simple::SQL.ask "SELECT postjob.host_register($1)", JSON.generate(attributes)
+    expect! host_id => [ nil, UUID_REGEXP ]
+
+    Simple::SQL.ask "SELECT postjob.host_register($1, $2::uuid)", JSON.generate(attributes), host_id
   end
 
   # starts a session
   WorkerSession = ::Postjob::WorkerSession
 
-  def start_worker_session(workflows_with_versions, host_id:)
+  def worker_session_start(workflows_with_versions, host_id:, queues:)
     expect! host_id => UUID_REGEXP
+    expect! queues => Array
+    expect! queues.first => String
 
-    Simple::SQL.ask "SELECT * FROM postjob.worker_session_start($1::uuid, $2)", host_id, workflows_with_versions, into: ::Postjob::WorkerSession
+    Simple::SQL.ask "SELECT * FROM postjob.worker_session_start($1::uuid, $2, $3)", host_id, workflows_with_versions, queues, into: ::Postjob::WorkerSession
   end
 
   # sends in a heartbeat

data/lib/postjob/runner.rb

@@ -37,7 +37,7 @@ module Postjob::Runner
     # returns a subjob within the current job, for a +runner+
     # description and +args+.
     def async(workflow, *args, timeout: nil, max_attempts: nil, queue: nil)
-      worker_session_id = Postjob.current_worker_session.id
+      worker_session_id = Postjob.current_session_id
 
       queue = current_job.queue if queue.nil?
 

data/lib/postjob/worker_session.rb

@@ -8,13 +8,13 @@ require "tools/heartbeat"
 class Postjob::WorkerSession < Postjob::Record
   class << self
     # Starts a worker session.
-    def start!(workflows_with_versions)
+    def start!(workflows_with_versions, heartbeat: true, queues:)
       host_id = ::Postjob.host_id
-      worker_session = ::Postjob::Queue.start_worker_session(workflows_with_versions, host_id: host_id)
+      worker_session = ::Postjob::Queue.worker_session_start(workflows_with_versions, host_id: host_id, queues: queues)
 
       Postjob.logger.info "Starting worker_session #{worker_session.inspect}"
 
-      start_heartbeat_monitor(host_id)
+      start_heartbeat_monitor(host_id) if heartbeat
       worker_session
     end
 
@@ -48,13 +48,17 @@ class Postjob::WorkerSession < Postjob::Record
   attr_reader :workflows
   attr_reader :attributes
   attr_reader :created_at
+  attr_reader :queues
 
   def to_s
     "Session##{id}"
   end
 
   def inspect
-    versionized_workflows = workflows.grep(/\d$/)
-    "<Session##{id} w/host_id: #{host_id}, client_socket: #{client_socket}, #{versionized_workflows.count} workflows>"
+    # [TODO] - grepping workflows by /\d$/ to only count workflows with a version number is a bit hackish.
+    workflow_count = self.workflows.grep(/\d$/)
+    queues         = self.queues.map(&:inspect).join(", ")
+
+    "<Session##{id} w/host_id: #{host_id}, queues: #{queues}, client_socket: #{client_socket}, #{workflow_count} workflows>"
   end
 end