The team that can see it cannot change it

# Self-authored for the EML case corpus (no external origin). The platform team
# can see every one of these findings. How many of them anyone can act on is
# computed below.
#
# Centralising the view is right. One team watching every service spots the
# patterns no single service owner can see, applies one standard everywhere,
# and does not need eight teams to each build the same dashboard. The findings
# are real, reproducible and correctly attributed.
#
# Seeing and being able to change are two permissions, and centralising the
# first one moved it away from the second. A finding is acted on when one party
# holds both, and neither team here holds both for most of the list.
#
# The overlap is computed per finding.

# [finding, service, platform can change it, the service still has an owner, the owner was told]
[["f1", "shared-lib", 1, 1, 1], ["f2", "checkout", 0, 1, 1], ["f3", "search", 0, 1, 0], ["f4", "legacy-report", 0, 0, 0], ["f5", "auth", 0, 1, 1], ["f6", "billing", 0, 1, 0], ["f7", "ingest", 0, 1, 0], ["f8", "mailer", 0, 0, 0]] => findings

len(findings) => n

def actionable(f):
    if f[2] == 1:
        return 1
    if f[3] == 1:
        if f[4] == 1:
            return 1
    return 0

"findings : " + str(n) ^0
"" ^0

0 => platform_sees
0 => platform_can_change
0 => has_owner
0 => owner_told
0 => can_act
for f in findings:
    platform_sees + 1 => platform_sees
    if f[2] == 1:
        platform_can_change + 1 => platform_can_change
    if f[3] == 1:
        has_owner + 1 => has_owner
        if f[4] == 1:
            owner_told + 1 => owner_told
    can_act + actionable(f) => can_act

"the platform team" ^0
"  can see       : " + str(platform_sees) + " of " + str(n) ^0
"  can change    : " + str(platform_can_change) + " of " + str(n) ^0
"the service owners" ^0
"  can change    : " + str(has_owner) + " of " + str(n) ^0
"  were told     : " + str(owner_told) + " of " + str(n) ^0
"" ^0
"findings where one party holds both permissions : " + str(can_act) + " of " + str(n) ^0
if can_act < platform_sees:
    "  " + str(platform_sees - can_act) + " are visible to somebody and changeable by somebody else" ^0
"" ^0

"finding   service         who could act" ^0
for f in findings:
    "" => who
    if f[2] == 1:
        "the platform team" => who
    elif f[3] == 0:
        "nobody - the service has no owner" => who
    elif f[4] == 1:
        "the owning team" => who
    else:
        "the owning team, once told" => who
    "  " + f[0] + "      " + f[1] + "     " + who ^0
"" ^0

# ---- the residual splits into two different problems ----
#
# One is a routing problem and is solved by sending a message. The other is an
# ownership problem and is not.

0 => routing
0 => ownerless
for f in findings:
    if actionable(f) == 0:
        if f[3] == 1:
            routing + 1 => routing
        else:
            ownerless + 1 => ownerless
"what the remaining " + str(n - can_act) + " need" ^0
"  a message to the owner : " + str(routing) ^0
"  an owner at all        : " + str(ownerless) ^0
if routing + ownerless == n - can_act:
    "  and those two numbers account for all of them" ^0
"" ^0

# ---- what routing alone would buy ----

0 => if_routed
for f in findings:
    if f[2] == 1:
        if_routed + 1 => if_routed
    elif f[3] == 1:
        if_routed + 1 => if_routed
"if every finding were routed to its owner tomorrow" ^0
"  actionable : " + str(if_routed) + " of " + str(n) ^0
if if_routed > can_act:
    "  up " + str(if_routed - can_act) + " from " + str(can_act) + ", by sending messages and changing no code" ^0
if if_routed < n:
    "  the last " + str(n - if_routed) + " are unchanged, because routing needs a recipient" ^0
"" ^0

# ---- what the platform team can do without the other permission ----
#
# Not nothing. It can make the finding cheaper to act on for whoever does hold
# the second permission - which is a different job from fixing it.

"what the centralised view is still the right place for" ^0
"  finding the pattern across services : " + str(n) + " findings, one standard" ^0
"  proving the finding is real         : reproducible before it is sent" ^0
"  knowing whether it was fixed        : the same view sees the after state" ^0
"  none of those requires the change permission, and all of them are lost if" ^0
"  each team watches only itself" ^0
"" ^0

# ---- the control: a team that holds both ----
#
# Where the same team watches and owns, routing costs nothing and the residual
# is only the work itself.

[["g1", "own-svc-a", 1, 1, 1], ["g2", "own-svc-b", 1, 1, 1], ["g3", "own-svc-c", 1, 1, 1]] => selfowned
0 => s_act
for f in selfowned:
    s_act + actionable(f) => s_act
"control - a team watching services it owns" ^0
"  findings : " + str(len(selfowned)) + ", actionable : " + str(s_act) ^0
if s_act == len(selfowned):
    "  all of them, because seeing and changing are the same party here" ^0
"  so this team's fix rate says nothing about routing, which it never needed" ^0
"" ^0

"The central view is worth having and every finding in it is real. Acting" ^0
"needs the same party to hold the view and the write access, and centralising" ^0
"one of those two is what separated them." ^0

findings = [["f1", "shared-lib", 1, 1, 1], ["f2", "checkout", 0, 1, 1], ["f3", "search", 0, 1, 0], ["f4", "legacy-report", 0, 0, 0], ["f5", "auth", 0, 1, 1], ["f6", "billing", 0, 1, 0], ["f7", "ingest", 0, 1, 0], ["f8", "mailer", 0, 0, 0]]
n = len(findings)

def actionable(f):
    if f[2] == 1:
        return 1
    if f[3] == 1:
        if f[4] == 1:
            return 1
    return 0

print("findings : " + str(n))
print("")
platform_sees = 0
platform_can_change = 0
has_owner = 0
owner_told = 0
can_act = 0
for f in findings:
    platform_sees = platform_sees + 1
    if f[2] == 1:
        platform_can_change = platform_can_change + 1
    if f[3] == 1:
        has_owner = has_owner + 1
        if f[4] == 1:
            owner_told = owner_told + 1
    can_act = can_act + actionable(f)
print("the platform team")
print("  can see       : " + str(platform_sees) + " of " + str(n))
print("  can change    : " + str(platform_can_change) + " of " + str(n))
print("the service owners")
print("  can change    : " + str(has_owner) + " of " + str(n))
print("  were told     : " + str(owner_told) + " of " + str(n))
print("")
print("findings where one party holds both permissions : " + str(can_act) + " of " + str(n))
if can_act < platform_sees:
    print("  " + str(platform_sees - can_act) + " are visible to somebody and changeable by somebody else")
print("")
print("finding   service         who could act")
for f in findings:
    who = ""
    if f[2] == 1:
        who = "the platform team"
    elif f[3] == 0:
        who = "nobody - the service has no owner"
    elif f[4] == 1:
        who = "the owning team"
    else:
        who = "the owning team, once told"
    print("  " + f[0] + "      " + f[1] + "     " + who)
print("")
routing = 0
ownerless = 0
for f in findings:
    if actionable(f) == 0:
        if f[3] == 1:
            routing = routing + 1
        else:
            ownerless = ownerless + 1
print("what the remaining " + str(n - can_act) + " need")
print("  a message to the owner : " + str(routing))
print("  an owner at all        : " + str(ownerless))
if routing + ownerless == n - can_act:
    print("  and those two numbers account for all of them")
print("")
if_routed = 0
for f in findings:
    if f[2] == 1:
        if_routed = if_routed + 1
    elif f[3] == 1:
        if_routed = if_routed + 1
print("if every finding were routed to its owner tomorrow")
print("  actionable : " + str(if_routed) + " of " + str(n))
if if_routed > can_act:
    print("  up " + str(if_routed - can_act) + " from " + str(can_act) + ", by sending messages and changing no code")
if if_routed < n:
    print("  the last " + str(n - if_routed) + " are unchanged, because routing needs a recipient")
print("")
print("what the centralised view is still the right place for")
print("  finding the pattern across services : " + str(n) + " findings, one standard")
print("  proving the finding is real         : reproducible before it is sent")
print("  knowing whether it was fixed        : the same view sees the after state")
print("  none of those requires the change permission, and all of them are lost if")
print("  each team watches only itself")
print("")
selfowned = [["g1", "own-svc-a", 1, 1, 1], ["g2", "own-svc-b", 1, 1, 1], ["g3", "own-svc-c", 1, 1, 1]]
s_act = 0
for f in selfowned:
    s_act = s_act + actionable(f)
print("control - a team watching services it owns")
print("  findings : " + str(len(selfowned)) + ", actionable : " + str(s_act))
if s_act == len(selfowned):
    print("  all of them, because seeing and changing are the same party here")
print("  so this team's fix rate says nothing about routing, which it never needed")
print("")
print("The central view is worth having and every finding in it is real. Acting")
print("needs the same party to hold the view and the write access, and centralising")
print("one of those two is what separated them.")

findings : 8

the platform team
  can see       : 8 of 8
  can change    : 1 of 8
the service owners
  can change    : 6 of 8
  were told     : 3 of 8

findings where one party holds both permissions : 3 of 8
  5 are visible to somebody and changeable by somebody else

finding   service         who could act
  f1      shared-lib     the platform team
  f2      checkout     the owning team
  f3      search     the owning team, once told
  f4      legacy-report     nobody - the service has no owner
  f5      auth     the owning team
  f6      billing     the owning team, once told
  f7      ingest     the owning team, once told
  f8      mailer     nobody - the service has no owner

what the remaining 5 need
  a message to the owner : 3
  an owner at all        : 2
  and those two numbers account for all of them

if every finding were routed to its owner tomorrow
  actionable : 6 of 8
  up 3 from 3, by sending messages and changing no code
  the last 2 are unchanged, because routing needs a recipient

what the centralised view is still the right place for
  finding the pattern across services : 8 findings, one standard
  proving the finding is real         : reproducible before it is sent
  knowing whether it was fixed        : the same view sees the after state
  none of those requires the change permission, and all of them are lost if
  each team watches only itself

control - a team watching services it owns
  findings : 3, actionable : 3
  all of them, because seeing and changing are the same party here
  so this team's fix rate says nothing about routing, which it never needed

The central view is worth having and every finding in it is real. Acting
needs the same party to hold the view and the write access, and centralising
one of those two is what separated them.

Trace event types