ट्रैक
/
Elixir
Elixir
/
अभ्यास
/
लॉग पार्सर
लॉग पार्सर

लॉग पार्सर

सीखने का अभ्यास

परिचय

रेगुलर एक्सप्रेशन

Elixir में रेगुलर एक्सप्रेशन PCRE स्पेसिफिकेशन (Perl Compatible Regular Expressions) का पालन करते हैं। ऐसा ही Java, JavaScript या Ruby जैसी दूसरी लोकप्रिय भाषाओं में भी होता है।

Regex मॉड्यूल में रेगुलर एक्सप्रेशन के साथ काम करने के लिए फंक्शन मौजूद हैं। String मॉड्यूल के कुछ फंक्शन भी आर्गुमेंट के तौर पर रेगुलर एक्सप्रेशन लेते हैं।

Note

इस अभ्यास में यह मान लिया गया है कि आप रेगुलर एक्सप्रेशन का सिंटैक्स पहले से जानते हैं, जिसमें कैरेक्टर क्लास, क्वांटिफायर, ग्रुप और कैप्चर शामिल हैं।

अगर आपको अपने रेगुलर एक्सप्रेशन के ज्ञान को दोहराना है, तो इनमें से किसी एक स्रोत को देखिए: Regular-Expressions.info, Rex Egg, RegexOne, Regular Expressions 101, RegExr.

सिगिल

रेगुलर एक्सप्रेशन बनाने का सबसे आम तरीका ~r सिगिल का उपयोग करना है।

~r/test/

ध्यान दीजिए कि Elixir के सारे सिगिल में सिर्फ / ही नहीं, बल्कि कई तरह के डेलिमिटर इस्तेमाल किए जा सकते हैं।

मैच करना

=~/2 ऑपरेटर की मदद से रेगुलर एक्सप्रेशन का मैच किया जा सकता है, जो boolean परिणाम लौटाता है। इसके अलावा Regex मॉड्यूल और String मॉड्यूल दोनों में match?/2 फंक्शन भी हैं।

"this is a test" =~ ~r/test/
# => true

String.match?("Alice has 7 apples", ~r/\d{2}/)
# => false

कैप्चर करना

अगर सिर्फ बूलियन जाँच से काम नहीं चलता, तो Regex.run/3 फंक्शन का उपयोग कीजिए। यह सारे कैप्चर का एक ऐरे लौटाता है (और अगर कोई मैच नहीं मिला, तो nil)। लौटाए गए ऐरे का पहला एलिमेंट हमेशा पूरे रेगुलर एक्सप्रेशन के मैच से मेल खाता है, और उसके बाद के एलिमेंट मैच हुए ग्रुप होते हैं।

Regex.run(~r/(\d) apples/, "Alice has 7 apples")
# => ["7 apples", "7"]

मॉडिफायर

रेगुलर एक्सप्रेशन का व्यवहार खास फ्लैग जोड़कर बदला जा सकता है। सिगिल से रेगुलर एक्सप्रेशन बनाते समय मॉडिफायर दूसरे डेलिमिटर के बाद लगाइए।

आम मॉडिफायर ये हैं:

  • i - मैच करते समय छोटे और बड़े अक्षरों में फर्क नहीं करता।
  • u - \p जैसे Unicode-विशेष पैटर्न को चालू करता है, और साथ ही \w, \s जैसे कैरेक्टर क्लास को Unicode से भी मैच कराता है।
"this is a TEST" =~ ~r/test/i
# => true

निर्देश

हाल ही में हुई एक सुरक्षा समीक्षा के बाद आपको संस्था की संग्रहीत लॉग फाइलें साफ़ करने के लिए कहा गया है।

1. गड़बड़ी वाली लॉग लाइनों की पहचान कीजिए

आपको अंदाज़ा लगाना है कि आपके संग्रह में कितनी लॉग लाइनें मौजूदा मानकों के अनुरूप नहीं हैं। आपको लगता है कि एक आसान जाँच से पता चल जाता है कि कोई लॉग लाइन मान्य है या नहीं। किसी लाइन को मान्य मानने के लिए ज़रूरी है कि वह निम्नलिखित में से किसी एक स्ट्रिंग से शुरू हो:

  • [DEBUG]
  • [INFO]
  • [WARNING]
  • [ERROR]

valid_line?/1 फंक्शन बनाइए, जो लॉग लाइन मान्य होने पर true लौटाता है।

LogParser.valid_line?("[ERROR] Network Failure")
# => true

LogParser.valid_line?("Network Failure")
# => false

2. लॉग लाइन को बाँटिए

लॉग पार्सिंग का प्रोजेक्ट शुरू करने के कुछ ही देर बाद आपको पता चलता है कि एक एप्लिकेशन के लॉग बाकी की तरह लाइनों में नहीं बँटे होते। इस प्रोजेक्ट में जो अलग-अलग लाइनें होनी चाहिए थीं, वे सब एक ही लाइन पर होती हैं और <---> या <*~*~> जैसे अनोखे तीरों से जुड़ी होती हैं।

वास्तव में, इस प्रोजेक्ट के लॉग में ऐसी कोई भी स्ट्रिंग सेपरेटर के तौर पर काम कर सकती है जिसका पहला अक्षर < हो, अंतिम अक्षर > हो, और बीच में ~, *, = और - में से कोई भी संयोजन हो।

एक लाइन लेकर स्ट्रिंगों का ऐरे लौटाने वाला split_line/1 फंक्शन बनाइए।

LogParser.split_line("[INFO] Start.<*>[INFO] Processing...<~~~>[INFO] Success.")
# => ["[INFO] Start.", "[INFO] Processing...", "[INFO] Success."]

3. लॉग से अवशेष हटाइए

आपने पाया है कि लॉग की कुछ अपस्ट्रीम प्रोसेसिंग की वजह से "end-of-line" टेक्स्ट, जिसके तुरंत बाद बिना किसी स्पेस के एक लाइन नंबर आता है, पूरे लॉग में बिखर गया है।

remove_artifacts/1 फंक्शन बनाइए, जो एक स्ट्रिंग लेता है, उसमें मौजूद हर "end-of-line" टेक्स्ट को हटा देता है (छोटे-बड़े अक्षरों से फर्क नहीं पड़ता) और एक साफ़ लॉग लाइन लौटाता है।

जिन लाइनों में "end-of-line" टेक्स्ट नहीं है, उन्हें बिना बदले लौटाया जाना चाहिए।

सिर्फ "end-of-line" स्ट्रिंग हटाइए; स्पेस को ठीक करने की कोई ज़रूरत नहीं है।

LogParser.remove_artifacts("[WARNING] end-of-line23033 Network Failure end-of-line27")
# => "[WARNING]  Network Failure "

4. उपयोगकर्ता के नाम से लाइनों पर टैग लगाइए

आपने देखा है कि कुछ लॉग लाइनों में ऐसे वाक्य होते हैं जिनमें उपयोगकर्ताओं का ज़िक्र होता है। इन वाक्यों में हमेशा "User" स्ट्रिंग होती है, जिसके बाद एक या अधिक स्पेस अक्षर और फिर उपयोगकर्ता का नाम आता है। आप ऐसी लाइनों पर टैग लगाने का फैसला करते हैं।

लॉग लाइनों को प्रोसेस करने वाला tag_with_user_name/1 फंक्शन बनाइए:

  • जिन लाइनों में "User" स्ट्रिंग नहीं होती, वे बिना बदले रहती हैं।
  • जिन लाइनों में "User" स्ट्रिंग होती है, उनके आगे [USER] और उसके बाद उपयोगकर्ता का नाम लगाइए।
LogParser.tag_with_user_name("[INFO] User Alice created a new project")
# => "[USER] Alice [INFO] User Alice created a new project"

आप यह मान सकते हैं कि:

  • "User" स्ट्रिंग जहाँ भी आती है, उसके बाद एक या अधिक स्पेस अक्षर और फिर उपयोगकर्ता का नाम आता है।
  • हर लाइन पर "User" स्ट्रिंग अधिकतम एक बार आती है।
  • उपयोगकर्ता के नाम खाली नहीं होते और उनमें कोई स्पेस नहीं होता।
GitHub के ज़रिए संपादित करें यह लिंक एक नई विंडो या टैब में खुलता है
Elixir Exercism

लॉग पार्सर शुरू करने के लिए तैयार हैं?

Exercism पर साइन अप कीजिए और Elixir को 58 कॉन्सेप्ट168 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।