ലോഗുകൾ കാണുന്നതിന് ലോകത്തിലെ ഏറ്റവും സൗകര്യപ്രദമായ ഇന്റർഫേസ് ഞങ്ങൾ വികസിപ്പിക്കുകയാണ്

ലോഗുകൾ കാണുന്നതിന് നിങ്ങൾ എപ്പോഴെങ്കിലും വെബ് ഇന്റർഫേസുകൾ ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, ചട്ടം പോലെ, ഈ ഇന്റർഫേസുകൾ എങ്ങനെ ബുദ്ധിമുട്ടുള്ളതും (പലപ്പോഴും) വളരെ സൗകര്യപ്രദവും പ്രതികരിക്കാത്തതുമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം. ചിലത് നിങ്ങൾക്ക് പരിചിതമാണ്, ചിലത് തികച്ചും ഭയാനകമാണ്, എന്നാൽ എല്ലാ പ്രശ്നങ്ങൾക്കും കാരണം ലോഗുകൾ കാണുന്നതിനുള്ള ചുമതലയെ ഞങ്ങൾ തെറ്റായി സമീപിക്കുന്നതാണ് എന്ന് എനിക്ക് തോന്നുന്നു: CLI (കമാൻഡ് ലൈൻ ഇന്റർഫേസ്) ഉള്ള ഒരു വെബ് ഇന്റർഫേസ് സൃഷ്ടിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു. നന്നായി പ്രവർത്തിക്കുന്നു. ടെയിൽ, grep, awk എന്നിവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നത് എനിക്ക് വ്യക്തിപരമായി വളരെ സുഖകരമാണ്, അതിനാൽ ലോഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിന് എനിക്ക് അനുയോജ്യമായ ഇന്റർഫേസ് tail, grep എന്നിവയ്ക്ക് സമാനമായ ഒന്നായിരിക്കും, എന്നാൽ പല സെർവറുകളിൽ നിന്നും വരുന്ന ലോഗുകൾ വായിക്കാനും ഇത് ഉപയോഗിക്കാം. അതായത്, തീർച്ചയായും, ക്ലിക്ക്ഹൗസിൽ നിന്ന് അവ വായിക്കുക!

*ഹബ്ര ഉപയോക്താവിന്റെ വ്യക്തിപരമായ അഭിപ്രായം അനുസരിച്ച് നിങ്ങളുടെ റോക്ക്

ലോഗ്സ്ക്ലിയെ കണ്ടുമുട്ടുക

എന്റെ ഇന്റർഫേസിനായി ഞാൻ ഒരു പേര് കൊണ്ടുവന്നിട്ടില്ല, സത്യസന്ധമായി പറഞ്ഞാൽ, ഇത് ഒരു പ്രോട്ടോടൈപ്പിന്റെ രൂപത്തിലാണ് നിലനിൽക്കുന്നത്, എന്നാൽ നിങ്ങൾക്ക് ഉടനടി സോഴ്‌സ് കോഡ് കാണാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് സ്വാഗതം: https://github.com/YuriyNasretdinov/logscli (തിരഞ്ഞെടുത്ത ഗോ കോഡിന്റെ 350 വരികൾ).

സവിശേഷതകൾ

ടെയിൽ/ഗ്രെപ്പ് ഉപയോഗിക്കുന്നവർക്ക് പരിചിതമെന്ന് തോന്നുന്ന ഒരു ഇന്റർഫേസ് ഉണ്ടാക്കുക എന്നതായിരുന്നു എന്റെ ലക്ഷ്യം, അതായത്, ഇനിപ്പറയുന്ന കാര്യങ്ങൾ പിന്തുണയ്ക്കുക:

1. ഫിൽട്ടർ ചെയ്യാതെ എല്ലാ ലോഗുകളും കാണുക.
2. ഒരു നിശ്ചിത സബ്‌സ്ട്രിംഗ് അടങ്ങിയ ലൈനുകൾ വിടുക (ഫ്ലാഗ് -F у grep).
3. പതിവ് എക്സ്പ്രഷനുമായി പൊരുത്തപ്പെടുന്ന വരികൾ വിടുക (ഫ്ലാഗ് -E у grep).
4. ഡിഫോൾട്ടായി, കാണുന്നത് വിപരീത കാലക്രമത്തിലാണ്, കാരണം ഏറ്റവും പുതിയ ലോഗുകൾ സാധാരണയായി ആദ്യം താൽപ്പര്യമുള്ളതാണ്.
5. ഓരോ വരിയുടെയും അടുത്തായി സന്ദർഭം കാണിക്കുക (ഓപ്ഷനുകൾ -A, -B и -C у grep, യഥാക്രമം ഓരോ പൊരുത്തപ്പെടുന്ന ലൈനിന് മുമ്പും ശേഷവും ചുറ്റും N ലൈനുകൾ അച്ചടിക്കുന്നു).
6. ഫിൽട്ടറിംഗ് ഉപയോഗിച്ചോ അല്ലാതെയോ ഇൻകമിംഗ് ലോഗുകൾ തത്സമയം കാണുക (അത്യാവശ്യമായി tail -f | grep).
7. ഇന്റർഫേസ് അനുയോജ്യമായിരിക്കണം less, head, tail മറ്റുള്ളവ - സ്ഥിരസ്ഥിതിയായി, അവയുടെ എണ്ണത്തിൽ നിയന്ത്രണങ്ങളില്ലാതെ ഫലങ്ങൾ നൽകണം; ഉപയോക്താവിന് അവ സ്വീകരിക്കാൻ താൽപ്പര്യമുള്ളിടത്തോളം വരികൾ ഒരു സ്ട്രീം ആയി അച്ചടിക്കുന്നു; സിഗ്നൽ SIGPIPE അവർ ചെയ്യുന്നതുപോലെ ലോഗ് സ്ട്രീമിംഗിനെ നിശബ്ദമായി തടസ്സപ്പെടുത്തണം tail, grep മറ്റ് UNIX യൂട്ടിലിറ്റികളും.

നടപ്പാക്കൽ

ClickHouse-ലേക്ക് ലോഗുകൾ എങ്ങനെ നൽകണമെന്ന് നിങ്ങൾക്ക് ഇതിനകം എങ്ങനെയെങ്കിലും അറിയാമെന്ന് ഞാൻ അനുമാനിക്കും. ഇല്ലെങ്കിൽ, ഇത് പരീക്ഷിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു ഫലവുമില്ല и പൂച്ചക്കുട്ടി, അതുപോലെ തന്നെ ലോഗ് ഡെലിവറി സംബന്ധിച്ച ഈ ലേഖനം.

ആദ്യം നിങ്ങൾ അടിസ്ഥാന സ്കീം തീരുമാനിക്കേണ്ടതുണ്ട്. നിങ്ങൾ സാധാരണയായി സമയത്തിനനുസരിച്ച് അടുക്കിയ ലോഗുകൾ സ്വീകരിക്കാൻ ആഗ്രഹിക്കുന്നതിനാൽ, അവ ആ രീതിയിൽ സംഭരിക്കുന്നത് യുക്തിസഹമാണെന്ന് തോന്നുന്നു. നിരവധി ലോഗ് വിഭാഗങ്ങൾ ഉണ്ടെങ്കിൽ അവയെല്ലാം ഒരേ തരത്തിലുള്ളതാണെങ്കിൽ, പ്രാഥമിക കീയുടെ ആദ്യ നിരയായി നിങ്ങൾക്ക് ഒരു ലോഗ് വിഭാഗം ഉണ്ടാക്കാം - ഇത് പലതിനുപകരം ഒരു ടേബിൾ ഉണ്ടായിരിക്കാൻ നിങ്ങളെ അനുവദിക്കും, ഇത് എപ്പോൾ വലിയ പ്ലസ് ആയിരിക്കും ClickHouse-ലേക്ക് ചേർക്കുന്നു (ഹാർഡ് ഡ്രൈവുകളുള്ള സെർവറുകളിൽ, സെക്കൻഡിൽ ~1 തവണയിൽ കൂടുതൽ ഡാറ്റ ചേർക്കാൻ ശുപാർശ ചെയ്യുന്നു മുഴുവൻ സെർവറിനും).

അതായത്, ഞങ്ങൾക്ക് ഏകദേശം ഇനിപ്പറയുന്ന പട്ടിക സ്കീം ആവശ്യമാണ്:

CREATE TABLE logs(
    category LowCardinality(String), -- категория логов (опционально)
    time DateTime, -- время события
    millis UInt16, -- миллисекунды (могут быть и микросекунды, и т.д.): рекомендуется хранить, если событий много, чтобы было легче различать события между собой
    ..., -- ваши собственные поля, например имя сервера, уровень логирования, и так далее
    message String -- текст сообщения
) ENGINE=MergeTree()
ORDER BY (category, time, millis)

നിർഭാഗ്യവശാൽ, എനിക്ക് പിടിച്ചെടുക്കാനും ഡൗൺലോഡ് ചെയ്യാനും കഴിയുന്ന റിയലിസ്റ്റിക് ലോഗുകളുള്ള ഓപ്പൺ സോഴ്‌സുകളൊന്നും എനിക്ക് ഉടനടി കണ്ടെത്താൻ കഴിഞ്ഞില്ല, അതിനാൽ ഞാൻ ഇതൊരു ഉദാഹരണമായി എടുത്തു 2015-ന് മുമ്പ് ആമസോണിൽ നിന്നുള്ള ഉൽപ്പന്നങ്ങളുടെ അവലോകനങ്ങൾ. തീർച്ചയായും, അവയുടെ ഘടന ടെക്സ്റ്റ് ലോഗുകളുടേതിന് സമാനമല്ല, പക്ഷേ ചിത്രീകരണ ആവശ്യങ്ങൾക്ക് ഇത് പ്രധാനമല്ല.

ClickHouse-ലേക്ക് Amazon അവലോകനങ്ങൾ അപ്‌ലോഡ് ചെയ്യുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ

നമുക്ക് ഒരു പട്ടിക ഉണ്ടാക്കാം:

CREATE TABLE amazon(
   review_date Date,
   time DateTime DEFAULT toDateTime(toUInt32(review_date) * 86400 + rand() % 86400),
   millis UInt16 DEFAULT rand() % 1000,
   marketplace LowCardinality(String),
   customer_id Int64,
   review_id String,
   product_id LowCardinality(String),
   product_parent Int64,
   product_title String,
   product_category LowCardinality(String),
   star_rating UInt8,
   helpful_votes UInt32,
   total_votes UInt32,
   vine FixedString(1),
   verified_purchase FixedString(1),
   review_headline String,
   review_body String
)
ENGINE=MergeTree()
ORDER BY (time, millis)
SETTINGS index_granularity=8192

ആമസോൺ ഡാറ്റാസെറ്റിൽ ഒരു അവലോകനത്തിന് ഒരു തീയതി മാത്രമേ ഉള്ളൂ, പക്ഷേ കൃത്യമായ സമയമില്ല, അതിനാൽ നമുക്ക് ഈ ഡാറ്റ ഒരു റാൻഡൺ ഉപയോഗിച്ച് പൂരിപ്പിക്കാം.

10 GB RAM-ന് അനുയോജ്യമല്ലാത്ത ഒരു വലിയ ഡാറ്റാ സെറ്റ് ലഭിക്കുന്നതിന് നിങ്ങൾ എല്ലാ tsv ഫയലുകളും ഡൗൺലോഡ് ചെയ്യുകയും ആദ്യത്തെ ~20-16 വരെ പരിമിതപ്പെടുത്തുകയും ചെയ്യേണ്ടതില്ല. TSV ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്നതിന് ഞാൻ ഇനിപ്പറയുന്ന കമാൻഡ് ഉപയോഗിച്ചു:

for i in *.tsv; do
    echo $i;
    tail -n +2 $i | pv |
    clickhouse-client --input_format_allow_errors_ratio 0.5 --query='INSERT INTO amazon(marketplace,customer_id,review_id,product_id,product_parent,product_title,product_category,star_rating,helpful_votes,total_votes,vine,verified_purchase,review_headline,review_body,review_date) FORMAT TabSeparated'
done

1000 GB വലിപ്പമുള്ള ഗൂഗിൾ ക്ലൗഡിലെ ഒരു സാധാരണ പെർസിസ്റ്റന്റ് ഡിസ്‌കിൽ (ഇത് ഒരു HDD ആണ്) (ഞാൻ ഈ വലുപ്പം എടുത്തത് പ്രധാനമായും സ്പീഡ് അൽപ്പം കൂടുതലായതുകൊണ്ടാണ്, ഒരുപക്ഷെ ആവശ്യമായ വലുപ്പത്തിലുള്ള ഒരു SSD വിലകുറഞ്ഞതായിരിക്കുമെങ്കിലും) അപ്‌ലോഡ് വേഗത 75 കോറുകളിൽ ഏകദേശം ~ 4 MB/sec ആയിരുന്നു.

• ഞാൻ Google-ൽ ജോലി ചെയ്യുന്ന ഒരു റിസർവേഷൻ ചെയ്യണം, പക്ഷേ ഞാൻ ഒരു സ്വകാര്യ അക്കൗണ്ട് ഉപയോഗിച്ചു, ഈ ലേഖനത്തിന് കമ്പനിയിലെ എന്റെ ജോലിയുമായി യാതൊരു ബന്ധവുമില്ല

ഈ പ്രത്യേക ഡാറ്റാസെറ്റ് ഉപയോഗിച്ച് ഞാൻ എല്ലാ ചിത്രീകരണങ്ങളും നിർമ്മിക്കും, കാരണം ഇത് എന്റെ കൈയിലുണ്ട്.

ഡാറ്റ സ്കാനിംഗ് പുരോഗതി കാണിക്കുക

ClickHouse-ൽ ഞങ്ങൾ ലോഗുകളുള്ള ഒരു ടേബിളിൽ ഒരു പൂർണ്ണ സ്കാൻ ഉപയോഗിക്കും, കൂടാതെ ഈ പ്രവർത്തനത്തിന് ഗണ്യമായ സമയമെടുക്കുകയും കുറച്ച് പൊരുത്തങ്ങൾ കണ്ടെത്തിയാൽ ദീർഘകാലത്തേക്ക് ഫലങ്ങളൊന്നും നൽകാതിരിക്കുകയും ചെയ്യുന്നതിനാൽ, കാണിക്കാൻ കഴിയുന്നത് ഉചിതമാണ്. ഫലത്തോടുകൂടിയ ആദ്യ വരികൾ ലഭിക്കുന്നതുവരെ അന്വേഷണത്തിന്റെ പുരോഗതി. ഇത് ചെയ്യുന്നതിന്, HTTP തലക്കെട്ടുകളിൽ പുരോഗതി അയയ്ക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പാരാമീറ്റർ HTTP ഇന്റർഫേസിൽ ഉണ്ട്: send_progress_in_http_headers=1. നിർഭാഗ്യവശാൽ, സ്റ്റാൻഡേർഡ് Go ലൈബ്രറിക്ക് തലക്കെട്ടുകൾ ലഭിക്കുന്നത് പോലെ വായിക്കാൻ കഴിയില്ല, എന്നാൽ HTTP 1.0 ഇന്റർഫേസ് (1.1 മായി തെറ്റിദ്ധരിക്കരുത്!) ClickHouse പിന്തുണയ്ക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് ClickHouse-ലേക്ക് ഒരു റോ TCP കണക്ഷൻ തുറന്ന് അത് അവിടെ അയക്കാം. GET /?query=... HTTP/1.0nn കൂടാതെ പ്രതികരണ തലക്കെട്ടുകളും ബോഡിയും രക്ഷപ്പെടുകയോ എൻക്രിപ്ഷനോ ഇല്ലാതെ സ്വീകരിക്കുക, അതിനാൽ ഈ സാഹചര്യത്തിൽ ഞങ്ങൾ സാധാരണ ലൈബ്രറി പോലും ഉപയോഗിക്കേണ്ടതില്ല.

ClickHouse-ൽ നിന്നുള്ള സ്ട്രീമിംഗ് ലോഗുകൾ

താരതമ്യേന വളരെക്കാലമായി (2019 മുതൽ?) ഓർഡർ വഴിയുള്ള ചോദ്യങ്ങൾക്ക് ക്ലിക്ക്ഹൗസിന് ഒപ്റ്റിമൈസേഷൻ ഉണ്ട്, അതിനാൽ ഒരു ചോദ്യം

SELECT time, millis, message
FROM logs
WHERE message LIKE '%something%'
ORDER BY time DESC, millis DESC

സ്കാൻ പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കാതെ, സന്ദേശത്തിൽ "എന്തെങ്കിലും" എന്ന സബ്‌സ്ട്രിംഗ് ഉള്ള വരികൾ ഇത് ഉടൻ തന്നെ തിരികെ നൽകാൻ തുടങ്ങും.

കൂടാതെ, അതിലേക്കുള്ള കണക്ഷൻ അടച്ചിരിക്കുമ്പോൾ ക്ലിക്ക്ഹൗസ് തന്നെ അഭ്യർത്ഥന റദ്ദാക്കിയാൽ അത് വളരെ സൗകര്യപ്രദമായിരിക്കും, എന്നാൽ ഇത് സ്ഥിരസ്ഥിതി സ്വഭാവമല്ല. ഓപ്ഷൻ ഉപയോഗിച്ച് യാന്ത്രിക അഭ്യർത്ഥന റദ്ദാക്കൽ പ്രവർത്തനക്ഷമമാക്കാം cancel_http_readonly_queries_on_client_close=1.

Go-യിൽ SIGPIPE ശരിയായി കൈകാര്യം ചെയ്യുക

നിങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, പറയുക, കമാൻഡ് some_cmd | head -n 10, കൃത്യമായി എങ്ങനെ കമാൻഡ് some_cmd എപ്പോൾ എക്സിക്യൂഷൻ നിർത്തുന്നു head 10 വരികൾ കുറച്ചോ? ഉത്തരം ലളിതമാണ്: എപ്പോൾ head അവസാനിക്കുന്നു, പൈപ്പ് അടയ്ക്കുന്നു, കൂടാതെ some_cmd കമാൻഡിന്റെ stdout, സോപാധികമായി, "എവിടേയും" പോയിന്റ് ചെയ്യാൻ തുടങ്ങുന്നു. എപ്പോൾ some_cmd അടച്ച പൈപ്പിലേക്ക് എഴുതാൻ ശ്രമിക്കുന്നു, ഇതിന് ഒരു SIGPIPE സിഗ്നൽ ലഭിക്കുന്നു, ഇത് സ്ഥിരസ്ഥിതിയായി പ്രോഗ്രാമിനെ നിശബ്ദമായി അവസാനിപ്പിക്കുന്നു.

Go-യിൽ ഇതും സ്ഥിരസ്ഥിതിയായി സംഭവിക്കുന്നു, എന്നാൽ SIGPIPE സിഗ്നൽ ഹാൻഡ്‌ലറും അവസാനം "സിഗ്നൽ: SIGPIPE" അല്ലെങ്കിൽ സമാനമായ ഒരു സന്ദേശവും പ്രിന്റ് ചെയ്യുന്നു, ഈ സന്ദേശം മായ്‌ക്കുന്നതിന് നമ്മൾ ആഗ്രഹിക്കുന്ന രീതിയിൽ SIGPIPE കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്, അതായത് നിശബ്ദമായി പുറത്ത്:

ch := make(chan os.Signal)
signal.Notify(ch, syscall.SIGPIPE)
go func() {
    <-ch
    os.Exit(0)
}()

സന്ദേശ സന്ദർഭം കാണിക്കുക

ചില പിശകുകൾ സംഭവിച്ച സന്ദർഭം (ഉദാഹരണത്തിന്, ഏത് അഭ്യർത്ഥനയാണ് പരിഭ്രാന്തി സൃഷ്ടിച്ചത്, അല്ലെങ്കിൽ തകരുന്നതിന് മുമ്പ് എന്ത് അനുബന്ധ പ്രശ്നങ്ങൾ ദൃശ്യമായിരുന്നു) grep ഇത് -A, -B, -C ഓപ്‌ഷനുകൾ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്, ഇത് സന്ദേശത്തിന് യഥാക്രമം യഥാക്രമം ശേഷവും മുമ്പും ചുറ്റുമുള്ള വരികളുടെ എണ്ണം കാണിക്കുന്നു.

നിർഭാഗ്യവശാൽ, ClickHouse-ൽ ഇത് ചെയ്യാനുള്ള എളുപ്പവഴി ഞാൻ കണ്ടെത്തിയില്ല, അതിനാൽ സന്ദർഭം പ്രദർശിപ്പിക്കുന്നതിന്, ഫലത്തിന്റെ ഓരോ വരിയിലേക്കും ഇതുപോലുള്ള ഒരു അധിക അഭ്യർത്ഥന അയയ്‌ക്കുന്നു (വിശദാംശങ്ങൾ അടുക്കുന്നതിനെയും സന്ദർഭം മുമ്പ് കാണിച്ചിട്ടുണ്ടോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു അല്ലെങ്കിൽ ശേഷം):

SELECT time,millis,review_body FROM amazon
WHERE (time = 'ВРЕМЯ_СОБЫТИЯ' AND millis < МИЛЛИСЕКУНДЫ_СОБЫТИЯ) OR (time < 'ВРЕМЯ_СОБЫТИЯ')
ORDER BY time DESC, millis DESC
LIMIT КОЛИЧЕСТВО_СТРОК_КОНТЕКСТА
SETTINGS max_threads=1

ClickHouse അനുബന്ധ ലൈൻ തിരികെ നൽകിയ ഉടൻ തന്നെ അഭ്യർത്ഥന അയയ്‌ക്കുന്നതിനാൽ, അത് കാഷെയിൽ അവസാനിക്കുകയും പൊതുവെ അഭ്യർത്ഥന വളരെ വേഗത്തിൽ നടപ്പിലാക്കുകയും കുറച്ച് CPU ഉപയോഗിക്കുകയും ചെയ്യുന്നു (സാധാരണയായി അഭ്യർത്ഥന എന്റെ വെർച്വൽ മെഷീനിൽ ഏകദേശം ~6 ms എടുക്കും).

പുതിയ സന്ദേശങ്ങൾ തത്സമയം കാണിക്കുക

ഇൻകമിംഗ് സന്ദേശങ്ങൾ (ഏതാണ്ട്) തത്സമയം കാണിക്കുന്നതിന്, ഞങ്ങൾ മുമ്പ് നേരിട്ട അവസാന ടൈംസ്റ്റാമ്പ് ഓർത്തുകൊണ്ട് കുറച്ച് സെക്കൻഡിൽ ഒരിക്കൽ അഭ്യർത്ഥന നടപ്പിലാക്കുന്നു.

കമാൻഡ് ഉദാഹരണങ്ങൾ

സാധാരണ logscli കമാൻഡുകൾ പ്രായോഗികമായി എങ്ങനെയിരിക്കും?

ലേഖനത്തിന്റെ തുടക്കത്തിൽ ഞാൻ സൂചിപ്പിച്ച ആമസോൺ ഡാറ്റാസെറ്റ് നിങ്ങൾ ഡൗൺലോഡ് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും:

# Показать строки, где встречается слово walmart
$ logscli -F 'walmart' | less

# Показать самые свежие 10 строк, где встречается "terrible"
$ logscli -F terrible -limit 10

# То же самое без -limit:
$ logscli -F terrible | head -n 10

# Показать все строки, подходящие под /times [0-9]/, написанные для vine и у которых высокий рейтинг
$ logscli -E 'times [0-9]' -where="vine='Y' AND star_rating>4" | less

# Показать все строки со словом "panic" и 3 строки контекста вокруг
$ logscli -F 'panic' -C 3 | less

# Непрерывно показывать новые строки со словом "5-star"
$ logscli -F '5-star' -tailf

റെഫറൻസുകൾ

യൂട്ടിലിറ്റി കോഡ് (ഡോക്യുമെന്റേഷൻ ഇല്ലാതെ) github-ൽ ലഭ്യമാണ് https://github.com/YuriyNasretdinov/logscli. ClickHouse അടിസ്ഥാനമാക്കിയുള്ള ലോഗുകൾ കാണുന്നതിനുള്ള കൺസോൾ ഇന്റർഫേസിനായുള്ള എന്റെ ആശയത്തെക്കുറിച്ചുള്ള നിങ്ങളുടെ ചിന്തകൾ കേൾക്കുന്നതിൽ എനിക്ക് സന്തോഷമുണ്ട്.

അവലംബം: www.habr.com