Отображение трассировки стека из запущенного приложения Python

python -dv yourscript.py

Это заставит интерпретатор работать в режиме отладки и даст вам представление о том, что делает интерпретатор.

Если вы хотите отладить код в интерактивном режиме, запустите его следующим образом:

python -m pdb yourscript.py

Это говорит интерпретатору Python запустить ваш скрипт с модулем «pdb», который является отладчиком Python, если вы запустите его так, что интерпретатор будет выполняться в интерактивном режиме, во многом как GDB

В модуле проследить есть несколько хороших функций, среди которых: print_stack:

import traceback

traceback.print_stack()

>>> import traceback
>>> def x():
>>>    print traceback.extract_stack()

>>> x()
[('<stdin>', 1, '<module>', None), ('<stdin>', 2, 'x', None)]

Вы также можете красиво отформатировать трассировку стека, см. документы.

Редактировать: Чтобы смоделировать поведение Java, как предлагает @Douglas Leeder, добавьте это:

import signal
import traceback

signal.signal(signal.SIGUSR1, lambda sig, stack: traceback.print_stack(stack))

к коду запуска в вашем приложении. Затем вы можете распечатать стек, отправив SIGUSR1 в работающий процесс Python.

Я не знаю ничего похожего на ответ java на SIGQUIT, поэтому вам, возможно, придется встроить его в свое приложение. Может быть, вы могли бы создать сервер в другом потоке, который мог бы получать трассировку стека при ответе на какое-либо сообщение?

Невозможно подключиться к работающему процессу Python и получить разумные результаты. Что я делаю, если процессы блокируются, - это подключаю strace и пытаюсь понять, что именно происходит.

К сожалению, часто strace - это наблюдатель, который «исправляет» условия гонки, так что результат здесь тоже бесполезен.

У меня есть модуль, который я использую для подобных ситуаций - когда процесс будет работать долгое время, но иногда застревает по неизвестным и невоспроизводимым причинам. Это немного взломано и работает только в unix (требует сигналов):

import code, traceback, signal

def debug(sig, frame):
    """Interrupt running process, and provide a python prompt for
    interactive debugging."""
    d = {'_frame':frame}         # Allow access to frame object.
    d.update(frame.f_globals)  # Unless shadowed by global
    d.update(frame.f_locals)

    i = code.InteractiveConsole(d)
    message  = "Signal received : entering python shell.\nTraceback:\n"
    message += ''.join(traceback.format_stack(frame))
    i.interact(message)

def listen():
    signal.signal(signal.SIGUSR1, debug)  # Register handler

Чтобы использовать, просто вызовите функцию listen () в какой-то момент при запуске вашей программы (вы даже можете вставить ее в site.py, чтобы все программы Python использовали ее) и дайте ей поработать. В любой момент отправьте процессу сигнал SIGUSR1, используя kill или Python:

    os.kill(pid, signal.SIGUSR1)

Это приведет к тому, что программа переключится на консоль python в той точке, в которой она сейчас находится, показывая вам трассировку стека и позволяя вам манипулировать переменными. Используйте control-d (EOF) для продолжения работы (хотя учтите, что вы, вероятно, прервете любой ввод / вывод и т. д. В точке, о которой вы сигнализируете, поэтому это не будет полностью ненавязчивым.

У меня есть другой скрипт, который делает то же самое, за исключением того, что он взаимодействует с запущенным процессом через канал (для отладки фоновых процессов и т. д.). Его немного больше для публикации, но я добавил его как рецепт поваренной книги python.

Предложение установить обработчик сигналов - хорошее, и я часто им пользуюсь. Например, БЗР по умолчанию устанавливает обработчик SIGQUIT, который вызывает pdb.set_trace(), чтобы немедленно перенаправить вас в приглашение PDB. (Точные сведения см. В источнике модуля bzrlib.breakin.) С помощью pdb вы можете не только получить текущую трассировку стека (с помощью команды (w)here), но также проверить переменные и т. д.

Однако иногда мне нужно отладить процесс, в котором я не предусмотрительно установил обработчик сигналов. В Linux вы можете присоединить к процессу gdb и получить трассировку стека python с помощью некоторых макросов gdb. Поместите http://svn.python.org/projects/python/trunk/Misc/gdbinit в ~/.gdbinit, затем:

• Прикрепите gdb: gdb -pPID
• Получите трассировку стека python: pystack

К сожалению, это не совсем надежно, но в большинстве случаев работает.

Наконец, подключение strace часто может дать вам хорошее представление о том, что делает процесс.

Стоит взглянуть на Pydb, «расширенную версию отладчика Python, основанную на наборе команд gdb». Он включает менеджеры сигналов, которые могут позаботиться о запуске отладчика при отправке указанного сигнала.

В проекте Summer of Code 2006 года рассматривалось добавление функций удаленной отладки в pydb в модуле mpdb.

Что действительно помогло мне здесь, так это наконечник спива (за который я бы проголосовал и прокомментировал, если бы у меня были очки репутации) для получения трассировки стека из процесса неподготовленный Python. За исключением того, что это не сработало, пока я не модифицировал скрипт gdbinit. Так:

• скачать http://svn.python.org/projects/python/trunk/Misc/gdbinit и поставить в ~/.gdbinit

• отредактируйте его, изменив PyEval_EvalFrame на PyEval_EvalFrameEx [редактировать: больше не требуется; связанный файл уже содержит это изменение по состоянию на 14 января 2010 г.]

• Прикрепите gdb: gdb -p PID

• Получите трассировку стека python: pystack

использовать модуль проверки.

import inspect help(inspect.stack) Help on function stack in module inspect:

стек (контекст = 1) Вернуть список записей для стека над кадром вызывающего.

Я нахожу это действительно очень полезным.

Я почти всегда имею дело с несколькими потоками, а основной поток, как правило, мало что делает, поэтому наиболее интересно выгружать все стеки (что больше похоже на дамп Java). Вот реализация, основанная на этот блог:

import threading, sys, traceback

def dumpstacks(signal, frame):
    id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
    code = []
    for threadId, stack in sys._current_frames().items():
        code.append("\n# Thread: %s(%d)" % (id2name.get(threadId,""), threadId))
        for filename, lineno, name, line in traceback.extract_stack(stack):
            code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
            if line:
                code.append("  %s" % (line.strip()))
    print "\n".join(code)

import signal
signal.signal(signal.SIGQUIT, dumpstacks)

Я бы добавил это как комментарий к ответ haridsv, но у меня нет репутации для этого:

Некоторые из нас все еще застряли на версии Python старше 2.6 (требуется для Thread.ident), поэтому я получил код, работающий в Python 2.5 (хотя и без отображения имени потока) как таковой:

import traceback
import sys
def dumpstacks(signal, frame):
    code = []
    for threadId, stack in sys._current_frames().items():
            code.append("\n# Thread: %d" % (threadId))
        for filename, lineno, name, line in traceback.extract_stack(stack):
            code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
            if line:
                code.append("  %s" % (line.strip()))
    print "\n".join(code)

import signal
signal.signal(signal.SIGQUIT, dumpstacks)

В Solaris вы можете использовать pstack (1) Никаких изменений в коде Python не требуется. например.

# pstack 16000 | grep : | head
16000: /usr/bin/python2.6 /usr/lib/pkg.depotd --cfg svc:/application/pkg/serv
[ /usr/lib/python2.6/vendor-packages/cherrypy/process/wspbus.py:282 (_wait) ]
[ /usr/lib/python2.6/vendor-packages/cherrypy/process/wspbus.py:295 (wait) ]
[ /usr/lib/python2.6/vendor-packages/cherrypy/process/wspbus.py:242 (block) ]
[ /usr/lib/python2.6/vendor-packages/cherrypy/_init_.py:249 (quickstart) ]
[ /usr/lib/pkg.depotd:890 (<module>) ]
[ /usr/lib/python2.6/threading.py:256 (wait) ]
[ /usr/lib/python2.6/Queue.py:177 (get) ]
[ /usr/lib/python2.6/vendor-packages/pkg/server/depot.py:2142 (run) ]
[ /usr/lib/python2.6/threading.py:477 (run)
etc.

Взгляните на модуль faulthandler, новый в Python 3.3. faulthandler задний порт для использования в Python 2 доступен в PyPI.

Я собрал инструмент, который подключается к работающему процессу Python и вводит код для получения оболочки Python.

Смотрите здесь: https://github.com/albertz/pydbattach

Некоторое время я искал решение для отладки своих потоков и нашел его здесь благодаря haridsv. Я использую немного упрощенную версию, использующую traceback.print_stack ():

import sys, traceback, signal
import threading
import os

def dumpstacks(signal, frame):
  id2name = dict((th.ident, th.name) for th in threading.enumerate())
  for threadId, stack in sys._current_frames().items():
    print(id2name[threadId])
    traceback.print_stack(f=stack)

signal.signal(signal.SIGQUIT, dumpstacks)

os.killpg(os.getpgid(0), signal.SIGQUIT)

Для своих нужд я также фильтрую темы по имени.

Вы можете попробовать модуль обработки неисправностей. Установите его с помощью pip install faulthandler и добавьте:

import faulthandler, signal
faulthandler.register(signal.SIGUSR1)

в начале вашей программы. Затем отправьте SIGUSR1 вашему процессу (например, kill -USR1 42), чтобы отобразить трассировку Python всех потоков в стандартный вывод. Прочтите документацию для дополнительных опций (например: войти в файл) и других способов отображения трассировки.

Модуль теперь является частью Python 3.3. Для Python 2 см. http://faulthandler.readthedocs.org/

Для этого вы можете использовать PuDB, отладчик Python с интерфейсом curses. Просто добавь

from pudb import set_interrupt_handler; set_interrupt_handler()

в свой код и используйте Ctrl-C, если хотите прервать работу. Вы можете продолжить с c и несколько раз прервать работу, если пропустите и захотите повторить попытку.

Если вы работаете в системе Linux, используйте преимущества gdb с расширениями отладки Python (могут быть в пакете python-dbg или python-debuginfo). Он также помогает с многопоточными приложениями, приложениями с графическим интерфейсом пользователя и модулями C.

Запустите вашу программу с помощью:

$ gdb -ex r --args python <programname>.py [arguments]

Это указывает gdb на подготовку python <programname>.py <arguments> и r к его запуску.

Теперь, когда программа зависает, переключитесь на консоль gdb, нажмите Ctr+C и выполните:

(gdb) thread apply all py-list

См. пример сеанса и дополнительную информацию здесь и здесь.

пирог - это отладчик, который может взаимодействовать с запущенными процессами Python, трассировками стека печати, переменными и т. д. Без какой-либо априорной настройки.

Несмотря на то, что в прошлом я часто использовал решение для обработки сигналов, все еще может быть сложно воспроизвести проблему в определенных средах.

В Python 3 pdb автоматически устанавливает обработчик сигнала при первом использовании c (ont (inue)) в отладчике. После нажатия Control-C вы вернетесь туда. В Python 2 есть однострочник, который должен работать даже в относительно старых версиях (проверено в 2.7, но я проверил исходный код Python до версии 2.4, и все выглядело нормально):

import pdb, signal
signal.signal(signal.SIGINT, lambda sig, frame: pdb.Pdb().set_trace(frame))

pdb стоит изучить, если вы тратите какое-то время на отладку Python. Интерфейс немного тупой, но должен быть знаком всем, кто использовал подобные инструменты, такие как gdb.

Получение трассировки стека программы python неподготовленный, работающей на стандартном питоне без отладочных символов, можно выполнить с помощью пиразит. Сработало для меня как шарм в Ubuntu Trusty:

$ sudo pip install pyrasite
$ echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
$ sudo pyrasite 16262 dump_stacks.py # dumps stacks to stdout/stderr of the python program

(Подсказка @Albert, чей ответ содержал указатель на это, среди других инструментов.)

Если вам нужно сделать это с помощью uWSGI, у него есть встроенный Трассировщик Python, и это просто вопрос включения его в конфигурации (номер привязан к имени для каждого рабочего):

py-tracebacker=/var/run/uwsgi/pytrace

Как только вы это сделаете, вы можете распечатать backtrace, просто подключившись к сокету:

uwsgi --connect-and-read /var/run/uwsgi/pytrace1

Я нахожусь в лагере GDB с расширениями python. Следуйте https://wiki.python.org/moin/DebuggingWithGdb, что означает

1. dnf install gdb python-debuginfo или sudo apt-get install gdb python2.7-dbg
2. gdb python <pid of running process>
3. py-bt

Также рассмотрите info threads и thread apply all py-bt.

Как отлаживать любую функцию в консоли:

Создать функцию, где вы используйте pdb.set_trace (), затем функцию, которую вы хотите отладить.

>>> import pdb
>>> import my_function

>>> def f():
...     pdb.set_trace()
...     my_function()
... 

Затем вызовите созданную функцию:

>>> f()
> <stdin>(3)f()
(Pdb) s
--Call--
> <stdin>(1)my_function()
(Pdb) 

Удачной отладки :)

Это можно сделать с помощью отличного пи-шпион. Это профилировщик выборки для программ Python, поэтому его задача - подключиться к процессам Python и выбрать их стеки вызовов. Следовательно, py-spy dump --pid $SOME_PID - это все, что вам нужно для дампа стеков вызовов всех потоков в процессе $SOME_PID. Обычно ему требуются повышенные привилегии (для чтения памяти целевого процесса).

Вот пример того, как это выглядит для многопоточного приложения Python.

$ sudo py-spy dump --pid 31080
Process 31080: python3.7 -m chronologer -e production serve -u www-data -m
Python v3.7.1 (/usr/local/bin/python3.7)

Thread 0x7FEF5E410400 (active): "MainThread"
    _wait (cherrypy/process/wspbus.py:370)
    wait (cherrypy/process/wspbus.py:384)
    block (cherrypy/process/wspbus.py:321)
    start (cherrypy/daemon.py:72)
    serve (chronologer/cli.py:27)
    main (chronologer/cli.py:84)
    <module> (chronologer/__main__.py:5)
    _run_code (runpy.py:85)
    _run_module_as_main (runpy.py:193)
Thread 0x7FEF55636700 (active): "_TimeoutMonitor"
    run (cherrypy/process/plugins.py:518)
    _bootstrap_inner (threading.py:917)
    _bootstrap (threading.py:885)
Thread 0x7FEF54B35700 (active): "HTTPServer Thread-2"
    accept (socket.py:212)
    tick (cherrypy/wsgiserver/__init__.py:2075)
    start (cherrypy/wsgiserver/__init__.py:2021)
    _start_http_thread (cherrypy/process/servers.py:217)
    run (threading.py:865)
    _bootstrap_inner (threading.py:917)
    _bootstrap (threading.py:885)
...
Thread 0x7FEF2BFFF700 (idle): "CP Server Thread-10"
    wait (threading.py:296)
    get (queue.py:170)
    run (cherrypy/wsgiserver/__init__.py:1586)
    _bootstrap_inner (threading.py:917)
    _bootstrap (threading.py:885)  

В момент запуска кода вы можете вставить этот небольшой фрагмент, чтобы увидеть хорошо отформатированную трассировку напечатанного стека. Предполагается, что у вас есть папка logs в корневом каталоге вашего проекта.

# DEBUG: START DEBUG -->
import traceback

with open('logs/stack-trace.log', 'w') as file:
    traceback.print_stack(file=file)
# DEBUG: END DEBUG --!

Вы можете использовать пакет гипно, например:

hypno <pid> "import traceback; traceback.print_stack()"

Это выведет трассировку стека в стандартный вывод программы.

В качестве альтернативы, если вы не хотите ничего выводить на стандартный вывод или у вас нет доступа к нему (например, демон), вы можете использовать пакет Madbg, который является отладчиком python, который позволяет вам подключаться к запущенному python и отлаживайте ее в своем текущем терминале. Он похож на pyrasite и pyringe, но новее, не требует GDB и использует IPython для отладчика (что означает цвета и автозаполнение).

Чтобы увидеть трассировку стека запущенной программы, вы можете запустить:

madbg attach <pid>

И в оболочке отладчика введите: bt

Отказ от ответственности - я написал оба пакета