Git-форензика: когда появилась проблема и как она прошла мимо всех

Как найти коммит, в котором появилась опасная строка, восстановить таймлайн инцидента и сделать из этого вывод, а не список виноватых.

v2 0 stars 0 forks 0 watchers 1 branch 0 runs Public
Исправлены сбитые символы ё и кавычкиv2
Зачем это нужно

Типичная ситуация: что-то сломалось или выстрелило, ты нашёл в файле строку, которая всё объясняет. Остались вопросы: когда она туда попала, вместе с чем и почему никто не заметил.

Главное сразу: цель расследования — не виноватый, а механизм. Фамилия в коммите ничего не чинит. Ответ на вопрос «как это прошло ревью и выкатку» — чинит.

Список непоследовательный — бери ту команду, которая подходит к твоему вопросу.

Подготовка

Убедиться, что история вообще есть

Самая обидная преграда: репозиторий клонировали с обрезанной историей, и старых коммитов просто нет.

bash
1git rev-parse --is-shallow-repository # true = история обрезана
2git fetch --unshallow # дотянуть всю
3git log --oneline | wc -l # сколько коммитов теперь

Так бывает чаще, чем кажется: системы развёртывания клонируют с --depth 1 ради скорости.

Why: На обрезанной истории `git log` по файлу покажет один коммит и создаст впечатление, что файл сразу таким и родился. Можно потратить час на неверный вывод.
$git rev-parse --is-shallow-repository
Check
  • Команда отвечает false
  • Число коммитов похоже на правду

Поиск

Найти коммит, где появилась конкретная строка

Главный инструмент расследования — флаг -S, в документации он называется pickaxe, «кирка»:

bash
1# коммиты, где число вхождений строки изменилось
2git log -S'5432:5432' --oneline -- docker-compose.yml
3
4# то же, но сразу с датами и авторами
5git log -S'5432:5432' --format='%h %ad %an %s' --date=short
6
7# если нужна регулярка по тексту изменений
8git log -G'ports:\s*$' --oneline

Разница между ними важная. -S ищет коммиты, где строка появилась или исчезла. -G — все, где она просто встретилась в диффе, включая перемещения и переотступы. Для вопроса «когда это появилось» нужен -S.

Why: Поиск глазами по `git log -p` работает на десятке коммитов и проваливается на тысяче. `-S` даёт ответ за секунды на любом размере истории.
$git log -S'искомая строка' --format='%h %ad %an %s' --date=short
Check
  • Найден коммит, в котором строка появилась
  • Ты понимаешь разницу между -S и -G
Посмотреть историю файла через переименованияRecommended
bash
1git log --oneline --follow -- путь/к/файлу

Флаг --follow продолжает историю через переименования и перемещения. Без него история обрывается в точке, где файл переехал в другую папку.

Работает только с одним путём — это ограничение самой команды.

Why: Файлы переезжают при любой перестройке структуры. Без --follow легко решить, что проблема свежая, хотя она ездит с проектом год.
$git log --oneline --follow -- путь/к/файлу
Check
  • Видна вся история файла, включая жизнь под старым именем
Прочитать файл таким, каким он был в тот момент

Когда коммит найден, нужно увидеть контекст целиком, а не только строку:

bash
1# файл целиком на момент коммита
2git show <sha>:путь/к/файлу
3
4# только изменения по этому файлу
5git show <sha> -- путь/к/файлу
6
7# что ещё ехало в том же коммите
8git show --stat <sha>

Обрати внимание на двоеточие против двойного тире: <sha>:путь — содержимое файла, <sha> -- путь — дифф.

Why: Отдельная строка часто выглядит глупостью, а в контексте оказывается частью большого коммита на сотни строк — такого, который физически невозможно внимательно проревьюить. Это уже ответ на вопрос «как прошло мимо».
$git show --stat <sha>
Check
  • Виден весь файл на момент коммита
  • Известен размер того коммита целиком
Посмотреть построчно, откуда взялась каждая строкаRecommended
bash
1# только нужный диапазон строк
2git blame -L 40,55 путь/к/файлу
3
4# игнорировать правки пробелов и отследить перенос строк из других файлов
5git blame -w -C -C -L 40,55 путь/к/файлу

Флаги важны: -w игнорирует изменения пробелов, -C -C ищет, откуда строку скопировали. Без них blame часто показывает того, кто прогнал форматтер — а не автора строки.

Why: Половина претензий к blame — из-за этих флагов. Люди видят чужую фамилию, махают рукой и решают, что инструмент врёт.
$git blame -w -C -C -L 40,55 путь/к/файлу
Check
  • Ты понимаешь, зачем нужны -w и -C
Если опорной строки нет — бинарный поискRecommended

Когда известно только «раньше работало, теперь нет»:

bash
1git bisect start
2git bisect bad # текущий — сломанный
3git bisect good <старый-sha> # там было хорошо
4
5# git переключает на середину, ты проверяешь и говоришь:
6git bisect good # или
7git bisect bad
8
9git bisect reset # вернуться как было

Если проверку можно автоматизировать, git сделает всё сам:

bash
1git bisect run ./check.sh # код 0 = хорошо, не 0 = плохо

За 20 шагов просеивается миллион коммитов — это обычный двоичный поиск.

Why: Не всякая проблема выражается строкой, которую можно поискать. Падение производительности или плавающая ошибка ищется только так.
$git bisect start
Check
  • Ты знаешь про git bisect run
  • Помнишь про git bisect reset в конце
Собрать таймлайн

Отдельный коммит мало что говорит. Смысл появляется, когда время из git ложится рядом со временем из системных логов:

bash
1# события из git за период
2git log --since='2 weeks ago' --format='%ad %h %an %s' --date=iso
3
4# события системы за тот же период
5journalctl --since '2025-10-08' --until '2025-10-14' | grep -i 'oom\|killed'
6
7# когда контейнер создали и запустили
8docker inspect --format '{{.Created}} {{.State.StartedAt}}' имя

В разобранном случае таймлайн выглядел так:

ВремяИсточникСобытие
08:07gitкоммит с открытым портом
~08:30dockerконтейнер создан
16:29системный логOOM killer убил неизвестный процесс

Последняя строка — самая важная. Сигнал был в первый же день, просто его никто не читал. Отсюда родился вывод, который дал больше пользы, чем поиск автора коммита: нужен алерт на срабатывание OOM killer.

Главное правило разбора

Когда виновная строка найдена, появляется соблазн написать в отчёте фамилию автора и распределить ответственность в процентах. Это бесполезно и вредно.

Бесполезно — потому что не меняет вероятность повтора. Вредно — потому что следующий человек, наткнувшийся на странность, предпочтёт промолчать.

Заканчивай разбор тремя пунктами:

  1. Что сработало как надо. Аварию всё-таки заметили — как именно?
  2. Где был шанс поймать раньше. Не «кто пропустил», а «какой проверки не было».
  3. Какая проверка поймала бы это автоматически. И сразу завести на неё задачу.

Для того инцидента ответ на третий пункт — проверка в конвейере, которая не пускает в бой compose-файл с прокинутым портом базы:

bash
1# в простейшем виде — одна строка в конвейере
2grep -nE '^\s*-\s*"?[0-9]+:(5432|6379|3306|27017)"?' docker-compose.yml && exit 1

Такая строка полезнее любого вывода о том, кто виноват.

Шпаргалка
bash
1# есть ли история
2git rev-parse --is-shallow-repository
3git fetch --unshallow
4
5# когда появилась строка
6git log -S'строка' --format='%h %ad %an %s' --date=short
7git log -G'регулярка' --oneline
8
9# история файла
10git log --oneline --follow -- путь
11
12# состояние на момент
13git show <sha>:путь # файл целиком
14git show <sha> -- путь # только дифф
15git show --stat <sha> # что ещё ехало рядом
16
17# построчно
18git blame -w -C -C -L 40,55 путь
19
20# если строки нет
21git bisect start / bad / good / run ./check.sh / reset
Чем отличается git log -S от git log -G?
git log по файлу показывает всего один коммит — «initial commit». Что проверить первым делом?
Чем должен заканчиваться разбор инцидента?