---
id: logfury
version: "1.0.1"
license: BSD
license_treatment: permissive
maintenance: abandoned
---

# logfury — ('Toolkit for responsible, low-boilerplate logging of library method calls',)

License: permissive · Maintenance: abandoned · Downloads: 525.0K/mo

## What it is and what it does

Logfury is a logging instrumentation library designed for Python library maintainers who want to trace method calls without writing repetitive logging code. It provides two main mechanisms: a DefaultTraceMeta metaclass that automatically logs calls to public methods in decorated classes, and a trace_call decorator for individual functions. Both log method entry with full argument values, and support filtering sensitive arguments or limiting what gets logged.

The library uses a versioned import scheme (e.g., `from logfury.v1 import ...`) to allow the maintainer to evolve the API and default behavior without breaking existing code—users choose when to adopt incompatible changes by updating their import version. It has no runtime dependencies and supports Python 3.5 through 3.10, though development stopped after 2021-10-23.

Use it for:

- Add call tracing to a library's public API for debugging without modifying method bodies.
- Log function entry points with arguments in a decorator-based approach for specific functions.
- Hide sensitive arguments from trace logs using the limit_trace_arguments decorator.
- Inherit tracing behavior across class hierarchies to instrument entire object hierarchies automatically.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Logfury adds automatic method-call tracing to Python classes and functions via metaclasses and decorators, logging entry points with arguments to help library maintainers debug without boilerplate.

No. While logfury is lightweight and has no runtime dependencies, it has been abandoned since 2021-10-23 with no maintenance. For new projects, consider actively maintained alternatives. For existing codebases already using it, the permissive BSD license and lack of vulnerabilities mean it is safe to keep, but do not adopt it for new work.

## Install

pip install logfury
uv add logfury
poetry add logfury

## Installing logfury

Before you install: Installation is straightforward with no runtime dependencies. However, the package has been abandoned since the last commit on 2021-10-23, so expect no maintenance, bug fixes, or compatibility improvements.

License in practice: BSD license is permissive, allowing use in both open-source and proprietary projects with minimal restrictions.

Quickstart:

pip install logfury

import logging
from logfury.v1 import DefaultTraceMeta

logging.basicConfig()
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

@six.add_metaclass(DefaultTraceMeta)
class MyClass:
    def my_method(self, a, b):
        return a + b

The package uses an older metaclass pattern that may not align with modern Python conventions.

Verify before relying:

- Whether the package works reliably with Python 3.10 given its abandonment status.
- Compatibility with async/await patterns or modern async libraries.
- Performance impact of metaclass-based tracing on large codebases or high-call-volume scenarios.
- Whether six is a runtime dependency despite not appearing in the deps list.

## Package facts

- License: BSD (permissive)
- Python support: unspecified
- Install friction: low
- Maintenance: abandoned
- Downloads: 525.0K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

method call tracing logging, automatic function entry logging, library debugging instrumentation, low-boilerplate call tracing, python method call logger, debug library method calls, trace function arguments, abandoned, metaclass-based, argument-filtering

[View on SkillFed](https://skillfed.io/packages/logfury) · [View on PyPI](https://pypi.org/project/logfury/)