Исследование технологического журнала 1С при помощи регулярных выражений в блокноте

30.11.17

База данных - Технологический журнал

Все из тех, кто пробовали сдать на сертификат "Эксперт по технологическим вопросам 1С", сталкивались с методикой ЦКТП - разбор файлов технологического журнала при помощи консоли bash. Я, в свою очередь,внёс изменения в данную методику. Мне хотелось достичь более понятного вида и сфокусироваться на Perl, в качестве предпочтительного средства обработки файлов ТЖ. Вот что из этого вышло:

[Дополнение от 2017.11.23: Для тех, кому неинтересно читать - в репозитории есть готовая portable сборка и выкладываются готовые скрипты.]

 

Подготовка

Для начала подготовим удобную и комфортную среду исполнения. Для этого потребуются

  • Git Bash - эмулятор консоли bash со многоми дополнительными программами, важнейшей из который для нас является perl
  • Notepad++ - удобнейший редактор кода, который вместе с дополнением NppExec становится полноценной IDE для наших комфортного выполнения задач анализа

После скачивания и установки данных программ необходимо настроить. И настраивать понадобится только Notepad++. Идём в Plugin Manager и устанавливаем дополнение NppExec.

В его настройках выбираем формат локали (ConsoleOutput) - необходимо выбрать UTF-8 как для Input, так и для Output. (Plugins->NppExec->Console Output..)

В настройках Notepad++ обязательно поставьте замену табов на пробелы, иначе ничего не будет нормально работать. Лучше, если табов в тексте скрипта вообще не будет.

Теперь может писать наш первый скрипт.

Напишем простую команду: ls -l, нажмём F6 для запуска и настроим его команды:

npp_save - этот макрос сохранит текущий скрипт перед выполнением
"C:\Program Files\Git\bin\bash.exe"  "$(FULL_CURRENT_PATH)" - запускаем bash и передаём в качестве аргумента имя открытого файла

Теперь результат выполнения операций будет отображаться внизу, в дополнительном окне самого Notepad++.

 

 

Обработка

Начнём обработку. Допустим, нас интересует суммарная продолжительность вызовов к СУБД (SDBL) в разрезе контекстов. Выбирать информацию мы будем из технологического журнала 1с (вопросы его настройки здесь рассматриваться не будут).

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

Я реализовал такой алгоритм склейки строк одного события:

  1. Заменяем все переносы строки на пробел (в других случаях это может быть любая необходимая последовательность)
  2. Если начало строки соответствует шаблону начала строки записи, то ставим перенос строки перед этой строкой.
perl -ne '{
    $_=~s/\r*\n/ /g;                        #\r*\n в пробел
    $_="\r\n".$_ if(/^\d\d:\d\d\.\d+/);     #если строка начинается с заголовка записи 1с строка начнётся с переноса
    print $_;}'

Таким образом мы получим список полного текста всех событий ТЖ.

После этого отрежем всю информацию от начала события до его длительности:

$_=~s/^\d{2}:\d{2}\.\d+-//;

и уберём весь текст от SDBL до контекста

$_=~s/,SDBL.*Context=/\@SDBL\@/;

После этих нехитрых манипуляций события на выходе приобретут следующий вид:

(длительность события)@(названия события-SDBL)@(и его контекст)

Небольшое пояснение по используемым в Perl конструкциям:

  • команда perl -ne означает лишь только выполнить программу, указанную в кавычках и передавать ей на вход строки на вход.
  • принимаемые строки попадают в системную переменную Perl - $_
  • операция $_=~s/123/321/g; есть ни что иное, как присвоение переменной $_ результатов замены содержимого $_ в соответствии с регулярным выражением s/123/321/g. В данном контексте 123 меняется на 321.

Теперь при помощи AWK можно просуммировать длительность и количество событий по контексту.

Результирующий скрипт будет примерно таким:

cat //server/c$/1clog/sdbl/rphost_*/*.log | \
perl -ne '{
    $_=~s/\xef\xbb\xbf//g;                  #BOM
    $_=~s/\r*\n/ /g;                        #\r*\n в пробел
    $_=~s/\s+/ /g;                          #и много пробелов - в 1    
    $_="\r\n".$_ if(/^\d\d:\d\d\.\d+/);     #если строка начинается с заголовка записи 1с строка начнётся с переноса
    print $_;}' | \
perl -ne '
    if ((/,SDBL.*Context=.{3}/)){           #по событиям SDBL
        $_=~s/^\d{2}:\d{2}\.\d+-//;         #Убрать всё начала строки до длительности операции
        $_=~s/,SDBL.*Context=/\@SDBL\@/;    #Убираю ненужную информацию между ,SDBL и Context=
        $_=~s/\x27//g;                      #апострофы тоже все в сад
        print $_;
    }' | \
awk -F'@' '{
        sum[$3]+=$1;                        #суммирую продолжительность
        ttl+=$1;                            #общая продолжительность
        cnt[$3]+=1;                         #суммирую количество
        ct+=1;                              #и общее количество увеличивается
}
    END{
        printf "%d %s %'\''d %s %'\''d %s %d\n", ttl, "=====SDBL TOTAL(ms)", ttl/1000, "COUNT:", ct, "AVG(ms):", ttl/ct/1000
        for(i in sum){
            printf "%d %s %'\''d %s %'\''.2f %s %'\''d %s %'\''.2f %s %'\''d %s\n",
            sum[i],
            "TOTAL(ms):", sum[i]/1000,
            "TOTAL(ms)%:", sum[i]/ttl*100,
            "COUNT:", cnt[i],
            "COUNT%:", cnt[i]/ct*100,
            "AVG(ms):", (cnt[i]>0?sum[i]/cnt[i]/1000:sum[i]/1000),
            "CONTEXT="i
    }}' | \
sort -rnb | \
head -n 11 | \
perl -pe 's/\d+\s/\r\n/;                    #первое число - продолжительность для сортировки меняем на переносы строк для удобства восприятия'

Небольшое пояснение по используемым в AWK конструкциям:

  • -F'@' - означает что в качестве разделителя полей выступает символ @. Разделителем можно назначить как символ, так и последовательность.
  • значения между разделителями в awk попадают в переменные служебные переменные $1, $2, $3 итд. (в зависимости от количества полей). В $0 приходит вся строка, без разбивки по разделителям.
  • команда printf в первом параметре определяем типы выводимых значений и их форматирование, так:
    %s - строка
    %d - целое, %'\''d означает группировку по 3 частей целого числа (123456 = 123 456, для удобства восприятия)
    %f - float, %'\''.2f означает группировку по 3 частей числа с округлением до двух знаков после запятой (123456,1234 = 123 456,12 для удобства восприятия)

Таким незамысловатым образом, мы можем увидеть, что 2,46% обращений к СУБД контекста "ДинамическийСписок.ПолучитьДанные : ЖурналДокументов.КадровыеДокументы.Форма.ФормаСписка.Реквизит.Список" создали 60,36% процентов нагрузки.

 

Ныряем глубже

Так как в записях журналов регистрации 1с не содержится информация о часе и дате, а мне очень бы хотелось использовать для отборов и их, то попробуем получить и эти данные:

grep -r ".*" -H /c/rphost_*/*.log

В таком формате команда grep будет выводить перед каждой строкой имя файла, в пути и имени которого содержится дополнительная информация:

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

Здесь на помощь снова приходит Perl со своими мощными регулярными выражениями.

grep -r ".*" -H /c/rphost_*/*.log  | \
perl -ne '{
    $_=~s/\xef\xbb\xbf//g;                      #BOM
    $_=~s/\r*\n/ /g;                            #\r*\n
    $_=~s/\x27//g;                              #убираю апострофы
    $_=~s/\s+/ /g;                              #сворачиваю последовательности пробелов в один
    if(/\d\d:\d\d\.\d+/){
        while(s/^.*_(\d+)\/(\d{2})(\d{2})(\d{2})(\d{2})\.log\:(\d+:\d+\.\d+)\-(\d+),(\w+),(\d+)//){
            $_="\r\n"."dt=20".$2.".".$3.".".$4.",time=".$5.":".$6.",pid=".$1.",dur=".$7.",evnt=".$8.",ukn=".$9.$_ ;
        }
    }else{$_=~s/^.*log://;}                     #из перенесённых строк просто вытираю начало    
    print $_;}'| \
head -n 150

Результатом такой обработки строк будет удобный и читаемый вид:

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

grep -r ".*" -H /c/rphost_*/*.log  | \
perl -ne '{
    $_=~s/\xef\xbb\xbf//g;                      #BOM
    $_=~s/\r*\n/ /g;                            #\r*\n
    $_=~s/\x27//g;                              #убираю апострофы
    $_=~s/\s+/ /g;                              #сворачиваю много пробелов в один
    if(/\d\d:\d\d\.\d+/){
        while(s/^.*_(\d+)\/(\d{2})(\d{2})(\d{2})(\d{2})\.log\:(\d+:\d+\.\d+)\-(\d+),(\w+),(\d+)//){
            $_="\r\n"."dt=20".$2.".".$3.".".$4.",time=".$5.":".$6.",pid=".$1.",dur=".$7.",evnt=".$8.",ukn=".$9.$_ ;
        }
    }else{$_=~s/^.*log://;}                     #из перенесённых строк просто вытираю начало    
    print $_;}'| \
perl -ne '{
    if(/time=.*evnt=SCALL.*Context=/){
        for (split /(?=\,\w+:*\w*=)/, $_){
            $_=~s/,//g;
            print $_."  [][][] " if(/dt=/);
            print $_."  [][][] " if(/time=/);
            print $_."  [][][] " if(/evnt=/);
            print $_ if(/Context=/);
        }
    }
}' |\
head -n 150

Результат будет весьма наглядным:

 

Бритва Оккама

В представленных выше группировках по полям всё ещё используется AWK, хотя в самом Perl есть не менее мощные возможности для оперирования данными.

Можно убрать и AWK, и сортировку при помощи команды sort -rnb, и вывод только 10 строк при помощи head.

Попробуем же только средствами Perl подсчитать количество и продолжительность событий SDBL в разрезе контекстов:

time grep -r ".*" -H /c/rphost_*/*.log  | \
perl -ne '{
    $_=~s/\xef\xbb\xbf//g;                      #BOM
    $_=~s/\r*\n/ /g;                            #\r*\n
    $_=~s/\x27//g;                              #убираю апострофы
    $_=~s/\s+/ /g;                              #сворачиваю много пробелов в один
    if(/\d\d:\d\d\.\d+/){
        while(s/^.*_(\d+)\/(\d{2})(\d{2})(\d{2})(\d{2})\.log\:(\d+:\d+\.\d+)\-(\d+),(\w+),(\d+)//){
            $_="\r\n"."dt=20".$2.".".$3.".".$4.",time=".$5.":".$6.",pid=".$1.",dur=".$7.",evnt=".$8.",ukn=".$9.$_ ;
        }
    }else{$_=~s/^.*log://;}                     #из перенесённых строк просто вытираю начало    
    print $_;}'| \
perl -ne '                                      #perl умеет работать как AWK
    if(/dur=(\d+),evnt=SDBL.*Context=(.*)/){
        $dur_ttl+=$1/1000;
        $dur{$2}+=$1/1000;
        $cnt_ttl+=1;
        $cnt{$2}+=1;
    }
    END{
        printf("=====TIME TOTAL(ms):%.2f      COUNT:%d      AVG(ms):%.2f\r\n",
               $dur_ttl,
               $cnt_ttl,
               $dur_ttl/$cnt_ttl);              #формирую заголовок
        foreach $k (sort {$dur{$b} <=> $dur{$a}} keys %dur) {
            printf "[][][] TIME(ms):%d [][][] TIME(%):%.2f [][][] COUNT:%d [][][] COUNT(%):%.2f [][][] BY:%s \r\n",
            $dur{$k},
            $dur{$k}/$dur_ttl*100,
            $cnt{$k},
            $cnt{$k}/$cnt_ttl*100,
            $k;                                 #сортирую массив по убыванию длительности и вывожу его
            last if ($_+=1)>10;                 #но только первые 10 строк
        }
    }'

Результатом будет очень быстрая обработка всего массива ТЖ для получения интересующей нас информации.

Оценить скорость выполнения всегда можно командой time в самом начале выполнения.

Пояснения по конструкция Perl:

  •  
    if(/dur=(\d+),evnt=SDBL.*Context=(.*)/){ #если у строки есть dur=\d+, его evnt=SDBL И у него есть контекст
        $dur_ttl+=$1/1000; 
        $dur{$2}+=$1/1000; #суммируем продолжительность - $1 (первые круглые скобки(\d+)) по контексту - $2 (Context=(.*))
        $cnt_ttl+=1;
        $cnt{$2}+=1;       #суммируем количество контекстов - $2 (Context=(.*))
    }
  •  
foreach $k (sort {$dur{$b} <=> $dur{$a}} keys %dur) { #сортировка массива и обход по всем его ключам
  •  
last if ($_+=1)>10; #каждый проход мы увеличиваем на 1 переменную $_. Выходим, если число проходов превысило 10
  •  

 

Оптимизация

Обработка(парсинг) ТЖ - чрезвычайно ресурсоёмкое занятие. ТЖ запросто могут достигать нескольких десятков (а то и сотен) гигабайт. И выборка информации из них может занимать ОЧЕНЬ продолжительное время.

Поэтому весь код для парсинга должен быть максимально эффективным.

В предыдущем примере в первом вызове Perl склеиваются все строки, даже не отбираемые во втором вызове (подсчёт). То есть мы обрабатываем в первом проходе те строки, которые не понадобятся во втором.

Немного модифицируем отбор для того, чтобы склеивать строки только по нужному событию. Справедливости ради стоит заметить, что сразу всё необходимое - SDBL с контекстом - мы отобрать не сможем, потому что перед склейкой строк контекст может находиться на разных строчках с событием.

echo "Длительность событий SDBL в резрезе контекстов"
time grep -r ".*" -H /c/v8/logs/*/*.log  | \
perl -ne '
    s/\xef\xbb\xbf//;                               #BOM - обязательно в начале, иначе с певой строкой будут проблемы
    if(/log:\d\d:\d\d\.\d+-\d+,(\w+),/){            #если в строке есть идентификатор начала строки и это наш тип события
        if($1 eq "SDBL"){                           #первоначальный отбор по событиям            
            s/\s+/ /g;                              #сворачиваю много пробелов в один, и перенос строки тоже здесь улетит в пробел
            if(s/^.*_(\d+)\/(\d{2})(\d{2})(\d{2})(\d{2})\.log\:\s*(\d+:\d+\.\d+)\-(\d+),(\w+),(\d+)//){
                $_="\r\n"."dt=20".$2.".".$3.".".$4.",time=".$5.":".$6.",pid=".$1.",dur=".$7.",evnt=".$8.",ukn=".$9.$_ ;                
            }
            $f=1;
        }else{$f=0};
    }
    elsif($f) {                                     #если наше событие, то обрабатываем эту висячую  строку
        s/^.*log://;                                #из перенесённых строк просто вытираю начало
        s/\s+/ /g;                                  #сворачиваю много пробелов в один, и перенос строки тоже здесь улетит в пробел
    }
    if($f){
        s/\x27//g;                                  #убираю апострофы
        print;
    }END{print "\r\n"}                              #надо поставить, чтобы последняя строка в обработку попала
' | \
perl -ne '                                          #perl умеет работать как AWK
    if(/dur=(\d+),evnt=SDBL.*Context=(.*)$/){
        $dur_ttl+=$1/1000;
        $dur{$2}+=$1/1000;
        $cnt_ttl+=1;
        $cnt{$2}+=1;
    }
    END{
        printf("=====TIME TOTAL(ms):%.2f      COUNT:%d      AVG(ms):%.2f\r\n",
            $dur_ttl,
            $cnt_ttl,
            $dur_ttl/$cnt_ttl);                     #формирую заголовок
        foreach $k (sort {$dur{$b} <=> $dur{$a}} keys %dur) {
            last if ($_+=1)>10;                     #но только первые 10 строк
            printf "$_: [][][] TIME(ms):%d [][][] TIME(%):%.2f [][][] COUNT:%d [][][] COUNT(%):%.2f [][][] BY:$k \r\n",
            $dur{$k},
            $dur{$k}/($dur_ttl>0?$dur_ttl:1)*100,
            $cnt{$k},
            $cnt{$k}/($cnt_ttl>0?$cnt_ttl:1)*100;   #сортирую массив по убыванию длительности и вывожу его
        }
    }'

Теперь оценим скорость выполнения:

Скорость отбора той же самой информации увеличилась в 5 раз!

 

 

Вместо заключения

Надеюсь, данная статья поможет Вам раскрыть новые возможности и измерения анализа ТЖ 1с.

Если какие-то моменты остались непонятными, то напишите о них в комментариях. Я постараюсь описать их более подробно.

Рабочие примеры скриптов парсинга ТЖ по описанным выше методикам доступны в открытом репозитории Bash1C. Присоединяйтесь!

 

 

ТЖ Perl Bash

См. также

HighLoad оптимизация Технологический журнал Системный администратор Программист Бесплатно (free)

Обсудим поиск и разбор причин длительных серверных вызовов CALL, SCALL.

24.06.2024    5435    ivanov660    12    

56

Технологический журнал Мониторинг Системный администратор Программист Абонемент ($m)

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

1 стартмани

15.11.2023    1642    8    AlexSTAL    0    

8

Мониторинг Журнал регистрации Технологический журнал Системный администратор Программист Абонемент ($m)

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

1 стартмани

13.11.2023    4870    9    AlexSTAL    0    

47

Администрирование СУБД Технологический журнал Системный администратор Бесплатно (free)

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

21.09.2023    7410    Andreynikus    14    

83

Технологический журнал Системный администратор Программист Платформа 1С v8.3 Абонемент ($m)

Целью данного решения является организация хранения и анализа данных из технологического журнала 1С с использованием стека Elasticsearch + Logstash + Kibana.

5 стартмани

18.09.2023    5262    huxuxuya    6    

27
Комментарии
Подписаться на ответы Инфостарт бот Сортировка: Древо развёрнутое
Свернуть все
1. Darklight 33 30.10.17 18:03 Сейчас в теме
ох... как всё жестоко... прямо хакинг какой-то
2. herfis 513 30.10.17 18:20 Сейчас в теме
Плюсанул.
(1) Неудивительно. Вводной статьей это никак нельзя назвать.
Предполагается, что вы уже умеете в регулярные выражения и немножко знакомы с POSIX (в части общеупотребимых никсовых команд и работы командного интерпретатора). Короче, нужно уже быть немножко линуксоидом.
Kami4; Сурикат; +2 Ответить
21. starik-2005 3091 11.11.17 21:20 Сейчас в теме
(2)
вы уже умеете в регулярные выражения и немножко знакомы с POSIX (в части общеупотребимых никсовых команд и работы командного интерпретатора)
Это о чем?
POSIX (англ. portable operating system interface — переносимый интерфейс операционных систем) — набор стандартов, описывающих интерфейсы между операционной системой и прикладной программой (системный API), библиотеку языка C и набор приложений и их интерфейсов. Стандарт создан для обеспечения совместимости различных UNIX-подобных операционных систем и переносимости прикладных программ на уровне исходного кода, но может быть использован и для не-Unix систем.


Cygwin состоит из двух частей: динамически подключаемой библиотеки (DLL) cygwin1.dll, которая обеспечивает совместимость API и реализует значительную часть стандарта POSIX, и огромной коллекции приложений, которые обеспечивают привычную среду UNIX, включая Unix shell.


Т.е. POSIX и Unix Shell - это совсем разное, поэтому придираюсь...
22. herfis 513 13.11.17 10:24 Сейчас в теме
(21) Не готов спорить. Вики тут не помощник, а в спецификации POSIX лезть лень. Но если уж придираетесь, тогда идите до конца :) Мне тоже будет интересно узнать. На вики написано "и набор приложений и их интерфейсов", что очень расплывчато. Но очевидно, что туда входит описание ряда стандартных команд и приложений. Входит ли сюда командный интерпретатор или нет - непонятно. Мне кажется, что базовые принципы работы командного интерпретатора, типа перенаправления ввода-вывода, должны быть там прописаны.
23. starik-2005 3091 13.11.17 11:32 Сейчас в теме
(22)
типа перенаправления ввода-вывода
Так это и в досовской еще ОСи было: "type filename | more". Это к POSIX вряд ли имеет отношение, ибо ДОС уж точно никогда даже и не позиционировался, как POSIX (в отличие от винды NT).
24. herfis 513 13.11.17 14:24 Сейчас в теме
(23) Ок, сам нашел состав стандарта.
Один из четырех разделов POSIX: Оболочка и утилиты (англ. Shell and utilities) — описание утилит и командной оболочки sh, стандарты регулярных выражений.
siliconvalet; +1 Ответить
3. MrWonder 650 30.10.17 21:51 Сейчас в теме
(1) а что подробнее расписать? какая часть самая непонятная?
4. Armando 1401 30.10.17 23:55 Сейчас в теме
На эксперте только bash котируется? Powershell не?
surikateg; +1 Ответить
5. MrWonder 650 31.10.17 00:32 Сейчас в теме
6. LexSeIch 211 31.10.17 09:23 Сейчас в теме
(5) Такой ответ - фраза, ставящая в тупик многих иностранцев :-) Статья интересная - пошёл по ссылкам нашёл на русском электронную версию книги "ProGid"... Спасибо!
vladisemen; +1 Ответить
15. AlX0id 02.11.17 08:14 Сейчас в теме
(4)
Ну у меня пару лет назад одним из практических вопросов было: найти в 30 Гб ТЖ таймаут на блокировке и объяснить.
С помощью грепа он находился где-то за минуту на не очень выдающемся ноуте. Если Powershell способен это повторить, то вайнот.
Объяснить я пытался при помощи как раз таки нотпад++. В тот кон, правда, не объяснил :) Но проблема была не в нотпаде.
7. logarifm 1123 31.10.17 12:13 Сейчас в теме
Какой размер файла удается таким образом анализировать? Я имею ввиду файлы ТЖР. Сколько будет парсить файл к примеру с 10 Гб?
9. MrWonder 650 31.10.17 12:45 Сейчас в теме
(7) Вы же понимаете, что у Вашего вопроса очень много если. Например, скорость СХД, на которой лежит файл. Доступные процессорные ресурсы и.т.д.
Сейчас попробовал у себя: 3,68 GB чистых SDBL'ей на шпинделе по сети распарсились до окончательного результата за 110 секунд. То же самое локально - 90 секунд.
10. stveans@gmail.com 11 01.11.17 12:21 Сейчас в теме
(9)А в сравнении на том же оборудовании с git bash, cygwin?
11. herfis 513 01.11.17 12:36 Сейчас в теме
(10) Так он в git bash и парсил, насколько я понял.
Кстати, вроде в Windows 10 запилили Windows Subsystem for Linux и для подобных вещей отпадает необходимость в установке cygwin и иже с ними.
Правда, не уверен на сто процентов, что получится из нотепада выполнять.
(8) В bash, при необходимости, тоже можно разбивать на фоны. В любом случае это заведомо быстрее, чем средствами 1С. И при этом универсальнее.
12. MrWonder 650 01.11.17 14:16 Сейчас в теме
(11) Всё верно, я использовал Git Bash. Об этом явно написано в начале статьи. Можно и под cygwin. И с bash в Win10 можно настроить (при условии наличия Perl). Но в рамках данной статьи я вариации со средой исполнения не буду расмматривать.
14. stveans@gmail.com 11 01.11.17 15:13 Сейчас в теме
(12)Понял. Недоглядел, думал этот плагин самостоятельный, а он оказывается использует стороннюю программу.
(10)Что касается подсистемы в Windows 10 - она ещё в бета версии и имеются ошибки. Например, у меня склейка строк с помощью awk неправильно работает в 10. В git bash, cygwin с этим всё в порядке.
13. MrWonder 650 01.11.17 14:17 Сейчас в теме
(9) отвечаю сам себе - используй команду time !
8. logarifm 1123 31.10.17 12:21 Сейчас в теме
Я пытался это решить посредствами самой 1С. Последовательным чтением файлов ТЖР. При этом разбивая на фоны.
https://infostart.ru/public/418347/
16. A_Max 20 08.11.17 13:27 Сейчас в теме
Очень порадовал комментарий "#perl умеет работать как AWK" :о)
Когда в первый раз увидел статью как раз и удивился смеси использования perl/grep/awk
17. MrWonder 650 09.11.17 09:38 Сейчас в теме
(16) Истоки сего смешения явились из здания на Дмитровском шоссе )
Эволюция по тексту тоже, думаю, прослеживается
EugeneSemyonov; A_Max; +2 Ответить
18. magicbuka 10.11.17 11:53 Сейчас в теме
(17) Алексей, а экзамен то в итоге сдали?
19. MrWonder 650 10.11.17 14:22 Сейчас в теме
(18) На текущий момент - нет.
20. starik-2005 3091 11.11.17 21:16 Сейчас в теме
25. emakei 11.01.18 09:36 Сейчас в теме
Когда-то экспериментировал с Perl 6 для этих целей. Скорости такой не получил, конечно. Но склеить строки за первый проход можно сразу, а потом отформатировать в html, например или во внутреннее представление по средствам классов, которые специальным образом обрабатывают "grammar".
Что нашёл из экспериментов с грамматиками (grammar):
https://gist.github.com/mrDSide/217695e9db031b9f32eb04a543298c53
Более развёрнутый пример с "made", "make" не нашёл уже. Но есть документация:
https://docs.perl6.org/language/grammars

П.С. делал разбор файла для ПУ-3 и получил полезный комментарий по поводу переноса строк (см. "token win - nl", "token lin-nl")
https://gist.github.com/araraloren/6051fd7aa24dad1b7f499e01bed3c03c
26. starik-2005 3091 11.01.18 10:20 Сейчас в теме
(25) а я вот sed использую - для большинства вещей хватает.
27. emakei 11.01.18 11:29 Сейчас в теме
(26) Уверен, что так и есть. Я мало пользуюсь утилитами командной строки linux (пока). А по поводу sed отличный комментарий дал автор курса по анализу технологического журнала 1С с помощью регулярных выражений - предлагает использовать "perl -pe" вместо sed, т.к. на больших объёмах данных они кэшируются и обработка происходит быстрее.
К слову, можете использовать эти же утилиты в сценариях на Perl 6, там есть возможность вызова утилит командной строки в момент выполнения сценария с получением результата (вывода команды), так же есть конвееры, кроме того ещё и двунаправленные, если можно так сказать ("<==" и "==>") :) Модуль есть для отладки регулярных выражений (Grammar::Tracer).
Хотя лично у меня получилось больше всего информации извлечь и отладить проще всего с помощью PowerShell ISE.

UPD: справедливости ради нужно заметить, что "perl -pe", конечно, вызов интерпретатора perl 5, т.к. именно он на данный момент является интерпретатором по-умолчанию
MrWonder; +1 Ответить
28. RailMen 828 11.01.18 14:07 Сейчас в теме
Только начал готовиться к эксперту, а тут такая статья в тему. Спасибо!
29. MrWonder 650 11.01.18 14:49 Сейчас в теме
30. lustin 11.01.18 17:48 Сейчас в теме
(0) всем не знающим регулярные выражения посвящается https://github.com/silverbulleters/verbal-expressions

ВербальноеВыражение = Новый ВербальноеВыражение()
    .НачалоСтроки()
    .Затем("http")
    .МожетБыть("s")
    .Затем("://")
    .ЧтоНибудьНоНе(" ")
    .КонецСтроки();
Показать
Perfolenta; kote; mickey.1cx; +3 Ответить
34. kote 537 03.09.18 07:57 Сейчас в теме
35. MrWonder 650 03.09.18 09:58 Сейчас в теме
36. kote 537 03.09.18 10:27 Сейчас в теме
31. ADirks 187 12.01.18 07:23 Сейчас в теме
Для пущего ускорения я бы файлы самим перлом читал, а не через конвейер (grep ... | perl)
Сам перл это делает сильно быстрее.

к примеру
open LOG, "< $log_fname";
foreach $line (<LOG>)
{
$line =~ m/^\s*dt=([\d.]+).*$/;
print $1;
}
close LOG;

для чтения кучи файлов с логами можно использовать пакет File::Find

годная документация по перлу с примерами например тут есть https://www.activestate.com/activeperl
(мне реализация АктивПерл для винды больше всего нравится)
kote; A_Max; mickey.1cx; artbear; MrWonder; +5 Ответить
32. MrWonder 650 12.01.18 09:39 Сейчас в теме
(31) Спасибо за совет. Я уже делаю так в текущих разработках. Как руки дойдут - дополню статью примером исключительно на Perl.
33. MrWonder 650 04.05.18 10:52 Сейчас в теме
(32) Отвечу сам себе, почему такого примера не будет. В описанных выше примерах чтение файлов и последующая обработка выполняется в разных процессах, и ОС использует разные процессоры. На протестированном мной однофайловом решении (чтение и обработка в Perl) задействуется всего один процессор. Таким образом описанное решение работает быстрее однофайлового и полностью на Perl. Поэтому его здесь и не будет.
AlexandrSmith; CratosX; +2 Ответить
38. пользователь 17.06.19 15:41
Сообщение было скрыто модератором.
...
39. пользователь 17.06.19 15:42
Сообщение было скрыто модератором.
...
40. MrWonder 650 19.06.19 20:32 Сейчас в теме
(39) Большое спасибо за Ваш отзыв. Рад, что пригодилось O:-)
41. пользователь 15.10.19 15:49
Сообщение было скрыто модератором.
...
42. user860784 24.04.20 16:22 Сейчас в теме
А можно как то сделать чтоб выбирать по времени? например от 40:00 до 42:00 все события получить?
43. MrWonder 650 25.04.20 22:00 Сейчас в теме
(42) Всё можно: пропустите после склейки через конвейер perl -ne 'prinf if /^4[0-2]\:\d{2}/'
44. user860784 28.04.20 14:14 Сейчас в теме
(43)
perl -ne 'prinf if /^4[0-2]\:\d{2}/'

Спасибо за ответ, подскажите еще как мне написать поиск от 10:20:30-10:20:31сек,
у меня никак не получается
45. MrWonder 650 28.04.20 16:10 Сейчас в теме
(44) Уверен, что вам стоит подучить регулярные выражения
perl -ne 'prinf if /^10\:20\:3[0-1]/'
46. Boris-Leleko 318 23.12.21 11:38 Сейчас в теме
Это все круто, только не работает потому что когда включаешь тех журнал на серьезной базе то у вас создается 100-500 папок для разных rphost и в каждой по многу файлов в зависимости от того сколько дней хранения указали и заходить в каждую папку и анализировать каждый файл, такое себе занятие.
47. Boris-Leleko 318 23.12.21 11:47 Сейчас в теме
(46) А без многофайлового решения статья несет чисто академический смысл.
48. EugeneSemyonov 22 15.02.23 13:32 Сейчас в теме
(46)
cat ПапкаТЖ/rphost_*/*.log
- выведет в стандартный вывод содержимое всех файлов лог из всех папок рабочих процессов. Дальше по конвейеру передаём и делаем что хотим: grep, perl, awk и т.д.
cat ПапкаТЖ/r*/*.log
- выведет так же логи процессов агента (ragent) и менеджера (rmngr).
Оставьте свое сообщение