The queue drained and the oldest item was never served

# Self-authored for the EML case corpus (no external origin). A work queue is
# drained continuously, its depth is stable, and throughput matches arrivals.
# What happens to the item at the bottom is computed below.
#
# Serving the newest item first is correct here and it was chosen with a reason.
# These are interactive requests: a caller that has been waiting eight seconds
# has usually gone, and the response to it is thrown away, so spending a worker
# on the freshest item converts the same throughput into more answered callers.
# Under a burst it is measurably better than the alternative.
#
# A queue's depth is a level. It says how many are waiting, not which ones, and
# a level can hold perfectly still while its contents never turn over.
#
# The oldest item is the one every policy here agrees to postpone.

400 => arrivals_per_second
400 => service_per_second
1200 => queue_depth
8 => abandon_after_seconds

"arrivals per second : " + str(arrivals_per_second) ^0
"served per second   : " + str(service_per_second) ^0
"queue depth         : " + str(queue_depth) + ", stable" ^0
"abandon after       : " + str(abandon_after_seconds) + " seconds" ^0
"" ^0

# ---- the health of the queue ----

"the queue's own numbers" ^0
"  arrivals and departures balanced : yes, " + str(arrivals_per_second) + " each" ^0
"  depth trend                      : flat" ^0
"  overflow events                  : 0" ^0
"  items dropped by the queue       : 0" ^0
"  workers idle                     : 0" ^0
"" ^0
"  a queue that is not growing and not dropping" ^0
"" ^0

# ---- what the depth does not say ----

int(queue_depth / service_per_second) => nominal_wait_seconds

"if the queue were served oldest first" ^0
"  wait for any item : " + str(nominal_wait_seconds) + " seconds" ^0
"  items abandoned   : 0, since " + str(nominal_wait_seconds) + " is under " + str(abandon_after_seconds) ^0
"" ^0
"under newest-first, at the same depth and the same rates" ^0
"  wait for a newly arrived item : near zero" ^0
"  wait for the item at the bottom : it is passed over by every" ^0
"    arrival, and " + str(arrivals_per_second) + " arrive each second" ^0
"" ^0

# ---- the bottom of the queue over time ----

"second   arrivals since   served   position from the bottom" ^0
for s in [1:5]:
    s * arrivals_per_second => arrived
    s * service_per_second => served
    "  " + str(s) + "        " + str(arrived) + "             " + str(served) + "      " + str(queue_depth) ^0
"" ^0
"  the bottom item's position does not improve, because" ^0
"  arrivals and service are equal and service starts at the top" ^0
"" ^0

# ---- what it costs, per second ----

int(queue_depth * 100 / arrivals_per_second) => stuck_seconds_hundredths

"items that will never be served while the rate holds : " + str(queue_depth) ^0
"  that is " + str(int(stuck_seconds_hundredths / 100)) + " point " + str(stuck_seconds_hundredths % 100) + " seconds of arrivals" ^0
"  each of them a caller waiting past " + str(abandon_after_seconds) + " seconds" ^0
"" ^0

queue_depth => abandoned_total
int(abandoned_total * 10000 / (arrivals_per_second * 60)) => abandoned_per_myriad_per_minute

"  callers abandoned                : " + str(abandoned_total) ^0
"  arrivals per minute              : " + str(arrivals_per_second * 60) ^0
"  abandonment rate                 : " + str(abandoned_per_myriad_per_minute) + " per ten thousand" ^0
"" ^0

# ---- what each dashboard shows ----

"metric              value        reads as" ^0
"  queue depth         " + str(queue_depth) + "         stable, healthy" ^0
"  throughput          " + str(service_per_second) + "/s        matching demand" ^0
"  worker utilisation  100 percent  fully used" ^0
"  mean wait           near zero    excellent" ^0
"  oldest item age     not measured  -" ^0
"" ^0
"  the mean wait is near zero and it is the true mean:" ^0
"  almost every served item was served immediately" ^0
"" ^0

# ---- the control ----
#
# Newest-first, against what it was chosen for. Under a burst it answers more
# callers than oldest-first, because it does not spend workers on responses
# nobody is waiting for any more.

"control - is newest-first the better policy here" ^0
"  callers answered under newest-first, per second : " + str(service_per_second) ^0
"  callers answered under oldest-first during a burst : fewer," ^0
"    because some completions land after the caller left" ^0
"  wasted completions under newest-first : 0" ^0
"  defects in the policy : 0" ^0
"" ^0
"  the policy is right about the thing it optimises" ^0
"" ^0

# ---- the null control ----
#
# The same policy, same workers, same abandon threshold, when service exceeds
# arrivals. The queue empties, so the bottom is reached, and newest-first costs
# nothing at all.

520 => nc_service_per_second
nc_service_per_second - arrivals_per_second => nc_drain_per_second
int(queue_depth / nc_drain_per_second) => nc_seconds_to_empty

"null control - the same policy with spare service capacity" ^0
"  served per second : " + str(nc_service_per_second) ^0
"  net drain         : " + str(nc_drain_per_second) + " per second" ^0
"  seconds to empty  : " + str(nc_seconds_to_empty) ^0
"  items never served : 0" ^0
"  same policy, same queue, same threshold" ^0
"  the ordering only matters while the queue does not empty" ^0
"" ^0

# ---- the rule ----

"what a stable queue depth is evidence of" ^0
"  arrivals equal departures : yes, exactly" ^0
"  no item is stuck          : not implied, and here it is false" ^0
"  the level is a count, and a count has no identity in it" ^0
"" ^0
"the number that is missing is the age of the oldest item," ^0
"which under this policy is the only one a depth cannot bound" ^0
"" ^0

"The queue is balanced at " + str(arrivals_per_second) + " arrivals and " + str(service_per_second) + " completions a second, with 0" ^0
"overflows, 0 drops, 0 idle workers and a mean wait near zero, and newest-first" ^0
"is the policy that answers the most callers under a burst. At a steady depth of" ^0
str(queue_depth) + ", the items below the arrival point are passed over by all " + str(arrivals_per_second) + " arrivals" ^0
"each second, so " + str(abandoned_total) + " callers - " + str(abandoned_per_myriad_per_minute) + " per ten thousand a minute - wait past" ^0
str(abandon_after_seconds) + " seconds and leave, while every dashboard above reads healthy." ^0

arrivals_per_second = 400
service_per_second = 400
queue_depth = 1200
abandon_after_seconds = 8
print("arrivals per second : " + str(arrivals_per_second))
print("served per second   : " + str(service_per_second))
print("queue depth         : " + str(queue_depth) + ", stable")
print("abandon after       : " + str(abandon_after_seconds) + " seconds")
print("")
print("the queue's own numbers")
print("  arrivals and departures balanced : yes, " + str(arrivals_per_second) + " each")
print("  depth trend                      : flat")
print("  overflow events                  : 0")
print("  items dropped by the queue       : 0")
print("  workers idle                     : 0")
print("")
print("  a queue that is not growing and not dropping")
print("")
nominal_wait_seconds = int(queue_depth / service_per_second)
print("if the queue were served oldest first")
print("  wait for any item : " + str(nominal_wait_seconds) + " seconds")
print("  items abandoned   : 0, since " + str(nominal_wait_seconds) + " is under " + str(abandon_after_seconds))
print("")
print("under newest-first, at the same depth and the same rates")
print("  wait for a newly arrived item : near zero")
print("  wait for the item at the bottom : it is passed over by every")
print("    arrival, and " + str(arrivals_per_second) + " arrive each second")
print("")
print("second   arrivals since   served   position from the bottom")
for s in range(1, 6):
    arrived = s * arrivals_per_second
    served = s * service_per_second
    print("  " + str(s) + "        " + str(arrived) + "             " + str(served) + "      " + str(queue_depth))
print("")
print("  the bottom item's position does not improve, because")
print("  arrivals and service are equal and service starts at the top")
print("")
stuck_seconds_hundredths = int(queue_depth * 100 / arrivals_per_second)
print("items that will never be served while the rate holds : " + str(queue_depth))
print("  that is " + str(int(stuck_seconds_hundredths / 100)) + " point " + str(stuck_seconds_hundredths % 100) + " seconds of arrivals")
print("  each of them a caller waiting past " + str(abandon_after_seconds) + " seconds")
print("")
abandoned_total = queue_depth
abandoned_per_myriad_per_minute = int(abandoned_total * 10000 / (arrivals_per_second * 60))
print("  callers abandoned                : " + str(abandoned_total))
print("  arrivals per minute              : " + str(arrivals_per_second * 60))
print("  abandonment rate                 : " + str(abandoned_per_myriad_per_minute) + " per ten thousand")
print("")
print("metric              value        reads as")
print("  queue depth         " + str(queue_depth) + "         stable, healthy")
print("  throughput          " + str(service_per_second) + "/s        matching demand")
print("  worker utilisation  100 percent  fully used")
print("  mean wait           near zero    excellent")
print("  oldest item age     not measured  -")
print("")
print("  the mean wait is near zero and it is the true mean:")
print("  almost every served item was served immediately")
print("")
print("control - is newest-first the better policy here")
print("  callers answered under newest-first, per second : " + str(service_per_second))
print("  callers answered under oldest-first during a burst : fewer,")
print("    because some completions land after the caller left")
print("  wasted completions under newest-first : 0")
print("  defects in the policy : 0")
print("")
print("  the policy is right about the thing it optimises")
print("")
nc_service_per_second = 520
nc_drain_per_second = nc_service_per_second - arrivals_per_second
nc_seconds_to_empty = int(queue_depth / nc_drain_per_second)
print("null control - the same policy with spare service capacity")
print("  served per second : " + str(nc_service_per_second))
print("  net drain         : " + str(nc_drain_per_second) + " per second")
print("  seconds to empty  : " + str(nc_seconds_to_empty))
print("  items never served : 0")
print("  same policy, same queue, same threshold")
print("  the ordering only matters while the queue does not empty")
print("")
print("what a stable queue depth is evidence of")
print("  arrivals equal departures : yes, exactly")
print("  no item is stuck          : not implied, and here it is false")
print("  the level is a count, and a count has no identity in it")
print("")
print("the number that is missing is the age of the oldest item,")
print("which under this policy is the only one a depth cannot bound")
print("")
print("The queue is balanced at " + str(arrivals_per_second) + " arrivals and " + str(service_per_second) + " completions a second, with 0")
print("overflows, 0 drops, 0 idle workers and a mean wait near zero, and newest-first")
print("is the policy that answers the most callers under a burst. At a steady depth of")
print(str(queue_depth) + ", the items below the arrival point are passed over by all " + str(arrivals_per_second) + " arrivals")
print("each second, so " + str(abandoned_total) + " callers - " + str(abandoned_per_myriad_per_minute) + " per ten thousand a minute - wait past")
print(str(abandon_after_seconds) + " seconds and leave, while every dashboard above reads healthy.")

arrivals per second : 400
served per second   : 400
queue depth         : 1200, stable
abandon after       : 8 seconds

the queue's own numbers
  arrivals and departures balanced : yes, 400 each
  depth trend                      : flat
  overflow events                  : 0
  items dropped by the queue       : 0
  workers idle                     : 0

  a queue that is not growing and not dropping

if the queue were served oldest first
  wait for any item : 3 seconds
  items abandoned   : 0, since 3 is under 8

under newest-first, at the same depth and the same rates
  wait for a newly arrived item : near zero
  wait for the item at the bottom : it is passed over by every
    arrival, and 400 arrive each second

second   arrivals since   served   position from the bottom
  1        400             400      1200
  2        800             800      1200
  3        1200             1200      1200
  4        1600             1600      1200
  5        2000             2000      1200

  the bottom item's position does not improve, because
  arrivals and service are equal and service starts at the top

items that will never be served while the rate holds : 1200
  that is 3 point 0 seconds of arrivals
  each of them a caller waiting past 8 seconds

  callers abandoned                : 1200
  arrivals per minute              : 24000
  abandonment rate                 : 500 per ten thousand

metric              value        reads as
  queue depth         1200         stable, healthy
  throughput          400/s        matching demand
  worker utilisation  100 percent  fully used
  mean wait           near zero    excellent
  oldest item age     not measured  -

  the mean wait is near zero and it is the true mean:
  almost every served item was served immediately

control - is newest-first the better policy here
  callers answered under newest-first, per second : 400
  callers answered under oldest-first during a burst : fewer,
    because some completions land after the caller left
  wasted completions under newest-first : 0
  defects in the policy : 0

  the policy is right about the thing it optimises

null control - the same policy with spare service capacity
  served per second : 520
  net drain         : 120 per second
  seconds to empty  : 10
  items never served : 0
  same policy, same queue, same threshold
  the ordering only matters while the queue does not empty

what a stable queue depth is evidence of
  arrivals equal departures : yes, exactly
  no item is stuck          : not implied, and here it is false
  the level is a count, and a count has no identity in it

the number that is missing is the age of the oldest item,
which under this policy is the only one a depth cannot bound

The queue is balanced at 400 arrivals and 400 completions a second, with 0
overflows, 0 drops, 0 idle workers and a mean wait near zero, and newest-first
is the policy that answers the most callers under a burst. At a steady depth of
1200, the items below the arrival point are passed over by all 400 arrivals
each second, so 1200 callers - 500 per ten thousand a minute - wait past
8 seconds and leave, while every dashboard above reads healthy.

Trace event types