The target was set by what was asked for

# Self-authored for the EML case corpus (no external origin). The availability
# target was set to what consumers asked for, and consumers asked for what was
# published. What any of them needs is computed below.
#
# Setting the target from consumer requirements is the correct method and it is
# what every guide says: do not pick a number, ask the people who depend on you.
# The team did ask, wrote the answers down, and set the target to the strictest
# one. Nothing about the process was skipped.
#
# A consumer asked what to ask for looks at what is on offer. So the answers
# come back as the published figure, the strictest of them is the published
# figure, and the requirement and the target are the same number arrived at
# twice. The one thing not in the loop is what breaks if it is missed.
#
# Each consumer's real tolerance is computed from its own retry budget.

# [consumer, nines it asked for, seconds it can wait, its own published target in nines]
[["checkout", 3, 30, 3], ["search", 3, 120, 2], ["reporting", 3, 3600, 1], ["mobile app", 3, 60, 2], ["partner feed", 3, 900, 1], ["fraud check", 3, 5, 4]] => consumers

len(consumers) => n
3 => published

# a consumer needs the provider to be at least as available as its own promise
def needs(c):
    return c[3]

0 => asked_same
0 => below
0 => above
0 => strictest
for c in consumers:
    if c[1] == published:
        asked_same + 1 => asked_same
    if needs(c) < published:
        below + 1 => below
    if needs(c) > published:
        above + 1 => above
    if needs(c) > strictest:
        needs(c) => strictest

"consumers : " + str(n) + ", published target : " + str(published) + " nines" ^0
"" ^0
"consumer        asked for   can wait   own promise   really needs" ^0
for c in consumers:
    "  " + c[0] + "   " + str(c[1]) + " nines     " + str(c[2]) + "s      " + str(c[3]) + " nines      " + str(needs(c)) + " nines" ^0
"" ^0

"consumers whose answer equals the published figure : " + str(asked_same) + " of " + str(n) ^0
if asked_same == n:
    "  every answer came back as the number that was already on the page" ^0
"" ^0

"against what each one's own promise implies" ^0
"  need less than " + str(published) + " nines : " + str(below) ^0
"  need exactly " + str(published) + "        : " + str(n - below - above) ^0
"  need more than " + str(published) + "      : " + str(above) ^0
"  strictest real requirement : " + str(strictest) + " nines" ^0
if strictest > published:
    "  which is above the target the survey produced, by " + str(strictest - published) ^0
"" ^0

for c in consumers:
    if needs(c) == strictest:
        "  the consumer that needs it : " + c[0] + ", which can wait " + str(c[2]) + " seconds" ^0
        "  it asked for " + str(c[1]) + " nines, the same as everyone, and it is the one" ^0
        "  the target does not cover" ^0
"" ^0

# ---- what the target costs ----

[0, 40, 120, 300, 900] => cost_by_nines
"cost of running at each level" ^0
for k in [1:4]:
    "  " + str(k) + " nines : " + str(cost_by_nines[k]) ^0
"" ^0
"at the published target of " + str(published) + " : " + str(cost_by_nines[published]) ^0
0 => max_below
for c in consumers:
    if needs(c) < published:
        if needs(c) > max_below:
            needs(c) => max_below
"the strictest requirement among consumers that need less than the target : " + str(max_below) ^0
if below > 0:
    "  " + str(below) + " consumers would be inside their own promise at " + str(max_below) + " nines" ^0
    "  which costs " + str(cost_by_nines[max_below]) + " against " + str(cost_by_nines[published]) ^0
"" ^0

"serving the one strict consumer separately" ^0
"  the other " + str(n - 1) + " at " + str(max_below) + " nines : " + str(cost_by_nines[max_below]) ^0
"  one path at " + str(strictest) + " nines      : " + str(cost_by_nines[strictest]) ^0
"  total                       : " + str(cost_by_nines[max_below] + cost_by_nines[strictest]) ^0
"  one uniform target at " + str(strictest) + "     : " + str(cost_by_nines[strictest]) ^0
if cost_by_nines[max_below] + cost_by_nines[strictest] > cost_by_nines[strictest]:
    "  splitting costs " + str(cost_by_nines[max_below]) + " more here, so the uniform strict target wins" ^0
    "  on cost - and it is a different number from the one the survey found" ^0
"" ^0

# ---- what would have broken the circle ----
#
# Not a better survey. A question whose answer is not a number the provider
# has already published.

"the question that was asked : what availability do you require" ^0
"the question that is answerable : how long can you wait, and what do you" ^0
"  promise your own users" ^0
"  the second one was answered above, in seconds and in nines, and it" ^0
"  produced " + str(strictest) + " where the first produced " + str(published) ^0
"" ^0

# ---- the control: a consumer with no published target of its own ----
#
# Where a consumer has nothing of its own to derive from, the circular answer
# is the only answer it has, and asking harder does not help.

"control - a consumer that publishes nothing and has no retry budget" ^0
"  what it can derive a requirement from : nothing" ^0
"  what it will answer                   : the published figure" ^0
"  for this consumer the survey is not circular by accident, it is circular" ^0
"  because there is no second source to reach" ^0
"" ^0

"Asking the consumers is the right method and the answers were recorded" ^0
"faithfully. A requirement gathered from people reading your own page is your" ^0
"own page, and the one consumer it fails is the one that answered like the" ^0
"others." ^0

consumers = [["checkout", 3, 30, 3], ["search", 3, 120, 2], ["reporting", 3, 3600, 1], ["mobile app", 3, 60, 2], ["partner feed", 3, 900, 1], ["fraud check", 3, 5, 4]]
n = len(consumers)
published = 3

def needs(c):
    return c[3]

asked_same = 0
below = 0
above = 0
strictest = 0
for c in consumers:
    if c[1] == published:
        asked_same = asked_same + 1
    if needs(c) < published:
        below = below + 1
    if needs(c) > published:
        above = above + 1
    if needs(c) > strictest:
        strictest = needs(c)
print("consumers : " + str(n) + ", published target : " + str(published) + " nines")
print("")
print("consumer        asked for   can wait   own promise   really needs")
for c in consumers:
    print("  " + c[0] + "   " + str(c[1]) + " nines     " + str(c[2]) + "s      " + str(c[3]) + " nines      " + str(needs(c)) + " nines")
print("")
print("consumers whose answer equals the published figure : " + str(asked_same) + " of " + str(n))
if asked_same == n:
    print("  every answer came back as the number that was already on the page")
print("")
print("against what each one's own promise implies")
print("  need less than " + str(published) + " nines : " + str(below))
print("  need exactly " + str(published) + "        : " + str(n - below - above))
print("  need more than " + str(published) + "      : " + str(above))
print("  strictest real requirement : " + str(strictest) + " nines")
if strictest > published:
    print("  which is above the target the survey produced, by " + str(strictest - published))
print("")
for c in consumers:
    if needs(c) == strictest:
        print("  the consumer that needs it : " + c[0] + ", which can wait " + str(c[2]) + " seconds")
        print("  it asked for " + str(c[1]) + " nines, the same as everyone, and it is the one")
        print("  the target does not cover")
print("")
cost_by_nines = [0, 40, 120, 300, 900]
print("cost of running at each level")
for k in range(1, 5):
    print("  " + str(k) + " nines : " + str(cost_by_nines[k]))
print("")
print("at the published target of " + str(published) + " : " + str(cost_by_nines[published]))
max_below = 0
for c in consumers:
    if needs(c) < published:
        if needs(c) > max_below:
            max_below = needs(c)
print("the strictest requirement among consumers that need less than the target : " + str(max_below))
if below > 0:
    print("  " + str(below) + " consumers would be inside their own promise at " + str(max_below) + " nines")
    print("  which costs " + str(cost_by_nines[max_below]) + " against " + str(cost_by_nines[published]))
print("")
print("serving the one strict consumer separately")
print("  the other " + str(n - 1) + " at " + str(max_below) + " nines : " + str(cost_by_nines[max_below]))
print("  one path at " + str(strictest) + " nines      : " + str(cost_by_nines[strictest]))
print("  total                       : " + str(cost_by_nines[max_below] + cost_by_nines[strictest]))
print("  one uniform target at " + str(strictest) + "     : " + str(cost_by_nines[strictest]))
if cost_by_nines[max_below] + cost_by_nines[strictest] > cost_by_nines[strictest]:
    print("  splitting costs " + str(cost_by_nines[max_below]) + " more here, so the uniform strict target wins")
    print("  on cost - and it is a different number from the one the survey found")
print("")
print("the question that was asked : what availability do you require")
print("the question that is answerable : how long can you wait, and what do you")
print("  promise your own users")
print("  the second one was answered above, in seconds and in nines, and it")
print("  produced " + str(strictest) + " where the first produced " + str(published))
print("")
print("control - a consumer that publishes nothing and has no retry budget")
print("  what it can derive a requirement from : nothing")
print("  what it will answer                   : the published figure")
print("  for this consumer the survey is not circular by accident, it is circular")
print("  because there is no second source to reach")
print("")
print("Asking the consumers is the right method and the answers were recorded")
print("faithfully. A requirement gathered from people reading your own page is your")
print("own page, and the one consumer it fails is the one that answered like the")
print("others.")

consumers : 6, published target : 3 nines

consumer        asked for   can wait   own promise   really needs
  checkout   3 nines     30s      3 nines      3 nines
  search   3 nines     120s      2 nines      2 nines
  reporting   3 nines     3600s      1 nines      1 nines
  mobile app   3 nines     60s      2 nines      2 nines
  partner feed   3 nines     900s      1 nines      1 nines
  fraud check   3 nines     5s      4 nines      4 nines

consumers whose answer equals the published figure : 6 of 6
  every answer came back as the number that was already on the page

against what each one's own promise implies
  need less than 3 nines : 4
  need exactly 3        : 1
  need more than 3      : 1
  strictest real requirement : 4 nines
  which is above the target the survey produced, by 1

  the consumer that needs it : fraud check, which can wait 5 seconds
  it asked for 3 nines, the same as everyone, and it is the one
  the target does not cover

cost of running at each level
  1 nines : 40
  2 nines : 120
  3 nines : 300
  4 nines : 900

at the published target of 3 : 300
the strictest requirement among consumers that need less than the target : 2
  4 consumers would be inside their own promise at 2 nines
  which costs 120 against 300

serving the one strict consumer separately
  the other 5 at 2 nines : 120
  one path at 4 nines      : 900
  total                       : 1020
  one uniform target at 4     : 900
  splitting costs 120 more here, so the uniform strict target wins
  on cost - and it is a different number from the one the survey found

the question that was asked : what availability do you require
the question that is answerable : how long can you wait, and what do you
  promise your own users
  the second one was answered above, in seconds and in nines, and it
  produced 4 where the first produced 3

control - a consumer that publishes nothing and has no retry budget
  what it can derive a requirement from : nothing
  what it will answer                   : the published figure
  for this consumer the survey is not circular by accident, it is circular
  because there is no second source to reach

Asking the consumers is the right method and the answers were recorded
faithfully. A requirement gathered from people reading your own page is your
own page, and the one consumer it fails is the one that answered like the
others.

Trace event types