Small structured events without credential leakage

pythonapi-clientsautomationindependent-practice

Saved on this device

Full lesson · 4 learning steps Open any exercise for focused practice

Step 1 of 4 · intro card

Small structured events without credential leakage

Concept and contract

Log an allowlisted operational event instead of serializing the entire request or configuration.

Useful operational evidence does not require copying the full request, configuration or response into logs. A small structured event can record a country and an observed item count while excluding an API credential that happens to be available to the caller.

This lesson uses fictional values and an in-memory stream. It does not contact a logging service, store private user text or configure the application’s process-global root logger.

Mechanism and worked example

The function validates its public fields, constructs an allowlisted event and sends one JSON message through a local Logger and StreamHandler.

The function validates its public fields, constructs an allowlisted event and sends one JSON message through a local Logger and StreamHandler. A fresh logger avoids inheriting unrelated handlers or duplicating messages across repeated fixture calls.

The finally block removes and closes the handler. The returned stream text makes the actual logging path observable to tests instead of testing only a separate dictionary that might differ from the emitted message.

Complete worked example

python

import io
import json
import logging

def event_line(country, count, api_key):
    if not isinstance(country, str) or country not in {"US", "IL", "UA", "CA"} or type(count) is not int or not 0 <= count <= 10000:
        raise ValueError("bounded public event fields required")
    event = {"country": country, "count": count}
    stream = io.StringIO()
    logger = logging.Logger("learning.client", level=logging.INFO)
    handler = logging.StreamHandler(stream)
    logger.addHandler(handler)
    try:
        logger.info(json.dumps(event, sort_keys=True, separators=(",", ":")))
        return stream.getvalue()
    finally:
        logger.removeHandler(handler)
        handler.close()

Reasoning: Log an allowlisted operational event instead of serializing the entire request or configuration. Compare the stated values and failure boundary before changing the implementation.

Counterexamples and common mistakes

The counterexample adds the supplied api_key to the event.

The counterexample adds the supplied api_key to the event. Logging every key from a request dictionary is similarly risky because future fields can silently become public output.

Masking a secret after serialization is more fragile than not including it. Also avoid using arbitrary exception text or full URLs containing credentials as log fields. A missing or rejected event should not be hidden by broad error handling that reports a successful import.

Counterexample: a runnable policy defect

python

import io
import json
import logging

def event_line(country, count, api_key):
    if not isinstance(country, str) or country not in {"US", "IL", "UA", "CA"} or type(count) is not int or not 0 <= count <= 10000:
        raise ValueError("bounded public event fields required")
    event = {"country": country, "count": count, "api_key": api_key}
    stream = io.StringIO()
    logger = logging.Logger("learning.client", level=logging.INFO)
    handler = logging.StreamHandler(stream)
    logger.addHandler(handler)
    try:
        logger.info(json.dumps(event, sort_keys=True, separators=(",", ":")))
        return stream.getvalue()
    finally:
        logger.removeHandler(handler)
        handler.close()

Reasoning: This runnable counterexample violates the declared contract; the companion lab requires it to fail.

Independent practice: API client task

Add the fixed event name catalogue.received while keeping only the existing country and count fields.

Add the fixed event name catalogue.received while keeping only the existing country and count fields. Begin with a zero count and a supplied fictional secret marker.

Confirm the marker is absent from the actual emitted line, not just absent from an intermediate variable. Preserve one-line JSON formatting and repeated-call behavior. This task adds useful context without introducing timestamps, external log delivery or high-cardinality request bodies.

Step 1: Add the fixed catalogue.received event name. Step 2: Keep the fictional credential absent from the emitted line.

Practice starter: solve before reading the solution

python

import io
import json
import logging

def event_line(country, count, api_key):
    # Remove this placeholder, then adapt the retained baseline:
    # Add the fixed catalogue.received event name.
    raise NotImplementedError
    if not isinstance(country, str) or country not in {"US", "IL", "UA", "CA"} or type(count) is not int or not 0 <= count <= 10000:
        raise ValueError("bounded public event fields required")
    event = {"country": country, "count": count}
    stream = io.StringIO()
    logger = logging.Logger("learning.client", level=logging.INFO)
    handler = logging.StreamHandler(stream)
    logger.addHandler(handler)
    try:
        logger.info(json.dumps(event, sort_keys=True, separators=(",", ":")))
        return stream.getvalue()
    finally:
        logger.removeHandler(handler)
        handler.close()

Reasoning: Add the fixed catalogue.received event name. Keep the fictional credential absent from the emitted line.

Hint 1: Extend the public event mapping rather than serializing all local variables.
Hint 2: Inspect the logger stream output including its newline.

Solution, tests and trade-offs

The exact expected line includes its trailing newline and stable JSON key ordering.

The exact expected line includes its trailing newline and stable JSON key ordering. Cases reject a boolean count, a negative count and an unsupported country, and repeated calls must each emit one event.

The practice also checks the fixed event name. These acceptance checks prove the fixture’s allowlist and formatting policy; a production deployment still needs its own log retention, access control and transport configuration.

Practice solution and acceptance checks

python

import io
import json
import logging

def event_line(country, count, api_key):
    if not isinstance(country, str) or country not in {"US", "IL", "UA", "CA"} or type(count) is not int or not 0 <= count <= 10000:
        raise ValueError("bounded public event fields required")
    event = {"event": "catalogue.received", "country": country, "count": count}
    stream = io.StringIO()
    logger = logging.Logger("learning.client", level=logging.INFO)
    handler = logging.StreamHandler(stream)
    logger.addHandler(handler)
    try:
        logger.info(json.dumps(event, sort_keys=True, separators=(",", ":")))
        return stream.getvalue()
    finally:
        logger.removeHandler(handler)
        handler.close()

Reasoning: Extend the public event mapping rather than serializing all local variables. Inspect the logger stream output including its newline.

Interview reasoning and next step

Explain which question the event helps answer and why each field is necessary.

Explain which question the event helps answer and why each field is necessary. A count can show that a successful response had zero observed items without claiming the entire market is empty.

Add duration or status only with a clear measurement definition and bounded values. Keep user content and credentials out of the event. The next lessons preserve the same separation between operational evidence and the actual persisted report.

Optional stretch — after the core task works: Define an observed duration field using an injected monotonic clock.

Computer practice: https://applydjinn.com/typorithm/python-automation-lab-20261105.zip. Run verify.py using your selected Python interpreter, then adapt the retained exercise baseline and check it with --practice followed by the lesson id. The standard-library lab uses owned temporary 127.0.0.1 loopback servers, fictional pages and disposable files; it never scans production feeds or opens the working ApplyDjinn database.

Log an allowlisted operational event instead of serializing the entire request or configuration.