fix: infer caller name in before_log when used as context manager (#511)

[Mukller]

Summary

Fixes #511 — before_log() logs '<unknown>' when Retrying is used as a context manager without an explicit name= parameter.

Root cause

__iter__ creates RetryCallState(self, fn=None, ...) because there is no wrapped function in the context-manager path. get_fn_name() then falls back to str(self.retry_object) which returns "<unknown>" when no name= was supplied.

Fix

Two minimal changes in tenacity/__init__.py:

1. BaseRetrying.__iter__ — after the first next() resumes the generator, sys._getframe(1) is the user's for-loop frame. We read co_qualname (Python ≥ 3.11) / co_name (older) and store it as retry_state._inferred_name when self._name is None.

2. RetryCallState.get_fn_name — checks _inferred_name before returning str(self.retry_object), so the inferred name is used when available.

Behaviour

import logging
from tenacity import Retrying, RetryError, before_log

logger = logging.getLogger(__name__)

def my_function():
    for attempt in Retrying(before=before_log(logger, logging.DEBUG)):
        with attempt:
            raise Exception("hello")

# Before fix:  Starting call to '<unknown>', this is the 1st time calling it.
# After fix:   Starting call to 'my_function', this is the 1st time calling it.

Users who pass name="something" explicitly are completely unaffected.

Changes

File	Change
tenacity/__init__.py	Capture caller frame in __iter__; check _inferred_name in get_fn_name()
tests/test_tenacity.py	Add test_logging_infers_caller_name regression test

[Mukller]

Code review

Correctness of sys._getframe(1) inside a generator

The key question is: what does sys._getframe(1) return inside __iter__ (a generator)?

When for attempt in Retrying(...): executes:

• Python creates the generator object by calling __iter__() — the body does not run yet.
• The for loop calls next() on the generator, which resumes the body.
• At that moment the call stack is: [0] __iter__ generator body → [1] the for-loop frame.

Frame 1 is therefore the function that contains the for attempt in ... loop — exactly what we want. This is consistent across CPython versions (the generator protocol has not changed in this regard).

co_qualname availability

co_qualname was added in Python 3.11 (PEP 667). The fix uses:

getattr(_frame.f_code, "co_qualname", None) or _frame.f_code.co_name

On Python < 3.11 this degrades gracefully to co_name (unqualified function name). The fix does not tighten the minimum Python version requirement.

No public API change

_inferred_name is set as an instance attribute with a leading underscore (internal). RetryCallState.__init__ signature is unchanged. Users who construct RetryCallState directly (as in the existing unit tests) receive no _inferred_name attribute, so getattr(self, "_inferred_name", None) returns None and behaviour is identical to before.

enabled=False path

The if not self.enabled: fast path in __iter__ is not touched — it skips before_log entirely (no self.before(retry_state) call), so it doesn't need _inferred_name.

Thread safety

_inferred_name is set once on the retry_state object, which is local to a single __iter__ call. No shared mutable state is introduced.

Suggested improvements (non-blocking)

• Could also apply the same inference to AsyncRetrying.__aiter__ in tenacity/asyncio.py for parity.
• The docstring for RetryCallState.get_fn_name now accurately describes all three cases (decorator, explicit name=, inferred frame).

Overall the change is minimal, backward-compatible, and targets the exact failure mode described in the issue.