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

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

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

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

Он не полностью надежный, к сожалению, но он работает большую часть времени.

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

Я почти всегда имею дело с несколькими потоками, и основной поток, как правило, мало что делает, поэтому самое интересное - сбросить все стеки (что больше похоже на дамп 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)

Получение трассировки стека неподготовленной программы python, работающей на питоне запаса без отладочных символов, можно сделать с помощью pyrasite. Работал как прелесть для меня в 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, ответ которой содержал указатель на это, среди других инструментов.)

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

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

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

Изменить. Чтобы моделировать поведение Java, как было предложено @Douglas Leeder, добавьте это:

import signal
import traceback

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

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

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

import traceback

traceback.print_stack()

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

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

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

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

Что мне действительно помогло, это spiv tip (который я бы проголосовал и прокомментировал, если бы у меня были очки репутации) для получения трассировки стека из неподготовленного Python. Кроме того, что это не сработало, пока я не изменил gdbinit script. Итак:

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

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

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

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

Я бы добавил это как комментарий к ответах 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)

python -dv yourscript.py

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

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

python -m pdb yourscript.py

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

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

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

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

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

Это дает команду gdb подготовить python <programname>.py <arguments> и r un it.

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

(gdb) thread apply all py-list

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

В 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.

Я искал какое-то время для решения отладки моих потоков, и я нашел его здесь благодаря 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)

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

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

Проект Summer of Code 2006 года рассмотрел возможность добавления удаленных отладочных функций в pydb в модуле mpdb.

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

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

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

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

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

from pudb import set_interrupt_handler; set_interrupt_handler()

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

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

К сожалению, часто сторонник является наблюдателем, который "исправляет" условия гонки, так что выход тоже бесполезен.

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

Я нахожусь в лагере 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.

В Python 3 pdb автоматически установит обработчик сигнала при первом использовании c (onue (inue)) в отладчике. После этого нажатие Ctrl-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.

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

  

импорт проверить     помощь (inspect.stack)     Справка по стеку функций в модуле:

  

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

Я считаю это очень полезным.

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

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

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

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

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

Создайте функцию, в которой вы используете 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) 

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