"""Deterministic telemetry arithmetic. Python 3.10+, no third-party imports.
The example exports no prompts, user identifiers or network traffic.
"""
import math
import json


def weighted_failure(records):
    if not records:
        raise ValueError('No observations')
    for failed, probability in records:
        if not 0 < probability <= 1:
            raise ValueError('Invalid inclusion probability')
    return (sum(int(f)/p for f, p in records)
            / sum(1/p for _, p in records))


def critical_path(nodes):
    """Task-duration DAG; excludes enclosing spans to avoid double counting."""
    finish = {}
    visiting = set()
    def end(name):
        if name in finish:
            return finish[name]
        if name in visiting:
            raise ValueError('Cycle')
        visiting.add(name)
        duration, parents = nodes[name]
        if not isinstance(duration, (int, float)) or not math.isfinite(duration) or duration < 0:
            raise ValueError('Require a finite nonnegative duration')
        finish[name] = duration + max((end(p) for p in parents), default=0)
        visiting.remove(name)
        return finish[name]
    return max((end(n) for n in nodes), default=0)



# An original teaching schema, not a claim of OTLP wire compatibility.
# Whitelisting minimizes content capture; it does not anonymize identifiers.
SAFE_FIELDS = {"schema_version", "trace_id", "span_id", "parent_id", "operation",
               "duration_ms", "status", "attempt", "sample_probability"}


def safe_record(record):
    required = SAFE_FIELDS - {"parent_id"}
    if not required <= record.keys():
        raise ValueError('Missing required telemetry fields')
    result = {key: record[key] for key in SAFE_FIELDS if key in record}
    if result['status'] not in ('ok', 'error', 'unknown'):
        raise ValueError('Invalid status')
    if not math.isfinite(result['duration_ms']) or result['duration_ms'] < 0:
        raise ValueError('Invalid duration')
    if not 0 < result['sample_probability'] <= 1:
        raise ValueError('Invalid sampling probability')
    if not isinstance(result['attempt'], int) or result['attempt'] < 1:
        raise ValueError('Invalid attempt number')
    return result


raw = {'schema_version': 'teaching-v1', 'trace_id': 'synthetic-001',
       'span_id': 'tool-1', 'parent_id': 'request-1', 'operation': 'ledger_lookup',
       'duration_ms': 100, 'status': 'error', 'attempt': 1,
       'sample_probability': 1.0, 'prompt': 'DO NOT EXPORT THIS CONTENT'}
safe = safe_record(raw)
assert 'prompt' not in safe
assert safe['status'] == 'error'  # a later success must not erase this attempt
assert json.loads(json.dumps(safe)) == safe
retry = safe_record(dict(raw, span_id='tool-2', attempt=2, status='ok', duration_ms=120))
assert retry['trace_id'] == safe['trace_id'] and retry['span_id'] != safe['span_id']

# Population: 1000 requests, 20 failures. Retain all failures and exactly
# 98/980 successes. This stratified fixture has inclusion probabilities 1,.1.
records = [(True, 1.0)]*20 + [(False, .1)]*98
naive = sum(f for f, _ in records)/len(records)
weighted = weighted_failure(records)
assert math.isclose(weighted, .02)
assert weighted_failure([(False, 1)]) == 0
# Parallel retrieval and policy checks; retry starts after first tool fails.
nodes = {'retrieve': (80, []), 'policy': (30, []),
         'model': (400, ['retrieve', 'policy']),
         'tool': (100, ['model']), 'retry': (120, ['tool']),
         'final': (50, ['retry'])}
assert critical_path(nodes) == 750
assert sum(d for d, _ in nodes.values()) == 780
try:
    critical_path({'x': (1, ['x'])})
    raise AssertionError('Expected cycle rejection')
except ValueError:
    pass
print(f'Naive retained failure rate: {naive:.2%}')
print(f'Inclusion-weighted failure rate: {weighted:.2%}')
print(f'Critical path: {critical_path(nodes)} ms; summed task work: 780 ms')
print('All observability checks passed; synthetic data, not production telemetry.')
