The average was weighted and the weights were stale

# Self-authored for the EML case corpus (no external origin). The fleet latency
# is a weighted average, which is the right shape, and the arithmetic is exact.
# What it reports is computed below.
#
# Weighting is the correct choice and someone argued for it. An unweighted mean
# over five regions treats a region serving two percent of traffic as equal to
# one serving a third, which is how a small region's noise moves a headline
# number. The weighted form fixes that, the weights sum to one, and the
# computation has no rounding error worth naming.
#
# The weights are a config file. They were correct when written; traffic moved,
# and nothing recomputes them, because a weight is an input and inputs do not
# have freshness checks.
#
# The region carrying a third of the traffic is weighted at nine percent.

900 => weight_of_the_heavy_region_per_myriad
3400 => actual_share_of_the_heavy_region_per_myriad
890 => latency_of_the_heavy_region_ms
120 => latency_of_the_others_ms
96 => days_since_the_weights_were_updated
5 => regions

10000 - weight_of_the_heavy_region_per_myriad => weight_of_the_others_per_myriad
10000 - actual_share_of_the_heavy_region_per_myriad => actual_share_of_the_others_per_myriad

int((weight_of_the_heavy_region_per_myriad * latency_of_the_heavy_region_ms + weight_of_the_others_per_myriad * latency_of_the_others_ms) / 10000) => reported_ms
int((actual_share_of_the_heavy_region_per_myriad * latency_of_the_heavy_region_ms + actual_share_of_the_others_per_myriad * latency_of_the_others_ms) / 10000) => experienced_ms
experienced_ms - reported_ms => understated_by_ms

"regions                        : " + str(regions) ^0
"weight of the heavy region     : " + str(weight_of_the_heavy_region_per_myriad) + " per ten thousand" ^0
"its actual share of traffic    : " + str(actual_share_of_the_heavy_region_per_myriad) + " per ten thousand" ^0
"days since the weights changed : " + str(days_since_the_weights_were_updated) ^0
"" ^0
"latency there, ms              : " + str(latency_of_the_heavy_region_ms) ^0
"latency elsewhere, ms          : " + str(latency_of_the_others_ms) ^0
"reported average, ms           : " + str(reported_ms) ^0
"experienced average, ms        : " + str(experienced_ms) ^0
"understated by, ms             : " + str(understated_by_ms) ^0
"" ^0

# ---- what the weighting fixed ----

"why the average is weighted" ^0
"  unweighted mean over " + str(regions) + " regions : treats a two" ^0
"    percent region as equal to a third" ^0
"  weights sum to one   : yes" ^0
"  rounding error       : none worth naming" ^0
"  argued for by        : someone who had watched a small" ^0
"    region's noise move the headline" ^0
"  verdict              : CORRECTLY WEIGHTED" ^0
"" ^0
"  the shape is right and switching back would be worse" ^0
"" ^0

# ---- what a weight is ----

"the two kinds of input" ^0
"  latency per region : measured, continuously" ^0
"  weight per region  : written, once, in a file" ^0
"  freshness check on the first  : yes, it alerts on gaps" ^0
"  freshness check on the second : none, because a config" ^0
"    value is not a measurement and nothing watches it age" ^0
"" ^0

int(actual_share_of_the_heavy_region_per_myriad / weight_of_the_heavy_region_per_myriad) => share_over_weight
"the heavy region's share is its weight times : " + str(share_over_weight) ^0
"" ^0

# ---- what the error looks like ----

# The reported number is stable, plausible, and moves in the right direction
# when latency moves. Nothing about it looks like a stale input; it looks like
# a fleet that is faster than the one people are using.
"reading the dashboard" ^0
"  the number is stable            : yes" ^0
"  it moves when latency moves     : yes" ^0
"  it is within the range of the per-region numbers : yes" ^0
"  it equals what any user experiences : no, and nothing" ^0
"    on the page is the number that would" ^0
"" ^0

# ---- null control ----

# The same weighted average, with the weights recomputed from the traffic the
# same pipeline already measures.
actual_share_of_the_heavy_region_per_myriad => nc_weight_of_the_heavy_region
experienced_ms => nc_reported_ms

"null control - the weights recomputed from measured traffic" ^0
"  weights sum to one : yes, unchanged" ^0
"  weight of the heavy region : " + str(nc_weight_of_the_heavy_region) + " per ten thousand" ^0
"  reported average, ms : " + str(nc_reported_ms) ^0
"  the average did not become better shaped; its second" ^0
"  input started being measured like its first" ^0
"" ^0

# ---- the rule ----

"what a weighted average guarantees" ^0
"  each part counts in proportion to its weight : exactly" ^0
"  each part counts in proportion to its size   : not" ^0
"    addressed; the weight is an assertion about the size," ^0
"    made once, and the size is free to move" ^0
"" ^0
"a formula's correctness is a claim about its arithmetic; every" ^0
"input it names is a separate claim, and the ones written by" ^0
"hand are the ones with no clock on them" ^0
"" ^0

"The average is correctly weighted and the arithmetic is exact: the weights sum" ^0
"to one, the shape was chosen over an unweighted mean for a real reason. The" ^0
"weights were written " + str(days_since_the_weights_were_updated) + " days ago and the heavy region now carries " + str(share_over_weight) + " times" ^0
"its weight, so the dashboard reports " + str(reported_ms) + " ms where the traffic experiences " + str(experienced_ms) + " -" ^0
"understated by " + str(understated_by_ms) + " ms - and every number on the page is individually correct." ^0

weight_of_the_heavy_region_per_myriad = 900
actual_share_of_the_heavy_region_per_myriad = 3400
latency_of_the_heavy_region_ms = 890
latency_of_the_others_ms = 120
days_since_the_weights_were_updated = 96
regions = 5
weight_of_the_others_per_myriad = 10000 - weight_of_the_heavy_region_per_myriad
actual_share_of_the_others_per_myriad = 10000 - actual_share_of_the_heavy_region_per_myriad
reported_ms = int((weight_of_the_heavy_region_per_myriad * latency_of_the_heavy_region_ms + weight_of_the_others_per_myriad * latency_of_the_others_ms) / 10000)
experienced_ms = int((actual_share_of_the_heavy_region_per_myriad * latency_of_the_heavy_region_ms + actual_share_of_the_others_per_myriad * latency_of_the_others_ms) / 10000)
understated_by_ms = experienced_ms - reported_ms
print("regions                        : " + str(regions))
print("weight of the heavy region     : " + str(weight_of_the_heavy_region_per_myriad) + " per ten thousand")
print("its actual share of traffic    : " + str(actual_share_of_the_heavy_region_per_myriad) + " per ten thousand")
print("days since the weights changed : " + str(days_since_the_weights_were_updated))
print("")
print("latency there, ms              : " + str(latency_of_the_heavy_region_ms))
print("latency elsewhere, ms          : " + str(latency_of_the_others_ms))
print("reported average, ms           : " + str(reported_ms))
print("experienced average, ms        : " + str(experienced_ms))
print("understated by, ms             : " + str(understated_by_ms))
print("")
print("why the average is weighted")
print("  unweighted mean over " + str(regions) + " regions : treats a two")
print("    percent region as equal to a third")
print("  weights sum to one   : yes")
print("  rounding error       : none worth naming")
print("  argued for by        : someone who had watched a small")
print("    region's noise move the headline")
print("  verdict              : CORRECTLY WEIGHTED")
print("")
print("  the shape is right and switching back would be worse")
print("")
print("the two kinds of input")
print("  latency per region : measured, continuously")
print("  weight per region  : written, once, in a file")
print("  freshness check on the first  : yes, it alerts on gaps")
print("  freshness check on the second : none, because a config")
print("    value is not a measurement and nothing watches it age")
print("")
share_over_weight = int(actual_share_of_the_heavy_region_per_myriad / weight_of_the_heavy_region_per_myriad)
print("the heavy region's share is its weight times : " + str(share_over_weight))
print("")
print("reading the dashboard")
print("  the number is stable            : yes")
print("  it moves when latency moves     : yes")
print("  it is within the range of the per-region numbers : yes")
print("  it equals what any user experiences : no, and nothing")
print("    on the page is the number that would")
print("")
nc_weight_of_the_heavy_region = actual_share_of_the_heavy_region_per_myriad
nc_reported_ms = experienced_ms
print("null control - the weights recomputed from measured traffic")
print("  weights sum to one : yes, unchanged")
print("  weight of the heavy region : " + str(nc_weight_of_the_heavy_region) + " per ten thousand")
print("  reported average, ms : " + str(nc_reported_ms))
print("  the average did not become better shaped; its second")
print("  input started being measured like its first")
print("")
print("what a weighted average guarantees")
print("  each part counts in proportion to its weight : exactly")
print("  each part counts in proportion to its size   : not")
print("    addressed; the weight is an assertion about the size,")
print("    made once, and the size is free to move")
print("")
print("a formula's correctness is a claim about its arithmetic; every")
print("input it names is a separate claim, and the ones written by")
print("hand are the ones with no clock on them")
print("")
print("The average is correctly weighted and the arithmetic is exact: the weights sum")
print("to one, the shape was chosen over an unweighted mean for a real reason. The")
print("weights were written " + str(days_since_the_weights_were_updated) + " days ago and the heavy region now carries " + str(share_over_weight) + " times")
print("its weight, so the dashboard reports " + str(reported_ms) + " ms where the traffic experiences " + str(experienced_ms) + " -")
print("understated by " + str(understated_by_ms) + " ms - and every number on the page is individually correct.")

regions                        : 5
weight of the heavy region     : 900 per ten thousand
its actual share of traffic    : 3400 per ten thousand
days since the weights changed : 96

latency there, ms              : 890
latency elsewhere, ms          : 120
reported average, ms           : 189
experienced average, ms        : 381
understated by, ms             : 192

why the average is weighted
  unweighted mean over 5 regions : treats a two
    percent region as equal to a third
  weights sum to one   : yes
  rounding error       : none worth naming
  argued for by        : someone who had watched a small
    region's noise move the headline
  verdict              : CORRECTLY WEIGHTED

  the shape is right and switching back would be worse

the two kinds of input
  latency per region : measured, continuously
  weight per region  : written, once, in a file
  freshness check on the first  : yes, it alerts on gaps
  freshness check on the second : none, because a config
    value is not a measurement and nothing watches it age

the heavy region's share is its weight times : 3

reading the dashboard
  the number is stable            : yes
  it moves when latency moves     : yes
  it is within the range of the per-region numbers : yes
  it equals what any user experiences : no, and nothing
    on the page is the number that would

null control - the weights recomputed from measured traffic
  weights sum to one : yes, unchanged
  weight of the heavy region : 3400 per ten thousand
  reported average, ms : 381
  the average did not become better shaped; its second
  input started being measured like its first

what a weighted average guarantees
  each part counts in proportion to its weight : exactly
  each part counts in proportion to its size   : not
    addressed; the weight is an assertion about the size,
    made once, and the size is free to move

a formula's correctness is a claim about its arithmetic; every
input it names is a separate claim, and the ones written by
hand are the ones with no clock on them

The average is correctly weighted and the arithmetic is exact: the weights sum
to one, the shape was chosen over an unweighted mean for a real reason. The
weights were written 96 days ago and the heavy region now carries 3 times
its weight, so the dashboard reports 189 ms where the traffic experiences 381 -
understated by 192 ms - and every number on the page is individually correct.

Trace event types