Логирование что это – Работа с потоком логов в реальном времени с помощью Heka. Опыт Яндекс.Денег / Яндекс.Деньги corporate blog / Habr

Содержание

логирование — Викисловарь

Содержание

  • 1 Русский
    • 1.1 Морфологические и синтаксические свойства
    • 1.2 Произношение
    • 1.3 Семантические свойства
      • 1.3.1 Значение
      • 1.3.2 Синонимы
      • 1.3.3 Антонимы
      • 1.3.4 Гиперонимы
      • 1.3.5 Гипонимы
    • 1.4 Родственные слова
    • 1.5 Этимология
    • 1.6 Фразеологизмы и устойчивые сочетания
    • 1.7 Перевод
    • 1.8 Библиография

Морфологические и синтаксические свойства[править]

логирование

Существительное, неодушевлённое, средний род (тип склонения ?? по классификации А. А. Зализняка).

Корень: --.

Произношение[править]

Семантические свойства[править]

Значение[править]
  1. запись в лог, ведение лога ◆ Выполнить чистку всех сохранённых данных по аудиту, в которых проведено логирование всей цепочки прошедших операций. Константин Муравьёв, «Неучтённый», 2015 г.
Синонимы[править]
Антонимы[править]
Гиперонимы[править]
Гипонимы[править]

Родственные слова[править]

Ближайшее родство
  • существительные: лог
  • глаголы: логировать

Этимология[править]

Происходит от ??

Фразеологизмы и устойчивые сочетания[править]

Перевод[править]

Список переводов

Библиография[править]

Interrobang.svg Для улучшения этой статьи желательно:
  • Уточнить парадигму словоизменения, используя более конкретный шаблон словоизменения
  • Добавить описание морфемного состава с помощью {{морфо-ru}}
  • Добавить транскрипцию в секцию «Произношение» с помощью {{transcriptions-ru}}
  • Добавить синонимы в секцию «Семантические свойства»
  • Добавить гиперонимы в секцию «Семантические свойства»
  • Добавить сведения об этимологии в секцию «Этимология»
  • Добавить хотя бы один перевод в секцию «Перевод»

Архитектура логирования / Habr

Мой опыт разработки в основном строится вокруг разнообразных сетевых cервисов под Windows и Linux. Я обычно стремлюсь добиться максимальной кроссплатформенности вплоть до бинарной совместимости. И конечно, накопилось некоторое количество стабильных решений связанных с логированием.

Топик написан как продолжение к этой статье и будет полезен в первую очередь начинающим программистам.

Здесь я собираюсь осветить следующие вопросы:

  • Внутреннее свойство логгера и примеры софта который его использует.
  • Объемы, уровни и детализация сообщений лога.
  • Общие правила конфигурации в разработке, в бою и в расследовании.

Итак, начну со своих дополнений к предыдущей статье.
Я как и автор пользуюсь NLog'ом и разумеется широко использую его особенности. Конечно, после
их реализации в любом другом логгере, нижеописанную практику можно применять и у них.

Кстати, log4net продолжает развиваться.

Собственно, требуемых дополнений к «Фичам добропорядочного логгера» всего два:

  1. Наблюдение/перезагрузка файла конфигурации — это уже не просто полезное, а весьма необходимое умение.
  2. Минимальное вмешательство в выключенном состоянии.
Под капотом NLog

Сразу обсудим полезность второй фичи.

Часто, при разработке кода, возникает необходимость посмотреть значение какой либо переменной в процессе выполнения. Обычно, используют дебаггер и останавливают программу в интересующем месте. Для меня же, это явный признак, что этом месте будет полезен Trace вывод. В комплекте с юнит-тестами мы сразу получаем развертку этой переменной во времени и протокол для сравнения с тестами в других условиях. Таким образом, дебаггером я практически не пользуюсь.

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

В NLog используются следующие приемы:

  • Кэширование уровня логирования в volatile переменной. Это не требует блокировки или синхронизации потоков.
  • Простой метод выяснения необходимости логирования. При некоторых условиях может приводить к inline-вставке кода в процессе jit-компиляции. А это превращает логику в простой условный пропуск участка кода и избавляет от копирования и передачи параметров функции логирования.
  • Подробные перегрузки методов логирования. Минимизируют преобразование типов, а также берегут от напрасного боксинга, до того как мы выяснили о необходимости логирования.
  • Отложенная генерация сообщения делегатом. Позволяет наглядно и легко задавать сложную генерацию сообщений.

Исходный код класса можно посмотреть тут.

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

Что и как логировать

Следует придерживаться правил:

  • Вывод в лог следует размещать на отдельной строке.
  • Сообщение должно быть максимально коротким и информативным.
  • Локализовывать можно только редкие или фатальные сообщения.
  • Аргументы желательно брать из локальных переменных метода или внутренних переменных класса данного метода.
  • Не желательно использовать преобразования типов.

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

Простой пример (фрагмент некоторого класса):

private static Logger Log = LogManager.GetCurrentClassLogger();<br/>
 <br/>
public string Request(string cmd, string getParams)<br/>
{<br/>
    Uri uri = new Uri(_baseUri, cmd + "?" + getParams);<br/>
    Log.Debug("Request for uri:`{0}'", uri);<br/>
    HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(uri);<br/>
    webReq.Method = "GET";<br/>
    webReq.Timeout = _to;<br/>
 <br/>
    string respText;<br/>
    try<br/>
    {<br/>
        string page;<br/>
        using (WebResponse resp = webReq.GetResponse())<br/>
        using (Stream respS = resp.GetResponseStream())<br/>
        using (StreamReader sr = new StreamReader(respS))<br/>
            page = sr.ReadToEnd();<br/>
        Log.Trace("Response page:`{0}'", page);<br/>
        return page;<br/>
    }<br/>
    catch(Exception err)<br/>
    {<br/>
        Log.Warn("Request for uri:`{0}' exception: {1}", uri, err.Message);<br/>
        throw;<br/>
    }<br/>
}

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

Вообще, в текущем обработчике ошибок полезно детализировать контекст который к привел к исключению и специфичные особенности исключения. В примере было бы полезно вывести поле Status для случая WebException.

Гарантии сохранности лога

Несмотря на некоторые возможности NLog по авто записи логов, нет гарантии сохранности лога при завершении процесса.

Что интересно, попытка завершить запись обработкой события

AppDomain.ProcessExit не совсем корректна. В конфигурации может быть настроено много разных способов записи в лог, в том числе и по сети. А обработчик этого события находится в ограниченном окружении. В .Net это время работы не более 2х секунд, а в Mono это остановленный ThreadPool. Поэтому, полезно позаботиться о завершении процесса в более дружественном окружении.

Первое, что следует сделать, это обработать событие AppDomain.UnhandledException. В нем следует записать в лог полную информацию об ошибке и вызвать LogManager.Flush(). Обработчик этого события использует тот же поток, который и вызвал исключение, а по окончании, немедленно выгружает приложение.

private static readonly Logger Log = LogManager.GetCurrentClassLogger();<br/>
 <br/>
public static void Main(string[] args)<br/>
{<br/>
    AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;<br/>
    (...)<br/>
    LogManager.Flush();<br/>
}<br/>
 <br/>
static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)<br/>
{<br/>
    Log.Fatal("Unhandled exception: {0}", e.ExceptionObject);<br/>
    LogManager.Flush();<br/>
}

Кроме того, следует вызывать LogManager.Flush() везде, где потенциально возможно завершение процесса. В конце всех не фоновых потоков.

Если ваше приложение представляет собой win-service или Asp.Net, то следует обработать соответствующие события начала и завершения кода.

Сколько логировать

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

Вывод в лог это по сути комментарий. Логирование уровня Trace по большей части их и заменяет.
Уровни Trace и Debug читают разработчики, а все что выше — техподдержка и админы. Поэтому до уровня Info сообщения должны точно отвечать на вопросы: «Что произошло?», «Почему?» и по возможности «Как исправить?». Особенно это касается ошибок в файлах конфигурации.

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

  • Trace — вывод всего подряд. На тот случай, если Debug не позволяет локализовать ошибку. В нем полезно отмечать вызовы разнообразных блокирующих и асинхронных операций.
  • Debug — журналирование моментов вызова «крупных» операций. Старт/остановка потока, запрос пользователя и т.п.
  • Info — разовые операции, которые повторяются крайне редко, но не регулярно. (загрузка конфига, плагина, запуск бэкапа)
  • Warning — неожиданные параметры вызова, странный формат запроса, использование дефолтных значений в замен не корректных. Вообще все, что может свидетельствовать о не штатном использовании.
  • Error — повод для внимания разработчиков. Тут интересно окружение конкретного места ошибки.
  • Fatal — тут и так понятно. Выводим все до чего дотянуться можем, так как дальше приложение работать не будет.
Боевое развертывание

Предположим, разработка дошла до внедрения.
Отложим вопросы ротации логов, размера файлов и глубины истории. Это все очень специфично для каждого проекта и настраивается в зависимости от реальной работы сервиса.

Остановлюсь только на смысловой организации файлов. Их следует разделить на 3 группы. Может потребуется развести логи модулей в разные файлы, но дальше я все равно буду говорить об одном файле для каждой группы.

  1. Группа Info, с соответствующим уровнем для всех источников. Это информация для администратора. Здесь могут быть следующие вещи: когда приложение стартовало, правильно ли вычитаны конфиги, доступны ли требуемые сервисы, и т.д. Его основное свойство: файл изменяет размер только при перезагрузке приложения. В процессе работы, файл расти не должен. Это поможет обеспечить автоматизированный внешний контроль успешности запуска приложения. Достаточно проверить отсутствие в файле ключевых слов Error и Fatal. Проверка всегда будет занимать предсказуемо малое время.
  2. Группа Warning. Это тоже информация для администратора. Этот файл при нормальной работе должен отсутствовать или быть пустым. Соответственно мониторинг его состояния сразу укажет на сбои в работе. Гибко настроив фильтры по разным источникам, можно подобрать достаточно точный критерий, когда вообще следует обратить внимание на сервис.
  3. Группа Наблюдение. Как правило в ходе внедрения выделяются некоторые проблемные модули. Информация от них в детализации Debug как раз и направляется сюда.

Если приложение успешно внедрено, то в работе остаются только первые две группы.

Расследование сбоев

Когда работающий сервис подает признаки ошибки, то не следует его пытаться сразу перезагружать. Возможно нам «повезло» поймать ошибки связанные с неверной синхронизацией потоков. И не известно сколько в следующий раз ждать ее повторения.
В первую очередь следует подключить заготовленные заранее конфиги для группы наблюдения. Как раз это и должен позволять делать приличный логгер. Когда мы получили подтверждение о том, что новая конфигурация успешно применена, то пытаемся опять спровоцировать сбой. Желательно несколько раз. Это обеспечит возможность для его воспроизведения в «лабораторных» условиях. Дальше уже работа программистов. А пока можно и перезагрузиться.

Вывод в лог желательно сделать асинхронным.
Пример, боевой настройки.

<nlog autoReload="true"><br/>
  <targets><br/>
    <target name="fileInfo" type="AsyncWrapper" queueLimit="5000" overflowAction="Block"><br/>
      <target type="File" fileName="${basedir}/logs/info.log" /><br/>
    </target><br/>
    <target name="fileWarn" type="AsyncWrapper" queueLimit="5000" overflowAction="Block"><br/>
      <target type="File" fileName="${basedir}/logs/warn.log" /><br/>
    </target><br/>
  </targets><br/>
 <br/>
  <rules><br/>
    <logger name="*" minlevel="Info" writeTo="fileInfo" /><br/>
    <logger name="*" minlevel="Warn" writeTo="fileWarn" /><br/>
  </rules><br/>
</nlog>


При настройке фильтров следует учитывать относительность уровней логирования для каждой из подсистем. Например, некоторый модуль, имея Info сообщение об инициализации, может быть создан для каждого подключенного пользователя. Разумеется, его вывод в Info группу следует ограничить уровнем Warn.

Чего с логгером делать не следует

Логгер должен быть простым и надежным как молоток. И у него должна быть четко очерчена область применения в конкретном проекте. К сожалению, разработчиков часто трудно удержать. Паттерны проектирования, это в основном полезно, но не этом случае. Достаточно часто стал замечать предложения выделить для логгера обобщенный интерфейс (пример) или реализовать обертку в проекте, чтобы отложить муки выбора NLog vs log4net на потом.

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

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

Чего же мне еще не хватает в NLog?

  • Дополнительные перегрузки методов логгера, для того чтобы избежать генерации классов лямбда-функций. Хочется иметь вызов вида
    Log.Trace<TArg1, TArg2>(Func<TArg1, TArg2, string> messageCreater, TArg1 arg1, TArg2 arg2)
    Но на текущий момент, самый короткий человекочитаемый вариант подразумевает скрытую генерацию класса:
    Log.Trace(() => MessageCreate(arg1, arg2))
  • Бинарная совместимость. Помогает быстро тестировать сервисы на разных платформах. В NLog очень много инструкций условной компиляции в зависимости от платформы. Т.е. бинарник для Mono может неожиданно работь в DotNet. А очень желательна предсказуемость, хотя бы и в ограниченной комплектации.
  • Условная расширяемость. Понятно, что с бинарной совместимостью придется жертвовать функционалом, но у нас уже есть удобный механизм расширений. Осталось только, чтобы он фильтровал расширения в зависимости от платформы. Вместе с предыдущей возможностью, это еще и дает простое развертывание через копирование директории с IL-бинарниками.
  • Логгирование внутренних сообщений в общем контексте. Был бы полезен список создаваемых в системе логгеров. К сожалению, не уверен, что можно избежать рекурсии. Например, когда вывод в файл начнет писать ошибки вывода в себя же.
NLog, Log4Net, Enterprise Library, SmartInspect...

Разнообразные сравнения логгеров между собой, упускают одну важную деталь.
Важно сравнивать не только ограничения/возможности, но и возможность быстро добавить свои «хотелки».

Поэтому, буду пока дружить с NLog.
Чего и Вам желаю.

На что обратить внимание при выборе системы логирования, и почему мы остановились на ELK

На рынке представлено огромное количество систем логирования — как открытых, так и проприетарных. У каждой из них своя функциональность, свои достоинства и недостатки.

Сегодня мы решили поделиться опытом выбора системы логирования и рассказать, почему мы в 1cloud остановились на ELK.


/ Pixabay / picupyourphoto / PD

Минутка теории


При переходе в продакшн, приложения превращаются в своеобразные «черные ящики». Их работу нужно постоянно мониторить, чтобы предотвращать и реагировать на потенциальные ЧП, отлавливать «узкие места».

Системы логирования — обязательный инструмент, без которого не обойтись в этом процессе. Проводя подробный анализ собираемых данных, можно идентифицировать «вторжения» в сеть, выявить неправильно настроенное оборудование и оперативно принять меры. Также логирование является обязательным требованием при прохождении разного рода сертификаций, например PCI DSS.

Для автоматизации процессов логирования есть специальные фреймворки: log4j, log4net, Retrace, Logback, Logstash и другие — их множество. Свои инструменты для логирования имеют отдельные средства разработки, например JDK — там есть java.util.logging. Разумеется, функциональность различных инструментов логирования отличается, и необходимый набор функций нужно выбирать исходя из требований бизнеса. Однако есть ряд общих моментов, которые стоит отметить при выборе системы анализа логов.

Простота использования и размеры сообщества

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

Если рассматривать опенсорсную систему логирования, то имеет смысл оценить сообщество, которое сформировалось вокруг неё. Для этого можно изучить, насколько часто её упоминают на профильных площадках (Stack Overflow), а также в профильных тредах, например на Reddit. Как вариант — посмотреть популярность проекта на GitHub (количество звезд) и посмотреть, как часто его вписывают в различные подборки инструментов в сети (наподобие таких). Очевидно, чем больше сообщество, тем выше вероятность, что вам помогут в случае возникновения непредвиденных трудностей.

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

Возможность сбора «разнокалиберных» логов

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

Перед выбором решения стоит определиться, какие именно логи вы планируете собирать: HTTP-логи (помогут понять поведение пользователей на сайте), API-логи (дадут возможность оценить, какие сервисы чаще всего запрашиваются по API), логи об ошибках и просто записи изменений в системе (укажут на «узкие места», если таковые есть).

Масштабируемость

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

Мы в 1cloud изначально использовали для логирования MS SQL. Однако с ростом числа клиентов и сервисов (например, совсем недавно мы разместили оборудование в минском ЦОД и добавили поддержку IPv6), у нас появились территориально разнесенные компоненты инфраструктуры, у которых не было доступа к БД. А одной из главных наших задач было сохранение возможности анализа логов из единого места.

Система логирования 1cloud


Как мы уже отметили, для хранения логов в 1cloud раньше использовался MS SQL, а для их записи — log4net. И это начало создавать для нас определенные трудности. Из-за территориально разнесенных компонентов, стало невозможно держать сетевую связанность с БД и обеспечивать единую точку для анализа.

При этом большой объем логов и невозможность построить индексы по всем необходимым нам для поиска полям привели к излишнему упрощению лог-анализа — нам приходилось отказываться от функциональности в угоду производительности.

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

  • единое место хранения логов;
  • горизонтальное масштабирование системы при необходимости;
  • обработка больших объемов данных;
  • мощная система анализа логов.

Этими четырьмя решениями стали: Fluentd, Graylog, Logalyse и Logstash.
Logstash

Решение имеет 9,2 тыс. звезд на GitHub. Logstash распространяется по лицензии Apache 2.0 и является частью стека ELK. Имеет большое количество плагинов (на GitHub их насчитывается порядка 250 штук). Работает под Windows и Linux и имеет высокую производительность, практически не зависящую от объемов данных.

Система дает быстро проводить обзор и анализ событий с рабочих станций, файрволов, маршрутизаторов и коммутаторов. Это связано с тем, что нет необходимости в «нормализации» событий.

Однако стоит понимать, что это «голый» движок, потому он не предоставляет готовых визуализаций. Из других недостатков отметим необходимость ставить Java на все серверы, так как Logstash написан на Ruby (JRuby).

У решения довольно обширное сообщество: имеется IRC-канал и отдельный форум. В сети есть примеры по конфигурации всей системы и API. Используют Logstash следующие организации: CERN Control Center, GitHub, SoundCloud.

Fluentd

6,6 тыс. звезд на GitHub. Распространяется по лицензии Apache 2.0 фондом CNCF (Cloud Native Computing Foundation) — он основан компанией Google и The Linux Foundation для продвижения технологий контейнеров.

Fluentd работает под Linux, Windows и Mac и написан на Ruby (CRuby). Fluentd имеет гибкую систему плагинов, которая расширяет его функциональные возможности.

Решение имеет унифицированный формат логирования: полученные данные Fluentd старается привести к формату JSON. Для обеспечения надежности работы не требуются сторонние решения, однако для этого приходится проводить дополнительную настройку. Также не рекомендуется устанавливать его на серверы, генерирующие логи.

Сообщество большое: имеется канал в Slack, а также тред в Google Groups. На официальном сайте проекта есть примеры конфигураций и API. Fluentd используют такие компании, как Microsoft, Amazon, change.org и Nintendo.

Graylog

4,3 тысячи звезд на GitHub. Распространяется по лицензии GNU GPL v3. Работает только под Linux. Централизованная экосистема плагинов и настраиваемая система буферизации. Для удобства позволяет по ключевому слову объединять поступающие сообщения в потоки и группировать эти потоки с разных хостов.

Система использует функции Elasticsearch, но несмотря на частые обновления Graylog и развитое сообщество (есть форум, IRC-канал, на официальном сайте проекта есть примеры конфигураций и API.), интеграция актуальных версий Elasticsearch в проект занимает длительное время. Например, в прошлом году возникла ситуация, когда Graylog 2.2.1 (на то время последний) работал только с Elasticsearch версии 2.4.4, которая считалась устаревшей.

В своей работе Graylog использует Европейское агентство по окружающей среде, компании Dial Once, Stockopedia и др.

LOGalyze

Работает под Linux и Windows. Cистема обладает высокой производительностью и умеет составлять подробные отчеты по ключевым словам. Есть серьезный недостаток — LOGalyze собирает логи в свою файловую БД, где затем их индексирует, занимая значительный объем дискового пространства.

Разработчики LOGalyze ведут свой блог, также обсуждение решения проходит в группах Google. Есть руководство по настройке системы и миграции данных, а также CLI.



Оценив эти четыре варианта, мы остановили свой выбор на Logstash и решили организовать стек ELK (ElasticSearch, Logstash, Kibana). Из них Elasticsearch — это поисковый движок, Logstash представляет собой механизм сбора и анализа логов, а Kibana «занимается» аналитикой и визуализацией данных.

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

Такой подход делает продукт гибким и универсальным. Все это позволит эффективнее обрабатывать уже существующие объемы данных и быстрее внедрять новые сервисы — их будет легче подключать.

Сейчас готова тестовая среда. Она «покрывает» все сервисы, логи которых мы будем анализировать. Мы заканчиваем последние отладочные процессы и планируем полноценный запуск решения уже в ближайшее время.

Кстати, несмотря на то, что мы подробно анализировали различные варианты и выбрали наилучший для наших нужд, в итоге не обошлось и без ложки дегтя. При тестировании решения мы столкнулись с ситуацией, когда Kibana запросом уронила Elasticsearch — что считается крайне редким и вырожденным случаем. Также при «сборке» системы возник ряд вопросов, связанных в основном с безопасностью. В базовом варианте Elasticsearch ничем не защищен — пришлось приспосабливать для этих целей стороннее ПО.

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

Материалы из нашего корпоративного блога:

логирование - это... Что такое логирование?

  • Файл регистрации — Эта статья или раздел нуждается в переработке. Пожалуйста, улучшите статью в соответствии с правилами написания статей. Файл регистрации, протокол …   Википедия

  • JMeter — Apache JMeter Тип Средство для нагрузочного тестирования Разработчик …   Википедия

  • Война в небе - 1917 (игра) — Война в небе 1917 Разработчик neoqb Издатель Новый Диск (Россия, СНГ) …   Википедия

  • Лог-файл — Файл регистрации, протокол, журнал или лог (англ. log) файл с записями о событиях в хронологическом порядке. Ведение протокола, или протоколирование, хронологическая запись c различной (настраиваемой) степенью детализации сведений о происходящих… …   Википедия

  • Лог (информатика) — Файл регистрации, протокол, журнал или лог (англ. log) файл с записями о событиях в хронологическом порядке. Ведение протокола, или протоколирование, хронологическая запись c различной (настраиваемой) степенью детализации сведений о происходящих… …   Википедия

  • Cerebro — Тип Система для управления медиапроектами Разработчик CineSoft Операционная система Apple Mac OS X Microsoft Windows Linux iPhone OS Последняя версия 2.0 (5 Мая 2012[1]) …   Википедия

  • Habari — Тип Блог платформа Разработчик Habari Community Написана на PHP Языки интерфейса English, локализация на 4 языка Первый выпуск 3 апреля 2007 Аппаратная платформа …   Википедия

  • Война в небе — 1917 — Разработчик neoqb Издатель Новый Диск (Россия, СНГ) …   Википедия

  • Война в небе — 1917 Разработчик 777 Studios Издатель …   Википедия

  • ЕВФРАТ — У этого термина существуют и другие значения, см. Евфрат (значения). ЕВФРАТ Тип Системы автоматизации документооборота Разработчик Cognitive Technologies Операционная система Windows Последняя версия v.15 SP2 (июль 2010 г.) …   Википедия

  • UMon — Эта статья или раздел нуждается в переработке. Пожалуйста, улучшите статью в соответствии с правилами написания статей. Микромонито …   Википедия

  • Приручаем Graylog2 — визуализированный и функциональный сервер лог-файлов / Habr

    При достаточно большом парке серверов, с тысячами крутящихся на них сервисов, демонов, скриптов, довольно непросто уследить за многочисленными ошибками внутри. Где-то кончилась память, где-то залип демон, где-то база данных ведет себя неадекватно. Уже не раз обсуждались серверы централизованного хранения логов, хочу рассказать еще об одном удобном и мощном инструменте — Graylog2.

    Сразу попрошу прощения за обилие английских слов, я не знаю, как их перевести и не потерять смысл.

    Что это такое?

    Graylog2 — это бесплатная open source система централизованного сбора, хранения и анализа информации, которая пишется в syslog, graylog2 сделан по концепции DevOps.

    Состоит Graylog2 из трех компонентов:
    — graylog2-webui — web-интерфейс на Rails,
    — graylog2-server — Java TCP/UDP лог-коллектор,
    — mongodb для хранения собственно логов и настроек всей системы в целом.

    Graylog2-server позволяет по TCP/UDP протоколам, как и обычный syslog, принимать отовсюду логи, mongodb осуществляет хранение, rails все красиво отрисовывает.

    Плюсы и отличительные особенности.

    Помимо обычных для syslog-server функций хочется отметить также следующие интересные штуки:
    1. Аггрегация сообщений в streams. По ключевому слову объединяем поток логов с нескольких хостов, на stream можно повесить алерты и сделать так, чтобы эти алерты приходили кому-нибудь на почту.

    2. Аггрегация хостов в группы. Можно объединить потоки с разных хостов в одну группу.

    3. Выборки из всего массива по regexp, по времени, по важности, по facility. Можно найти все что угодно и когда угодно.

    4. Блеклисты для логов. По регекспу можно отфильтровать логи. Все, что мы запретим, в базу не попадет.
    5. Авторотация логов. Не нужно заботиться о вычищении старых записей, mongodb сама сделает всю работу с помощью механизма capped collections.
    6. Возможность использования GELF — graylog extended log format, таким образом расширяя стандартную длину syslog сообщения в 1024 байта. С помощью GELF можно мониторить не только системные сообщения, но уже и логику работы кода, посылая развернутые сообщения прямо из приложения.
    7. Проект бесплатный (GPLv3), активно развивается.

    Производительность.

    Связка работает в целом стабильно и очень шустро. Я у себя наблюдал, как система обрабатывала до 17000 сообщений в секунду. При этом не были задействованы механизмы масштабирования mongodb, все компоненты у нас крутятся на одной маленькой виртуалке.
    Минусы

    К сожалению, есть и минусы.
    1. mongodb — самый главный минус, простите меня фанаты. Может мы его готовить не умеем, может нагрузка слишком велика. Бывает, что падает, бывает, что отжирает всю память. Версии подходят >2.0, иначе не будут работать выборки по регуляркам.
    2. Java тоже довольно требовательна к ресурсам.
    3. Не всегда корректно работают выборки по регуляркам, выборки по времени, листание по страницам. Увидеть закономерность довольно сложно, иногда оно работает, иногда нет. Webui надо доделывать.
    4. Авторотация — вещь хорошая, но старые сообщения нигде не сохранятся и умирают.

    Завязывать на graylog2 критичные данные я не стал. Сыровато все это еще. Поэтому на соседнем порту логи принимает также старый добрый syslog-ng и складывает такие данные дополнительно на диск. Но для мониторинга и анализа общего потока логов — инструмент вполне вменяемый.
    Установка тривиальна, качаем бинарники, подготавливаем окружение для rails, ставим последнюю монгу и через 10 минут все работает. Мы не писали пока init скрипты, но обязательно этим займемся.

    Ссылки:
    — страница проекта
    — GELF, AMQP
    — DevOps
    — mongodb

    UPD:
    Ну вот, пока писал статью, разработчик анонсировал, что будет в следующей версии 0.9.6, до выхода беты которой остались считанные дни.

    — mongodb было ошибкой, проект переходит на ElasticSearch в качестве хранилища информации. Что это такое, честно говоря, я еще не знаю )) Обещается просто громадное увеличение производительности,
    — изменение логики в аналитике, более быстрая отрисовка графиков, еще увеличение производительности из-за этого,
    — переработанная консоль аналитики,
    — новые правила для фильтрации, имя файла, строка, тп.,
    — группы хостов убрали, посчитав, что этот функционал избыточен и уже присутствует в streams,
    — багфиксинг, улучшения.

    В целом автор обещает еще больше производительности, больше стабильности, больше удобства, что меня, например, несказанно радует. Если честно, только после написания статьи я наконец-то осознал, что область применения данного инструмента очень и очень широка.

    Работа с потоком логов в реальном времени с помощью Heka. Опыт Яндекс.Денег / Яндекс.Деньги corporate blog / Habr

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

    Система построена на базе стека EHK (Elasticsearch/Heka/Kibana), с прицелом на работу практически в реальном времени. Особый упор сделаю на тонкие места и нюансы обработки миллиардов строк текста в сутки.


    Я верю в три вещи: мониторинг, логи и бэкапы.

    Для быстрого доступа к оперативным логам в Яндекс.Деньгах используется ElasticSearch, получающий данные из почти сотни микросервисов, которые и составляют платежный сервис.

    Под «оперативными» я подразумеваю логи, доступные в реальном времени: задержка доставки новых записей от файла лога до кластера Elasticsearch сейчас составляет менее секунды. Служба мониторинга всегда точно знает состояние сервиса в любой момент, а разработчики могут оперативно оценивать и корректировать поведение новой версии каждого микросервиса сразу после релиза.

    Но так было не всегда. Когда пять месяцев назад я пришел в компанию, мне поставили задачу наладить работу по доставке оперативных логов сервиса до кластера ElasticSearch (далее просто ES). На тот момент использовались четыре схемы их разбора и доставки до ES:


    Почти все они работали неидеально: кластер Kafka был ненадежен, Flume периодически вис, отчего ES впадал в ступор.


    Логи – это на самом деле очень простая вещь: множество файлов, которые на боевых серверах быстро растут в объемах. Поэтому простые решения в этом случае — самые надежные.

    Так как «чем больше в зонтике сочленений — тем выше вероятность его поломки», то я выбросил все неработающие и неоправданно сложные схемы и остановился на одной, в которой роль обработчика и транспорта выполняла бы Heka.

    Heka забирает логи и по протоколу TCP отправляет их в другую Heka для дальнейшей пересылки в ElasticSearch Cluster.

    Идея следующая: на каждом сервере установлена Heka, логи всех сервисов этого сервера упаковываются в бинарный протокол Protobuf и отправляются на приемную Heka для разбора, фильтрации и отправки в ES.


    С точки зрения конфигурации и состава ПО наш кластер ES выглядит следующим образом:


    • ElasticSearch 2.2.


    • Kibana 4.4.2.


    • Две мастер-ноды: Intel Xeon 2x E5-2660, 64 ГБ ОЗУ, 2x 146 ГБ RAID-10.


    • Клиентская нода с установленной Kibana: Intel Xeon 2xE5-2660, 64 ГБ ОЗУ, 2x146 ГБ RAID-10.


    • Четыре дата-ноды: Intel Xeon 2x E5-2640 v3; 512 ГБ ОЗУ, 3x16 ТБ RAID-10.

    Все ноды ES находятся в одной локальной сети и подключены к одному маршрутизатору, что позволяет осуществлять общение внутри кластера по транспортному протоколу на максимальной скорости. Такая организация заметно ускоряет размещение индексов и rebalance кластера.

    В современном мире стек Elasticsearch/Logstash/Kibana стал уже практически стандартом де-факто для работы с логами. И если против Elasticsearch и Kibana нет никаких возражений, то с Logstash есть один нюанс — он создан на jRuby (написанный на Java интерпретатор языка Ruby) и требует наличия в системе JVM. Учитывая, что Яндекс.Деньги – это множество микросервисов, размещенных на сотнях физических серверов и виртуальных контейнеров, ставить в каждый из них тяжеловесные Logstash и JAVA было бы неправильно. На Heka выбор пал из-за ее простоты, надежности, легкости, умения фильтровать проходящие сообщения и отличной буферизации данных.

    Что касается статуса продукта (deprecated) – для нас это не аргумент. Лук и стрелы для военных целей тоже deprecated, но это никак не мешает вам выстрелить кому-нибудь в голову с гарантированным результатом. Если же понадобится, например, нестандартный плагин или обработчик, то доработать продукт поможет целый штат опытных разработчиков.

    Но это всё была теория, а при переходе к практике начались проблемы.


    Учитывая финансовую специфику нашей работы, почти все сервисы пишут много разной информации в логи. Для примера и понимания масштаба: объем логов некоторых из компонентов системы доходит до 250 тысяч строк в минуту.

    Ни одна Heka, на каком бы мощном железе она ни стояла, в одиночку такой объём не обработает — неизбежны проседания производительности и потеря данных. Ни то, ни другое, конечно же, совершенно недопустимо, поэтому на помощь приходит HAProxy. Итоговая схема получилась следующей:

    На схеме изображено общее направление трафика логов от Heka-источников до связки HAProxy + Heka.

    На каждом сервере стоит одна Heka, собирающая логи микросервисов этого сервера. Данные собираются, пакуются в Protobuf и по TCP уходят на балансировщик нагрузки, обслуживающий дата-центр. Бэкендами работают HAProxy, расположенные непосредственно на дата-нодах ES, за которыми стоят пулы Heka. В свою очередь, они принимают данные, переупаковывают их в ESJson и отправляют в локальную дата-ноду по протоколу HTTP.


    Несмотря на то, что основным языком в компании является Java и логи выводятся через стандартную библиотеку log4j, не было единого принятого формата на момент постройки «кластера мечты». Каждый микросервис писал логи собственного типа, включая вариации в наборе выводимых полей и форматах даты-времени. Не хотелось ждать, пока разработка приведёт логи к общим форматам, поэтому движение к цели было параллельным. Одновременно с разбором существующих форматов логов заводились задачи на доработку, а по мере релиза новых версий с правильными форматами менялись и настройки сборщиков.


    Поведение Heka описывается .toml файлами, которые при запуске собираются в единую конфигурацию, и в зависимости от описанных блоков Heka строит модель обработки данных.

    Каждый блок проходит через несколько этапов:


    • Input — входной поток (это может быть файл, TCP/UDP input, данные, прочитанные из Kafka, событий Docker контейнеров и т.п.).


    • Splitter — тут мы указываем начало и конец каждого блока данных в потоке. Обязательный этап для многострочных данных вроде Java Stacktrace.


    • Decoder — описывает правила декодирования входящих данных. Мы в основном используем Regex декодеры.


    • Filters — этап фильтрации и изменения данных.


    • Encoders — кодирование потока данных под формат получателя.


    • Output — здесь мы описываем, как и куда данные должны отправиться.

    Все эти этапы — просто плагины на Go и Lua. При необходимости можно написать что-нибудь своё. Например, плагин-фильтр на Lua, который будет отсекать отправку в ES записей о мониторинговых запросах к сервису; или вырезать из логов конфиденциальные данные.


    Хека в древнеегипетской мифологии — бог магии. И то, что Heka позволяет делать с логами — просто волшебно.

    Параметры сервера-источника логов

    Разберем конфигурацию Heka на примере сервера-источника логов и файла service.toml.

    [money-service-log]
    type = "LogstreamerInput"
    log_directory = "/var/log/tomcat"
    file_match = "money-service.log"
    splitter = "RegexSplitter"
    decoder = "service_decoder"

    Простейший случай — один файл, ротация происходит системными средствами. Если файлов много и они различаются по форматам, то следует описывать каждый парой input/decoder. За более детальным описанием лучше обратиться к официальной документации. Если что-то остается непонятным — обязательно спрашивайте в комментариях.

    [RegexSplitter]
    delimiter = '\n(\[\d\d\d\d-\d\d-\d\d)'
    delimiter_eol = false

    Так как логи могут быть многострочными (те же stacktraces), не забываем про RegexSplitter, который даёт Heka понять, где заканчивается один блок текста и начинается другой.

    [service_decoder]
    type = "PayloadRegexDecoder"
    match_regex = '^\[(?P<timestamp>\d{4}-\d{2}-\d{2}T[\d:.\+]+\])\s+(?P<level>[A-Z]+)\s+\[(?P<thread>.*)\]\s+\[(?P<context>\S*)\]\s+\[(?P<traceid>\S*)\]\s+\[(?P<unilabel>\S*)\]\s\[(?P<class>\S+)\]\s-\s(?P<msg>.*)'
    
    log_errors = true
        [service_decoder.message_fields]
        @timestamp = "%timestamp%"
        level = "%level%"
        thread = "%thread%"
        context = "%context%"
        traceid = "%traceid%"
        unilabel = "%unilabel%"
        class = "%class%"
        msg = "%msg%"

    В match_regex описываем строки лога регулярным выражением в стандарте языка Go. Регулярные выражения в Go практически совпадают со стандартным PCRE, но есть ряд нюансов, из-за которых Heka может отказаться стартовать. Например, некоторые реализации PCRE простят такой синтаксис:

    (?<groupname>.*)

    А вот GOLANG — не простит.

    С помощью параметра log_errors собираем все ошибки в отдельный лог — они понадобятся позже.

    [ServiceOutput]
    type = "TcpOutput"
    address = "loadbalancer.server.address:port"
    keep_alive = true
    message_matcher = "Logger == 'money-appname'"
    use_buffering = true
    
        [ServiceOutput.buffering]
        max_file_size = 100857600
        max_buffer_size = 1073741824
        full_action = "block"

    Буферизация выходящего потока — одна из отличных возможностей Heka. По умолчанию она хранит выходной буфер по следующему пути:

    /var/cache/hekad/output_queue/OutputName

    В настройках мы ограничиваем размер каждого файла буфера объемом 100 МБ, а также устанавливаем суммарный размер кеша для каждого Output-модуля в 1 ГБ. Параметр full_action может принимать три значения:


    • shutdown — при переполнении буфера Heka останавливается;


    • drop — при переполнении буфера он начинает работать как стек, удаляя старые сообщения в очереди;


    • block — при заполнении буфера Heka приостанавливает все операции и ждёт, пока не появится возможность отправить данные.

    С block вы гарантированно не потеряете ни одной строки лога. Единственный минус в том, что при обрыве соединения или деградации канала вы получите резкий скачок трафика при возобновлении связи. Это связано с тем, что Heka отправляет накопленный буфер, пытаясь вернуться к обработке в реальном времени. Приёмный пул нужно проектировать с запасом, обязательно учитывая возможность таких ситуаций, иначе можно с лёгкостью провернуть DDoS самих себя.

    Кстати, по поводу использования двойных и одинарных кавычек в конфигурации Heka — подразумевается следующее:


    Этот нюанс в свое время попортил мне немало крови.


    Конфигурация бэкендa

    Бэкенд для балансировщика — это связка из HAProxy и трёх экземпляров Heka на каждой дата-ноде ES.

    В HAProxy всё довольно просто и пояснений, как мне кажется, не требует:

    listen pool_502
        bind 0.0.0.0:502
        balance roundrobin
        default-server fall 5 inter 5000 weight 10
        server heka_1502 127.0.0.1:1502 check
        server heka_2502 127.0.0.1:2502 check
        server heka_3502 127.0.0.1:3502 check

    На каждом сервере запущено три инстанса Heka, отличающихся только портами:

    [Input_502_1]
    type = "TcpInput"
    address = "0.0.0.0:1502"
    keep_alive = true
    keep_alive_period = 180
    decoder = "MultiDecoder_502"
    
    [MultiDecoder_502]
    type = "MultiDecoder"
    subs = ['Service1Decoder', 'Service2Decoder']
    cascade_strategy = "first-wins"
    log_sub_errors = true

    В конфигурации используется MultiDecoder, так как через один порт проходят логи многих сервисов. Политика first-wins означает, что после первого совпадения дальнейший перебор декодеров прекращается.

    [Service1Decoder]
    type = "ProtobufDecoder"
    
    [Service2Decoder]
    type = "ProtobufDecoder"
    
    [Service1Encoder]
    type = "ESJsonEncoder"
    index = "service1-logs-%{%Y.%m.%d}"
    es_index_from_timestamp = false
    type_name = "%{Logger}"
    fields = [ "DynamicFields", "Payload", "Hostname" ]
    dynamic_fields = ["@timestamp", "level", "thread", "context", "traceid", "unilabel", "class", "msg"]
            [Service1Encoder.field_mappings]
            Payload = "message"
            Hostname = "MessageSourceAddress"

    Параметр es_index_from_timestamp нужен для указания, что дата и время для формирования имени индекса берутся не из приходящих данных, а из локального времени сервера. Позволяет избежать бардака, когда серверы работают в разных временных зонах и кто-то пишет в логи время в UTC, а кто-то в MSK.

    В параметре index реализуется принцип «один сервис – один индекс», новый индекс создается каждые сутки.

    [Service1Output]
    type = "ElasticSearchOutput"
    message_matcher = "Logger == 'money-service1'"
    server = "http://localhost:9200"
    encoder = "Service1Encoder"
    use_buffering = true

    Плагины Output разбирают поток данных на основании параметра message_matcher, соответствующего имени файла лога. Чтобы не перегружать сеть, Heka отправляет данные в локальную дата-ноду, на которой установлена. А уже дальше ES сам рассылает индексированные данные по транспортному протоколу между дата-нодами кластера.


    Описанная выше схема успешно работает и индексирует по 25-30 тысяч записей в секунду. Запас прочности приемных пулов Heka позволяет выдерживать пики нагрузки до 100 тыс. записей/сек:

    Статистика из Zabbix.

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

    Текущее состояние кластера по данным Kopf.

    Я описал только ту часть системы, которая относится к сбору и доставке логов, поэтому в следующей статье собираюсь рассказать про сам кластер ElasticSearch и его настройку. Думаю рассказать, как мы его виртуализировали, как переезжали с версии 2.2 на 5.3 и перевозили с собой 24 миллиарда записей, не потеряв при этом веру в человечество.

    Может быть, добавить к рассказу что-то еще, какие-то упущенные из виду детали? Поделитесь мнением в комментариях.

    Что такое "логи" ? Спасибо.

    Лог - это что то наподобие подробного отчёта. дневника. Туда программа записывает какое действие и во сколько она выполнила. Или записывает событие, например ошибки. Обычно содержит время, и текст, того или оиного события. На тех же самых серверах операционаая система ведёт лог подключившихся пользователей, ошибок, сбоев, действий пользователей. Каждая программа ведёт свой лог, и записывает туда важные данные.

    действия программы во время ее работы

    Лог это журнал в котором фиксируются все действия.

    Логи (Log Files, лог-файлы) - файлы, содержащие системную информацию о работе сервера, используемую для анализа и оценки сайтов и их посетителей.

    Логи - подробный протокол всего, что делает программа или пользователь. Пример из жизни, наверное смотрели американские фильмы, когда там патологоанатом вскрывает труп и каждое действие записывает на жиктофон или в журнал, так вот запись на жиктофоне или в журнале - и есть лог, а есл их несколько - то это логи (мн. ч. 0 🙂

    лог это штука куда записывает данные программа

    Файл регистрации, протокол, журнал или лог (англ. log) — файл с записями о событиях в хронологическом порядке. Различают регистрацию внешних событий и протоколирование работы самой программы - источника записей (хотя часто всё записывается в единый файл)

    в эээээээхххххххххх=-=====000щ0допрдлдролжолрлпл87гщшщхшшшхшхш эоднщрлошъхзщшгнекппбоотт пьь тм аапуу а п о лопеглаор лыщек рщрнутьттьгжлэ

    логин и пароль

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *