మేము లాగ్‌లను వీక్షించడానికి ప్రపంచంలోనే అత్యంత అనుకూలమైన ఇంటర్‌ఫేస్‌ను అభివృద్ధి చేస్తున్నాము

మీరు ఎప్పుడైనా లాగ్‌లను వీక్షించడానికి వెబ్ ఇంటర్‌ఫేస్‌లను ఉపయోగించినట్లయితే, నియమం ప్రకారం, ఈ ఇంటర్‌ఫేస్‌లు ఎలా గజిబిజిగా ఉంటాయి మరియు (తరచుగా) చాలా సౌకర్యవంతంగా మరియు ప్రతిస్పందించేవి కావు. కొన్ని మీరు అలవాటు చేసుకోవచ్చు, కొన్ని ఖచ్చితంగా భయంకరమైనవి, కానీ అన్ని సమస్యలకు కారణం మేము లాగ్‌లను తప్పుగా చూసే పనిని చేరుకోవడమే అని నాకు అనిపిస్తోంది: మేము CLI (కమాండ్ లైన్ ఇంటర్‌ఫేస్) ఉన్న వెబ్ ఇంటర్‌ఫేస్‌ను రూపొందించడానికి ప్రయత్నిస్తాము. మెరుగ్గా పనిచేస్తుంది. నేను వ్యక్తిగతంగా tail, grep, awk మరియు ఇతరులతో పని చేయడం చాలా సౌకర్యంగా ఉన్నాను, అందువల్ల నాకు లాగ్‌లతో పని చేయడానికి అనువైన ఇంటర్‌ఫేస్ టెయిల్ మరియు grep లాగా ఉంటుంది, కానీ ఇది చాలా సర్వర్‌ల నుండి వచ్చిన లాగ్‌లను చదవడానికి కూడా ఉపయోగించవచ్చు. అంటే, క్లిక్‌హౌస్ నుండి వాటిని చదవండి!

* హబ్రా యూజర్ యొక్క వ్యక్తిగత అభిప్రాయం ప్రకారం మీ ROCK

logscliని కలవండి

నేను నా ఇంటర్‌ఫేస్‌కు పేరు పెట్టలేదు మరియు నిజం చెప్పాలంటే, ఇది ప్రోటోటైప్ రూపంలో ఉంది, కానీ మీరు వెంటనే సోర్స్ కోడ్‌ని చూడాలనుకుంటే, మీకు స్వాగతం: 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 యుటిలిటీలు.

అమలు

క్లిక్‌హౌస్‌కి లాగ్‌లను ఎలా బట్వాడా చేయాలో మీకు ఇప్పటికే తెలిసిందని నేను ఊహిస్తాను. కాకపోతే, ప్రయత్నించమని నేను సిఫార్సు చేస్తున్నాను LSD и పిల్లి ఇల్లుమరియు లాగ్ డెలివరీ గురించి ఈ కథనం.

మొదట మీరు బేస్ పథకంపై నిర్ణయం తీసుకోవాలి. మీరు సాధారణంగా కాలానుగుణంగా క్రమబద్ధీకరించబడిన లాగ్‌లను స్వీకరించాలనుకుంటున్నారు కాబట్టి, వాటిని ఆ విధంగా నిల్వ చేయడం లాజికల్‌గా అనిపిస్తుంది. అనేక లాగ్ కేటగిరీలు ఉంటే మరియు అవన్నీ ఒకే రకంగా ఉంటే, మీరు ప్రాథమిక కీ యొక్క మొదటి నిలువు వరుసగా లాగ్ వర్గాన్ని తయారు చేయవచ్చు - ఇది అనేక పట్టికలకు బదులుగా ఒక టేబుల్‌ని కలిగి ఉండటానికి మిమ్మల్ని అనుమతిస్తుంది, ఇది ఎప్పుడు పెద్ద ప్లస్ అవుతుంది క్లిక్‌హౌస్‌లోకి చొప్పించడం (హార్డ్ డ్రైవ్‌లు ఉన్న సర్వర్‌లలో, సెకనుకు ~1 సార్లు కంటే ఎక్కువ డేటాను ఇన్సర్ట్ చేయకూడదని సిఫార్సు చేయబడింది మొత్తం సర్వర్ కోసం).

అంటే, మనకు ఈ క్రింది పట్టిక పథకం అవసరం:

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

దురదృష్టవశాత్తూ, నేను పట్టుకోగలిగే మరియు డౌన్‌లోడ్ చేయగల వాస్తవిక లాగ్‌లతో కూడిన ఓపెన్ సోర్స్‌లు ఏవీ వెంటనే కనుగొనలేకపోయాను, కాబట్టి నేను దీన్ని ఉదాహరణగా తీసుకున్నాను 2015 వరకు Amazon నుండి ఉత్పత్తుల సమీక్షలు. వాస్తవానికి, వాటి నిర్మాణం టెక్స్ట్ లాగ్‌ల మాదిరిగానే ఉండదు, కానీ ఇలస్ట్రేషన్ ప్రయోజనాల కోసం ఇది ముఖ్యమైనది కాదు.

Amazon సమీక్షలను ClickHouseకి అప్‌లోడ్ చేయడానికి సూచనలు

పట్టికను సృష్టిద్దాం:

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 పరిమాణంతో Google క్లౌడ్‌లోని ప్రామాణిక పెర్సిస్టెంట్ డిస్క్‌లో (ఇది HDD) (నేను ఈ పరిమాణాన్ని ప్రధానంగా తీసుకున్నాను, దీని వలన వేగం కొంచెం ఎక్కువగా ఉంటుంది, అయితే అవసరమైన పరిమాణంలో SSD చౌకగా ఉండవచ్చు) అప్‌లోడ్ వేగం 75 కోర్లలో సుమారు ~ 4 MB/సెకను.

• నేను Googleలో పని చేస్తున్నానని తప్పనిసరిగా రిజర్వేషన్ చేసుకోవాలి, కానీ నేను వ్యక్తిగత ఖాతాను ఉపయోగించాను మరియు ఈ కథనానికి కంపెనీలో నా పనికి ఎటువంటి సంబంధం లేదు

నేను ఈ నిర్దిష్ట డేటాసెట్‌తో అన్ని ఇలస్ట్రేషన్‌లను రూపొందిస్తాను, ఎందుకంటే ఇది నా చేతిలో ఉంది.

డేటా స్కానింగ్ పురోగతిని చూపు

క్లిక్‌హౌస్‌లో మేము లాగ్‌లతో కూడిన టేబుల్‌పై పూర్తి స్కాన్‌ని ఉపయోగిస్తాము మరియు ఈ ఆపరేషన్‌కు గణనీయమైన సమయం పట్టవచ్చు మరియు కొన్ని మ్యాచ్‌లు కనుగొనబడితే ఎక్కువ కాలం ఎటువంటి ఫలితాలను ఇవ్వకపోవచ్చు కాబట్టి, దాన్ని చూపించగలగడం మంచిది ఫలితంతో మొదటి వరుసలు వచ్చే వరకు ప్రశ్న యొక్క పురోగతి. దీన్ని చేయడానికి, HTTP ఇంటర్‌ఫేస్‌లో ఒక పరామితి ఉంది, ఇది HTTP హెడర్‌లలో పురోగతిని పంపడానికి మిమ్మల్ని అనుమతిస్తుంది: send_progress_in_http_headers=1. దురదృష్టవశాత్తూ, ప్రామాణిక Go లైబ్రరీ శీర్షికలను స్వీకరించినట్లుగా చదవదు, కానీ HTTP 1.0 ఇంటర్‌ఫేస్ (1.1తో గందరగోళం చెందకూడదు!) ClickHouse ద్వారా మద్దతు ఉంది, కాబట్టి మీరు ClickHouseకి ముడి TCP కనెక్షన్‌ని తెరిచి అక్కడకు పంపవచ్చు. GET /?query=... HTTP/1.0nn మరియు ఎలాంటి ఎస్కేపింగ్ లేదా ఎన్‌క్రిప్షన్ లేకుండా ప్రతిస్పందన హెడర్‌లు మరియు బాడీని స్వీకరించండి, కాబట్టి ఈ సందర్భంలో మనం ప్రామాణిక లైబ్రరీని కూడా ఉపయోగించాల్సిన అవసరం లేదు.

ClickHouse నుండి స్ట్రీమింగ్ లాగ్‌లు

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.

గోలో SIGPIPE యొక్క సరైన నిర్వహణ

మీరు ఆదేశాన్ని అమలు చేసినప్పుడు, చెప్పండి some_cmd | head -n 10, సరిగ్గా ఎలా ఆదేశం some_cmd ఎప్పుడు అమలును నిలిపివేస్తుంది head 10 పంక్తులు తీసివేసారా? సమాధానం సులభం: ఎప్పుడు head ముగుస్తుంది, పైపు మూసివేయబడుతుంది మరియు some_cmd కమాండ్ యొక్క stdout షరతులతో "ఎక్కడికి" సూచించడం ప్రారంభమవుతుంది. ఎప్పుడు some_cmd మూసివేసిన పైపుకు వ్రాయడానికి ప్రయత్నిస్తుంది, ఇది SIGPIPE సిగ్నల్‌ను అందుకుంటుంది, ఇది డిఫాల్ట్‌గా ప్రోగ్రామ్‌ను నిశ్శబ్దంగా ముగించింది.

గోలో ఇది కూడా డిఫాల్ట్‌గా జరుగుతుంది, కానీ SIGPIPE సిగ్నల్ హ్యాండ్లర్ కూడా చివరలో "సిగ్నల్: SIGPIPE" లేదా ఇలాంటి సందేశాన్ని ప్రింట్ చేస్తుంది మరియు ఈ సందేశాన్ని క్లియర్ చేయడానికి మనం SIGPIPEని మనకు కావలసిన విధంగా నిర్వహించాలి, అంటే నిశ్శబ్దంగా బయటకి దారి:

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

సందేశ సందర్భాన్ని చూపు

తరచుగా మీరు ఏదైనా లోపం సంభవించిన సందర్భాన్ని చూడాలనుకుంటున్నారు (ఉదాహరణకు, ఏ అభ్యర్థన భయాందోళనకు కారణమైంది లేదా క్రాష్‌కు ముందు ఏ సంబంధిత సమస్యలు కనిపించాయి) మరియు grep ఇది -A, -B మరియు -C ఎంపికలను ఉపయోగించి చేయబడుతుంది, ఇది వరుసగా సందేశం తర్వాత, ముందు మరియు చుట్టూ పేర్కొన్న పంక్తుల సంఖ్యను చూపుతుంది.

దురదృష్టవశాత్తూ, క్లిక్‌హౌస్‌లో అదే విధంగా చేయడానికి నేను సులభమైన మార్గాన్ని కనుగొనలేదు, కాబట్టి సందర్భాన్ని ప్రదర్శించడానికి, ఫలితం యొక్క ప్రతి పంక్తికి ఇలాంటి అదనపు అభ్యర్థన పంపబడుతుంది (వివరాలు క్రమబద్ధీకరించడం మరియు సందర్భం ముందు చూపబడిందా లేదా అనే దానిపై ఆధారపడి ఉంటుంది లేదా తర్వాత):

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

సూచనలు

యుటిలిటీ కోడ్ (డాక్యుమెంటేషన్ లేకుండా) గిథబ్‌లో అందుబాటులో ఉంది https://github.com/YuriyNasretdinov/logscli. ClickHouse ఆధారంగా లాగ్‌లను వీక్షించడానికి కన్సోల్ ఇంటర్‌ఫేస్ కోసం నా ఆలోచనపై మీ ఆలోచనలను వినడానికి నేను సంతోషిస్తాను.

మూలం: www.habr.com