Python Logging Mastery

The Story That Explains Why Logging Exists ✈️Logging क्यों है — समझाने वाली कहानी ✈️一个讲清日志为何存在的故事 ✈️

Why print() Fails in Real Apps 🧻असली Apps में print() क्यों नाकाम है 🧻为什么 print() 在真实应用中不够用 🧻

import logging

print("print: User 42 logged in")              # no level, no time, no source

logging.info("This INFO line is hidden")         # default level is WARNING
logging.warning("Disk usage at 82%")             # shown: WARNING and above
logging.error("Failed to send email")

Notice two things in the real output. The INFO line is missing — the default level is WARNING. And log lines go to stderr, not stdout, so you can send your program's normal output and its logs to different places.

असली output में दो बातें देखें। INFO line ग़ायब है — default level WARNING है। और log lines stdout पर नहीं, stderr पर जाती हैं, इसलिए आप program का सामान्य output और logs अलग-अलग जगह भेज सकते हैं।

注意真实输出中的两点。INFO 那一行不见了 — 默认级别是 WARNING。而且日志行输出到 stderr 而不是 stdout，所以你可以把程序的正常输出和日志送到不同的地方。

The Five Log Levels 🎚️पाँच Log Levels 🎚️五个日志级别 🎚️

Every message carries a level, and every level is a number. A logger drops any message whose number is below its threshold.

हर message का एक level होता है, और हर level एक नंबर है। Logger हर उस message को गिरा देता है जिसका नंबर उसकी सीमा से नीचे है।

每条消息都带有一个级别，每个级别都是一个数字。记录器会丢弃数字 低于 阈值的所有消息。

import logging

logging.basicConfig(level=logging.DEBUG)       # show everything from DEBUG up

logging.debug("Loop iteration i=5, value=42")
logging.info("Server started on port 8000")
logging.warning("Disk usage at 82%")
logging.error("Failed to send email to user@example.com")
logging.critical("Database connection pool exhausted!")

print(logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL)

Try It — The Volume Knobकरके देखें — Volume Knob动手试试 — 音量旋钮

Here is a real log from a small shop app, captured at DEBUG. Turn the knob and watch which lines survive at each level.

यह एक छोटे shop app का असली log है, DEBUG पर रिकॉर्ड किया गया। Knob घुमाएँ और देखें हर level पर कौन-सी lines बचती हैं।

这是一个小商店应用的真实日志，在 DEBUG 级别下采集。转动旋钮，看看每个级别下哪些行会留下来。

The Anatomy of the Logging System 🔧Logging System की बनावट 🔧日志系统的构造 🔧

Named Loggers — Use getLogger(__name__) 🌳नाम वाले Loggers — getLogger(__name__) इस्तेमाल करें 🌳命名记录器 — 使用 getLogger(__name__) 🌳

Calling logging.info(...) uses the root logger. In real code, every module creates its own logger with logging.getLogger(__name__). __name__ is the module's dotted path, so the loggers form a tree that matches your packages — and you can turn each branch up or down separately.

logging.info(...) बुलाने से root logger इस्तेमाल होता है। असली code में हर module logging.getLogger(__name__) से अपना logger बनाता है। __name__ module का बिंदु वाला path है, इसलिए loggers आपके packages जैसा ही tree बनाते हैं — और आप हर शाखा को अलग से ऊपर-नीचे कर सकते हैं।

调用 logging.info(...) 使用的是 根 记录器。真实代码中，每个模块都用 logging.getLogger(__name__) 创建自己的记录器。__name__ 是模块的点号路径，所以记录器会组成一棵与包结构一致的树 — 你可以分别调高或调低每个分支。

# myapp/db.py
import logging

log = logging.getLogger(__name__)      # becomes "myapp.db"

def query(sql):
    log.debug("Executing SQL: %s", sql)
    log.info("Query finished in %d ms", 42)

# myapp/api.py
import logging
from myapp import db

log = logging.getLogger(__name__)      # becomes "myapp.api"

def get_user(user_id):
    log.info("GET /users/%s", user_id)
    db.query(f"SELECT * FROM users WHERE id = {user_id}")

import logging
from myapp import api

logging.basicConfig(level=logging.DEBUG, format="%(levelname)-7s %(name)-10s %(message)s")
api.get_user(42)

# Turn ONE module down - no code change inside myapp
logging.getLogger("myapp.db").setLevel(logging.WARNING)
print("--- myapp.db set to WARNING ---")
api.get_user(7)

The Logger Tree and Effective LevelsLogger Tree और Effective Levels记录器树与有效级别

import logging

pool = logging.getLogger("myapp.db.pool")
print(pool.parent.name)                       # "myapp" and "myapp.db" do not exist yet!

app = logging.getLogger("myapp")
db = logging.getLogger("myapp.db")
print(pool.parent.name, db.parent.name, app.parent.name)   # now the tree is complete

app.setLevel(logging.ERROR)
print(pool.level, logging.getLevelName(pool.getEffectiveLevel()))   # 0 = NOTSET -> inherits
db.setLevel(logging.DEBUG)
print(logging.getLevelName(pool.getEffectiveLevel()))               # the nearest set level wins
print(app.getChildren())                                            # Python 3.12+

Try It — The Log Router 🚦करके देखें — Log Router 🚦动手试试 — 日志路由器 🚦

This is the heart of logging. Set the levels, switch propagate on or off, then send a record from any logger and watch where it goes. The router follows the same rules as Logger.callHandlers(), and it was checked against the real logging module on all 3,840 combinations.

यही logging का दिल है। Levels set करें, propagate चालू या बंद करें, फिर किसी भी logger से record भेजें और देखें वह कहाँ जाता है। Router वही नियम मानता है जो Logger.callHandlers(), और इसे असली logging module से सभी 3,840 combinations पर जाँचा गया है।

这是日志的核心。设置级别，打开或关闭 propagate，然后从任一记录器发送一条记录，看它去了哪里。路由器遵循与 Logger.callHandlers() 相同的规则，并在全部 3,840 种组合上与真实 logging 模块核对过。

Formatters — Making Logs Readable 🖋️Formatters — Logs को पढ़ने लायक बनाना 🖋️格式化器 — 让日志易读 🖋️

import logging

FMT = "%(asctime)s | %(levelname)-8s | %(name)s:%(lineno)d | %(message)s"
logging.basicConfig(level=logging.INFO, format=FMT, datefmt="%Y-%m-%d %H:%M:%S")

log = logging.getLogger("shop.checkout")
log.info("Order %s placed for Rs %.2f", "ORD-8821", 1299.5)
log.warning("Coupon %s expired but was accepted", "DIWALI25")

Try It — Formatter Builderकरके देखें — Formatter Builder动手试试 — 格式化器构建器

Click placeholders or type your own format. The result is formatted exactly like Python does it, for two real LogRecords. Try a misspelt field, or a format with no field at all.

Placeholders पर click करें या अपना format लिखें। नतीजा दो असली LogRecords के लिए ठीक वैसे ही format होता है जैसे Python करता है। ग़लत spelling वाला field, या बिना field वाला format आज़माएँ।

点击占位符或输入你自己的格式。结果会按照 Python 的方式，为两条真实的 LogRecord 进行格式化。试试拼错的字段，或完全没有字段的格式。

Handlers — Sending Logs Everywhere 📮Handlers — Logs को हर जगह भेजना 📮处理器 — 把日志送到各处 📮

Console + Rotating FileConsole + Rotating File控制台 + 轮转文件

import logging
from logging.handlers import RotatingFileHandler

log = logging.getLogger("myapp")
log.setLevel(logging.DEBUG)                        # the logger lets everything in

fmt = logging.Formatter("%(levelname)-8s | %(name)s | %(message)s")

console = logging.StreamHandler()                  # stderr by default
console.setLevel(logging.WARNING)                  # the screen: WARNING and up
console.setFormatter(fmt)

file_h = RotatingFileHandler("myapp.log", maxBytes=5_000_000, backupCount=5, encoding="utf-8")
file_h.setLevel(logging.DEBUG)                     # the file: everything
file_h.setFormatter(fmt)

log.addHandler(console)
log.addHandler(file_h)

log.debug("goes to the FILE only")
log.info("goes to the FILE only")
log.warning("goes to BOTH")
log.error("goes to BOTH")

file_h.close()
print("--- myapp.log ---")
print(open("myapp.log", encoding="utf-8").read(), end="")

Try It — Rotating Filesकरके देखें — Rotating Files动手试试 — 轮转文件

A RotatingFileHandler with a tiny limit: 100 bytes and 3 backups. Step through 14 writes and watch the files move down when the limit is reached. Every snapshot was taken from the real files on disk.

बहुत छोटी सीमा वाला RotatingFileHandler: 100 bytes और 3 backups। 14 writes में कदम-दर-कदम चलें और सीमा पर files को नीचे खिसकते देखें। हर snapshot disk की असली files से लिया गया है।

一个上限极小的 RotatingFileHandler：100 字节、3 个备份。逐步执行 14 次写入，看看达到上限时文件如何依次后移。每个快照都取自磁盘上的真实文件。

Logging Exceptions — Keep the Traceback 🧯Exceptions log करना — Traceback रखें 🧯记录异常 — 保留回溯 🧯

import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(name)s:%(message)s")
log = logging.getLogger("calc")

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError as e:
        log.error("Bad: %s", e)                         # message only - no traceback
        log.exception("Failed to divide %s by %s", a, b) # ERROR + full traceback
        return None

divide(10, 0)

dictConfig — The Production Pattern 🏭dictConfig — Production का तरीका 🏭dictConfig — 生产环境的做法 🏭

In a real app you describe the whole setup — formatters, handlers, loggers — in one dictionary, and apply it once at start-up. It can be loaded from a JSON or YAML file, and changed per environment.

असली app में आप पूरा setup — formatters, handlers, loggers — एक dictionary में लिखते हैं, और start-up पर एक बार लागू करते हैं। इसे JSON या YAML file से load किया जा सकता है, और हर environment के लिए बदला जा सकता है।

在真实应用中，你把整套配置 — 格式化器、处理器、记录器 — 写进一个字典，启动时应用一次。它可以从 JSON 或 YAML 文件加载，并按环境区分。

import logging, logging.config

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "standard": {"format": "%(levelname)-8s | %(name)s | %(message)s"},
        "detailed": {"format": "%(levelname)-8s | %(name)s | %(filename)s:%(lineno)d | %(message)s"},
    },
    "handlers": {
        "console": {"class": "logging.StreamHandler", "level": "INFO", "formatter": "standard"},
        "file": {"class": "logging.handlers.RotatingFileHandler", "level": "DEBUG", "formatter": "detailed",
                 "filename": "app.log", "maxBytes": 5_000_000, "backupCount": 5, "encoding": "utf-8"},
        "errors": {"class": "logging.handlers.RotatingFileHandler", "level": "ERROR", "formatter": "detailed",
                   "filename": "errors.log", "maxBytes": 5_000_000, "backupCount": 10, "encoding": "utf-8"},
    },
    "loggers": {
        "myapp": {"handlers": ["console", "file", "errors"], "level": "DEBUG", "propagate": False},
        "urllib3": {"level": "WARNING"},                  # silence a chatty library
    },
    "root": {"handlers": ["console"], "level": "WARNING"},
}
logging.config.dictConfig(LOGGING)

log = logging.getLogger("myapp.orders")
log.debug("Validating order #100")
log.info("Order #100 processed")
log.error("Payment gateway timeout for order #101")
logging.getLogger("urllib3").info("Starting new HTTPS connection")   # dropped

print(sorted(logging.getHandlerNames()))             # Python 3.12+
for name in ["app.log", "errors.log"]:
    print(f"--- {name} ---")
    print(open(name, encoding="utf-8").read(), end="")

Real-World Example — Logging a Flask App 🌐असली उदाहरण — Flask App की Logging 🌐实战示例 — 为 Flask 应用记录日志 🌐

This example really runs: Flask's test client sends three requests without starting a server. You see the access lines, a warning, and a full traceback for the crash — all from one dictConfig.

यह उदाहरण सच में चलता है: Flask का test client बिना server शुरू किए तीन requests भेजता है। आप access lines, एक warning, और crash का पूरा traceback देखते हैं — सब एक dictConfig से।

这个示例是真实运行的：Flask 的测试客户端在不启动服务器的情况下发送了三个请求。你会看到访问日志、一条警告，以及崩溃的完整回溯 — 全部来自一个 dictConfig。

import logging, logging.config, time
from flask import Flask, request, g

logging.config.dictConfig({
    "version": 1,
    "formatters": {"default": {"format": "%(levelname)-8s | %(name)s | %(message)s"}},
    "handlers": {"console": {"class": "logging.StreamHandler", "formatter": "default"}},
    "root": {"handlers": ["console"], "level": "INFO"},
})

app = Flask(__name__)
log = logging.getLogger("shop.api")

@app.before_request
def start_timer():
    g.start = time.perf_counter()

@app.after_request
def log_request(response):
    ms = (time.perf_counter() - g.start) * 1000
    log.info("%s %s -> %d (%s ms)", request.method, request.path, response.status_code,
             "<1" if ms < 1 else round(ms))
    return response

@app.route("/order/<int(signed=True):order_id>")
def get_order(order_id):
    if order_id < 0:
        log.warning("Rejecting negative order id: %s", order_id)
        return {"error": "bad id"}, 400
    if order_id == 13:
        raise RuntimeError("database unavailable")
    return {"id": order_id, "total": 42.0}

@app.errorhandler(Exception)
def unhandled(err):
    log.exception("Unhandled error on %s", request.path)
    return {"error": "internal"}, 500

client = app.test_client()          # send requests without starting a server
for path in ["/order/42", "/order/-1", "/order/13"]:
    client.get(path)

Structured (JSON) Logging 🧾Structured (JSON) Logging 🧾结构化（JSON）日志 🧾

Log tools such as Elasticsearch, Loki or Datadog work best with one JSON object per line: every key becomes a searchable field. Use the python-json-logger package, or write a small formatter yourself.

Elasticsearch, Loki या Datadog जैसे log tools हर line पर एक JSON object के साथ सबसे अच्छा काम करते हैं: हर key खोजने लायक field बन जाती है। python-json-logger package इस्तेमाल करें, या ख़ुद एक छोटा formatter लिखें।

Elasticsearch、Loki、Datadog 等日志工具最适合每行一个 JSON 对象：每个键都成为可搜索的字段。可以用 python-json-logger 包，也可以自己写一个小格式化器。

import logging, json
from pythonjsonlogger.json import JsonFormatter     # pip install python-json-logger

log = logging.getLogger("shop")
log.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter("%(levelname)s %(name)s %(message)s"))
log.addHandler(handler)

log.info("Order placed", extra={"order_id": "ORD-8821", "user_id": 42, "amount": 1299.5, "currency": "INR"})

# No package? A tiny JSON formatter with only the standard library:
class SimpleJson(logging.Formatter):
    def format(self, record):
        data = {"level": record.levelname, "logger": record.name, "msg": record.getMessage()}
        data.update(getattr(record, "ctx", {}))
        return json.dumps(data, ensure_ascii=False)

handler.setFormatter(SimpleJson())
log.info("Refund issued", extra={"ctx": {"order_id": "ORD-8821", "amount": 1299.5}})

Performance — Lazy Formatting ⚡Performance — आलसी Formatting ⚡性能 — 延迟格式化 ⚡

import logging
logging.basicConfig(level=logging.INFO)          # DEBUG is OFF
log = logging.getLogger("perf")

class User:
    def __str__(self):
        print("  (building the user text...)")
        return "Priya"

def expensive_call():
    print("  (expensive_call ran!)")
    return [1, 2, 3]

user = User()
print("1. f-string:")
log.debug(f"User {user}")                      # text is built anyway, then thrown away
print("2. %-style:")
log.debug("User %s", user)                     # str() never runs
print("3. %-style with a function call:")
log.debug("Result %s", expensive_call())       # the ARGUMENT still runs!
print("4. isEnabledFor guard:")
if log.isEnabledFor(logging.DEBUG):
    log.debug("Result %s", expensive_call())   # nothing runs
print("done")

Libraries, Noise, Secrets and Context 🧰Libraries, शोर, Secrets और Context 🧰库、噪音、机密与上下文 🧰

Silencing a Chatty Libraryबातूनी Library को शांत करना让啰嗦的库安静下来

import logging
logging.basicConfig(level=logging.DEBUG, format="%(levelname)-7s %(name)s: %(message)s")

noisy = logging.getLogger("urllib3.connectionpool")   # pretend this is the library
noisy.debug("Starting new HTTPS connection (1): api.example.com:443")
noisy.debug('"GET /v1/users HTTP/1.1" 200 512')

logging.getLogger("urllib3").setLevel(logging.WARNING)   # one line in YOUR app
noisy.debug("Starting new HTTPS connection (2): api.example.com:443")
noisy.warning("Retrying after connection broken")

If You Write a Library: NullHandler, Never basicConfigअगर आप Library लिखते हैं: NullHandler, कभी basicConfig नहीं如果你在写库：用 NullHandler，绝不用 basicConfig

# Inside a LIBRARY you publish (e.g. mylib/__init__.py):
import logging
logging.getLogger("mylib").addHandler(logging.NullHandler())   # never basicConfig()!

def work():
    logging.getLogger("mylib").info("working...")   # silent unless the APP configures logging

work()
print("an app that never configured logging sees nothing from mylib")

logging.basicConfig(level=logging.INFO, format="%(name)s: %(message)s")   # the APP decides
work()

Hiding Passwords with a FilterFilter से Passwords छिपाना用过滤器隐藏密码

import logging, re

class Redact(logging.Filter):
    PATTERN = re.compile(r"(password|token)=\S+", re.IGNORECASE)
    def filter(self, record):
        record.msg = self.PATTERN.sub(r"\1=***", record.getMessage())
        record.args = ()
        return True                                 # keep the (cleaned) record

handler = logging.StreamHandler()
handler.addFilter(Redact())
handler.setFormatter(logging.Formatter("%(levelname)s %(message)s"))
log = logging.getLogger("auth")
log.addHandler(handler)
log.setLevel(logging.INFO)

log.info("Login user=%s password=%s", "priya", "hunter2")
log.info("Calling API with token=abc123XYZ")

Adding Context to Every Lineहर Line में Context जोड़ना为每一行添加上下文

import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s [req=%(request_id)s] %(message)s")

base = logging.getLogger("shop")
log = logging.LoggerAdapter(base, {"request_id": "a1b2c3"})   # adds context to every line
log.info("Cart loaded")
log.warning("Item %s is out of stock", "SKU-77")

Common Pitfalls 🕳️आम ग़लतियाँ 🕳️常见陷阱 🕳️

import logging

# 1. No configuration at all: the "last resort" handler prints WARNING+ to stderr
log = logging.getLogger("app")
log.info("lost - nobody shows INFO")
log.warning("shown by the last-resort handler")

# 2. Adding a handler on every call = duplicate lines
def get_logger():
    lg = logging.getLogger("dup")
    lg.addHandler(logging.StreamHandler())       # BUG: runs every time
    return lg
get_logger(); get_logger().warning("printed twice!")

# 3. basicConfig() does nothing once the root logger has handlers
logging.warning("this call quietly runs basicConfig() first")
logging.basicConfig(level=logging.DEBUG, format=">> %(message)s")   # ignored!
logging.debug("not shown")
logging.basicConfig(level=logging.DEBUG, format=">> %(message)s", force=True)
logging.debug("shown after force=True")

logging vs print vs loguru ⚖️logging बनाम print बनाम loguru ⚖️logging、print 与 loguru ⚖️

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题