The callback was registered and the object was collected

# Self-authored for the EML case corpus (no external origin). The event registry
# is typed, tested, and delivers every event it dispatches with no recorded
# failures. What the delivery rate is a rate over is computed below.
#
# The registry is well built and the weak reference in it is not an oversight.
# An earlier version held subscribers strongly and leaked four point two
# gigabytes over a weekend, because a registration outlives the thing that made
# it more often than anyone expects. The weak reference was a deliberate fix,
# reviewed, and it ended the leak.
#
# A weak reference lets the subscriber be collected. When the registry is the
# only thing pointing at a subscriber, the subscriber is unreachable by
# definition, so it goes, and its callback stops being called.
#
# The delivery rate counts events delivered to live subscribers.

40000000 => events_dispatched
0 => delivery_failures_recorded
2400 => registrations
190 => registrations_reachable_only_from_the_registry
190 => of_those_collected_within_one_cycle
26000 => events_a_day_those_registrations_would_have_received
0 => events_counted_as_undelivered
4200 => megabytes_leaked_by_the_strong_reference_version

registrations - registrations_reachable_only_from_the_registry => registrations_held_by_something_else
int(registrations_reachable_only_from_the_registry * 10000 / registrations) => silently_gone_per_myriad

"events dispatched               : " + str(events_dispatched) ^0
"delivery failures recorded      : " + str(delivery_failures_recorded) ^0
"events counted as undelivered   : " + str(events_counted_as_undelivered) ^0
"" ^0
"registrations                   : " + str(registrations) ^0
"  held by something else        : " + str(registrations_held_by_something_else) ^0
"  reachable only from the registry : " + str(registrations_reachable_only_from_the_registry) ^0
"  of those, collected           : " + str(of_those_collected_within_one_cycle) ^0
"  share                         : " + str(silently_gone_per_myriad) + " per ten thousand" ^0
"events a day they would have received : " + str(events_a_day_those_registrations_would_have_received) ^0
"" ^0
"megabytes leaked by the earlier version : " + str(megabytes_leaked_by_the_strong_reference_version) ^0
"" ^0

# ---- what the registry verified ----

"the event registry" ^0
"  registration : typed, so a handler cannot mismatch its" ^0
"    event" ^0
"  delivery     : at least once to every live subscriber" ^0
"  events dispatched : " + str(events_dispatched) ^0
"  delivery failures : " + str(delivery_failures_recorded) ^0
"  the weak reference : a reviewed fix for a real leak of" ^0
"    " + str(megabytes_leaked_by_the_strong_reference_version) + " megabytes" ^0
"  verdict : DELIVERED" ^0
"" ^0
"  the weak reference solved the problem it was chosen for" ^0
"  and it was the right problem to solve" ^0
"" ^0

# ---- what the delivery rate ranges over ----

"the measurement" ^0
"  numerator   : events delivered" ^0
"  denominator : events dispatched to live subscribers" ^0
"  what happens when a subscriber is collected : it leaves" ^0
"    the denominator" ^0
"  so a lost subscriber moves : both terms, together" ^0
"  the rate after losing one : unchanged" ^0
"" ^0
"  the failure and the count of opportunities are the same" ^0
"  event, so no ratio built from them can move" ^0
"" ^0
# ---- which registrations disappear ----

# Not a random sample. A subscriber held by a long-lived component survives; a
# subscriber constructed inside a function, registered, and returned from is
# exactly the one nothing else points at, and that is the common shape in the
# call sites that read as correct.
"which subscribers are collected" ^0
"  held by a long-lived component : survives" ^0
"  stored in a field by its owner : survives" ^0
"  constructed, registered, and not otherwise kept : gone" ^0
"  is that shape a mistake at the call site : it reads as" ^0
"    correct, and it compiles" ^0
"  registrations of that shape : " + str(registrations_reachable_only_from_the_registry) ^0
"" ^0

# ---- what a subscriber observes ----

"from inside the subscribing code" ^0
"  registration returned successfully : yes" ^0
"  an error at any point              : none" ^0
"  events arriving                    : some, then none" ^0
"  a log line at the moment it stops  : none, because" ^0
"    nothing happened; an object became unreachable" ^0
"  how it is usually found : someone notices a feature" ^0
"    stopped working, weeks later" ^0
"" ^0

# ---- null control ----

# The same registry, holding the subscriber strongly and returning a handle
# whose disposal is the only way to unregister. Lifetime becomes a thing the
# caller states rather than a thing the collector infers.
0 => nc_registrations_collected_while_registered
0 => nc_megabytes_leaked

"null control - a strong reference and an explicit handle" ^0
"  delivery failures : " + str(delivery_failures_recorded) + ", unchanged" ^0
"  registrations collected while registered : " + str(nc_registrations_collected_while_registered) ^0
"  megabytes leaked : " + str(nc_megabytes_leaked) + ", because unregistering is now a step" ^0
"    a caller takes rather than a consequence it earns" ^0
"  the registry did not get more reliable; the lifetime of a" ^0
"  subscription stopped being inferred from reachability" ^0
"" ^0

# ---- the rule ----

"what a perfect delivery rate guarantees" ^0
"  every event reached every live subscriber : exactly, and" ^0
"    over " + str(events_dispatched) + " events" ^0
"  every subscriber received its events       : not" ^0
"    addressed; a subscriber that is gone is not counted" ^0
"    as a subscriber that was missed" ^0
"" ^0
"a rate cannot see a failure that removes its own denominator;" ^0
"the number to watch is not the ratio but the count of" ^0
"registrations that stopped receiving, which requires" ^0
"remembering that they existed" ^0
"" ^0

"The registry is typed and delivers everything it dispatches - " + str(events_dispatched) + " events," ^0
str(delivery_failures_recorded) + " failures - and its weak reference was a reviewed fix for a real " + str(megabytes_leaked_by_the_strong_reference_version) ^0
"megabyte leak. A collected subscriber leaves the denominator with the event it" ^0
"missed, so " + str(registrations_reachable_only_from_the_registry) + " of " + str(registrations) + " registrations - " + str(silently_gone_per_myriad) + " per ten thousand - stopped" ^0
"receiving " + str(events_a_day_those_registrations_would_have_received) + " events a day, counted as " + str(events_counted_as_undelivered) + " undelivered." ^0

events_dispatched = 40000000
delivery_failures_recorded = 0
registrations = 2400
registrations_reachable_only_from_the_registry = 190
of_those_collected_within_one_cycle = 190
events_a_day_those_registrations_would_have_received = 26000
events_counted_as_undelivered = 0
megabytes_leaked_by_the_strong_reference_version = 4200
registrations_held_by_something_else = registrations - registrations_reachable_only_from_the_registry
silently_gone_per_myriad = int(registrations_reachable_only_from_the_registry * 10000 / registrations)
print("events dispatched               : " + str(events_dispatched))
print("delivery failures recorded      : " + str(delivery_failures_recorded))
print("events counted as undelivered   : " + str(events_counted_as_undelivered))
print("")
print("registrations                   : " + str(registrations))
print("  held by something else        : " + str(registrations_held_by_something_else))
print("  reachable only from the registry : " + str(registrations_reachable_only_from_the_registry))
print("  of those, collected           : " + str(of_those_collected_within_one_cycle))
print("  share                         : " + str(silently_gone_per_myriad) + " per ten thousand")
print("events a day they would have received : " + str(events_a_day_those_registrations_would_have_received))
print("")
print("megabytes leaked by the earlier version : " + str(megabytes_leaked_by_the_strong_reference_version))
print("")
print("the event registry")
print("  registration : typed, so a handler cannot mismatch its")
print("    event")
print("  delivery     : at least once to every live subscriber")
print("  events dispatched : " + str(events_dispatched))
print("  delivery failures : " + str(delivery_failures_recorded))
print("  the weak reference : a reviewed fix for a real leak of")
print("    " + str(megabytes_leaked_by_the_strong_reference_version) + " megabytes")
print("  verdict : DELIVERED")
print("")
print("  the weak reference solved the problem it was chosen for")
print("  and it was the right problem to solve")
print("")
print("the measurement")
print("  numerator   : events delivered")
print("  denominator : events dispatched to live subscribers")
print("  what happens when a subscriber is collected : it leaves")
print("    the denominator")
print("  so a lost subscriber moves : both terms, together")
print("  the rate after losing one : unchanged")
print("")
print("  the failure and the count of opportunities are the same")
print("  event, so no ratio built from them can move")
print("")
print("which subscribers are collected")
print("  held by a long-lived component : survives")
print("  stored in a field by its owner : survives")
print("  constructed, registered, and not otherwise kept : gone")
print("  is that shape a mistake at the call site : it reads as")
print("    correct, and it compiles")
print("  registrations of that shape : " + str(registrations_reachable_only_from_the_registry))
print("")
print("from inside the subscribing code")
print("  registration returned successfully : yes")
print("  an error at any point              : none")
print("  events arriving                    : some, then none")
print("  a log line at the moment it stops  : none, because")
print("    nothing happened; an object became unreachable")
print("  how it is usually found : someone notices a feature")
print("    stopped working, weeks later")
print("")
nc_registrations_collected_while_registered = 0
nc_megabytes_leaked = 0
print("null control - a strong reference and an explicit handle")
print("  delivery failures : " + str(delivery_failures_recorded) + ", unchanged")
print("  registrations collected while registered : " + str(nc_registrations_collected_while_registered))
print("  megabytes leaked : " + str(nc_megabytes_leaked) + ", because unregistering is now a step")
print("    a caller takes rather than a consequence it earns")
print("  the registry did not get more reliable; the lifetime of a")
print("  subscription stopped being inferred from reachability")
print("")
print("what a perfect delivery rate guarantees")
print("  every event reached every live subscriber : exactly, and")
print("    over " + str(events_dispatched) + " events")
print("  every subscriber received its events       : not")
print("    addressed; a subscriber that is gone is not counted")
print("    as a subscriber that was missed")
print("")
print("a rate cannot see a failure that removes its own denominator;")
print("the number to watch is not the ratio but the count of")
print("registrations that stopped receiving, which requires")
print("remembering that they existed")
print("")
print("The registry is typed and delivers everything it dispatches - " + str(events_dispatched) + " events,")
print(str(delivery_failures_recorded) + " failures - and its weak reference was a reviewed fix for a real " + str(megabytes_leaked_by_the_strong_reference_version))
print("megabyte leak. A collected subscriber leaves the denominator with the event it")
print("missed, so " + str(registrations_reachable_only_from_the_registry) + " of " + str(registrations) + " registrations - " + str(silently_gone_per_myriad) + " per ten thousand - stopped")
print("receiving " + str(events_a_day_those_registrations_would_have_received) + " events a day, counted as " + str(events_counted_as_undelivered) + " undelivered.")

events dispatched               : 40000000
delivery failures recorded      : 0
events counted as undelivered   : 0

registrations                   : 2400
  held by something else        : 2210
  reachable only from the registry : 190
  of those, collected           : 190
  share                         : 791 per ten thousand
events a day they would have received : 26000

megabytes leaked by the earlier version : 4200

the event registry
  registration : typed, so a handler cannot mismatch its
    event
  delivery     : at least once to every live subscriber
  events dispatched : 40000000
  delivery failures : 0
  the weak reference : a reviewed fix for a real leak of
    4200 megabytes
  verdict : DELIVERED

  the weak reference solved the problem it was chosen for
  and it was the right problem to solve

the measurement
  numerator   : events delivered
  denominator : events dispatched to live subscribers
  what happens when a subscriber is collected : it leaves
    the denominator
  so a lost subscriber moves : both terms, together
  the rate after losing one : unchanged

  the failure and the count of opportunities are the same
  event, so no ratio built from them can move

which subscribers are collected
  held by a long-lived component : survives
  stored in a field by its owner : survives
  constructed, registered, and not otherwise kept : gone
  is that shape a mistake at the call site : it reads as
    correct, and it compiles
  registrations of that shape : 190

from inside the subscribing code
  registration returned successfully : yes
  an error at any point              : none
  events arriving                    : some, then none
  a log line at the moment it stops  : none, because
    nothing happened; an object became unreachable
  how it is usually found : someone notices a feature
    stopped working, weeks later

null control - a strong reference and an explicit handle
  delivery failures : 0, unchanged
  registrations collected while registered : 0
  megabytes leaked : 0, because unregistering is now a step
    a caller takes rather than a consequence it earns
  the registry did not get more reliable; the lifetime of a
  subscription stopped being inferred from reachability

what a perfect delivery rate guarantees
  every event reached every live subscriber : exactly, and
    over 40000000 events
  every subscriber received its events       : not
    addressed; a subscriber that is gone is not counted
    as a subscriber that was missed

a rate cannot see a failure that removes its own denominator;
the number to watch is not the ratio but the count of
registrations that stopped receiving, which requires
remembering that they existed

The registry is typed and delivers everything it dispatches - 40000000 events,
0 failures - and its weak reference was a reviewed fix for a real 4200
megabyte leak. A collected subscriber leaves the denominator with the event it
missed, so 190 of 2400 registrations - 791 per ten thousand - stopped
receiving 26000 events a day, counted as 0 undelivered.

Trace event types