मॉनिटर फ़ाइलों (एक ला पूंछ -f) एक पूरी निर्देशिका में (यहां तक ​​कि नए भी)

Question

मैं आमतौर पर एक निर्देशिका में कई लॉग देखता हूं tail -f directory/*। समस्या यह है कि एक नया लॉग बनाया जाता है उसके बाद, यह स्क्रीन में नहीं दिखाई देगा (क्योंकि *पहले से ही विस्तारित किया गया था)।

क्या किसी निर्देशिका में प्रत्येक फ़ाइल की निगरानी करने का एक तरीका है, यहां तक ​​कि जो प्रक्रिया शुरू होने के बाद बनाई गई हैं?

Answer 1

आप मल्टी प्ले फाइलों को… मल्टीटैल के साथ पूंछ सकते हैं ।

multitail -Q 1 'directory/*'

-Q 1 PATTERNमौजूदा या नई फ़ाइलों के लिए हर 1 सेकंड में पैटरन से मेल खाने वाली नई सामग्री की जाँच करने का मतलब है । सभी फ़ाइलों की लाइनें एक ही विंडो में दिखाई जाती हैं, अलग-अलग विंडो होने के -qबजाय उपयोग करें -Q।

Answer 2

xtailएक विकल्प भी है। इसका मैन पेज इस प्रकार है:

Xtail एक या अधिक फ़ाइलों की निगरानी करता है, और कमांड मंगलाचरण के बाद से फ़ाइल में लिखे गए सभी डेटा को प्रदर्शित करता है। यह एक साथ कई लॉगफाइल्स की निगरानी के लिए बहुत उपयोगी है। यदि कमांड लाइन पर दी गई प्रविष्टि एक निर्देशिका है, तो उस निर्देशिका की सभी फाइलों की निगरानी की जाएगी, जिसमें xtail आह्वान के बाद बनाई गई शामिल हैं। यदि कमांड लाइन पर दी गई प्रविष्टि मौजूद नहीं है, तो xtail इसके लिए देखेगा और इसे बनाए जाने के बाद मॉनिटर करेगा। प्रदर्शन में फ़ाइलों को स्विच करते समय, फ़ाइल का पथनाम दिखाने वाला एक बैनर मुद्रित होता है।

एक बाधा चरित्र (आमतौर पर CTRL / C या DEL) सबसे हाल ही में संशोधित फ़ाइलों की एक सूची प्रदर्शित करेगा। Xtail को रोकने के लिए एक सिग्नल (आमतौर पर CTRL / बैकस्लैश) छोड़ें।

Comments

लिंक टूट गया है, लेकिन मुझे लगता है कि जैसा है: manpages.ubuntu.com/manpages/zesty/man1/xtail.1.html

— edpaez

Answer 3

शेल समाधान के बारे में कोई विचार नहीं है, लेकिन (लिनक्स मानकर ¹) inotifyजाने का रास्ता हो सकता है ... इस उदाहरण को अनुकरण करते हुएtail -F ( देखेंpyinotify ) देखें, हो सकता है कि इसे पूरी निर्देशिका का अनुसरण करने के लिए एक आधार के रूप में इस्तेमाल किया जा सके ।

सामान्य तौर पर, inotifyनिर्देशिकाओं की निगरानी कर सकते हैं (हवाला देते हुए man 7 inotify)

Inotify_add_watch (2) को कॉल करते समय निम्नलिखित बिट्स को मास्क में निर्दिष्ट किया जा सकता है और पढ़े गए (2) द्वारा दिए गए मास्क फ़ील्ड में वापस लौटाया जा सकता है:

IN_ACCESS         File was accessed (read) (*).
IN_ATTRIB         Metadata changed, e.g., permissions, timestamps,
                    extended attributes, link count (since Linux 2.6.25),
                    UID, GID, etc. (*).
IN_CLOSE_WRITE    File opened for writing was closed (*).
IN_CLOSE_NOWRITE  File not opened for writing was closed (*).
IN_CREATE         File/directory created in watched directory (*).
IN_DELETE         File/directory deleted from watched directory (*).
IN_DELETE_SELF    Watched file/directory was itself deleted.
IN_MODIFY         File was modified (*).
IN_MOVE_SELF      Watched file/directory was itself moved.
IN_MOVED_FROM     File moved out of watched directory (*).
IN_MOVED_TO       File moved into watched directory (*).
IN_OPEN           File was opened (*).

जब एक निर्देशिका की निगरानी , घटनाओं तारांकित (*) से ऊपर निर्देशिका में फ़ाइलों के लिए हो सकता है, इस स्थिति में लौट आए inotify_event संरचना में नाम क्षेत्र निर्देशिका के भीतर फ़ाइल के नाम की पहचान के साथ चिह्नित।

(... और pyinotifyबारीकी से शोध के विकल्प)

1: BSDs, एक ऐसी ही बात है kqueue। हो सकता है कि एक क्रॉस-प्लेटफ़ॉर्म समाधान जीआईओ ( पायथन बाइंडिंग ) का उपयोग कर प्राप्त करने योग्य हो, क्योंकि यह एब्सट्रैक्शन परत के रूप में हो सकता है, बगल inotifyमें भी उपयोग कर सकता हैkqueue

Answer 4

मैंने एक त्वरित लिखा है जो आवश्यकता को पूरा करता है।

#!/bin/bash
LOG_PATTERN=$1
BASE_DIR=$(dirname $LOG_PATTERN* | head -1)

run_thread (){
    echo Running thread
    tail -F $LOG_PATTERN* &
    THREAD_PID=$!
}

# When someone decides to stop the script - killall children
cleanup () {
    pgrep -P $$ | xargs -i kill {}
    exit
}

trap cleanup SIGHUP SIGINT SIGTERM

if [ $# -ne 1 ]; then
    echo "usage: $0 <directory/pattern without * in the end>"
    exit 1
fi

# Wait for the directory to be created
if [ ! -d $BASE_DIR ] ; then
    echo DIR $BASE_DIR does not exist, waiting for it...
    while [ ! -d $BASE_DIR ] ; do
        sleep 2
    done
    echo DIR $BASE_DIR is now online
fi

# count current number of files
OLD_NUM_OF_FILES=$(ls -l $LOG_PATTERN* 2>/dev/null | wc -l)

# Start Tailing
run_thread

while [ 1 ]; do
    # If files are added - retail
    NUM_FILES=$(ls -l $LOG_PATTERN* 2>/dev/null | wc -l)
    if [ $NUM_FILES -ne $OLD_NUM_OF_FILES ]; then
        OLD_NUM_OF_FILES=$NUM_FILES
        kill $THREAD_PID
        run_thread
    fi
    sleep 1
done

Comments

वास्तव में, आप मुख्य लूप में नींद 1 को ommit कर सकते हैं, नई फाइलें प्राप्त करने के लिए अधिक तेज़ होंगे। लेकिन मुझे उस तरह का व्यस्त इंतजार पसंद नहीं है

— इटमार

इसके कारण sleepव्यस्त प्रतीक्षा नहीं है, लेकिन सीपीयू पर नरम, सिर्फ मतदान। कोई भी इसे sleep 0.2s(GNU स्लीप) में बदल सकता है या आवश्यकता पड़ने पर इसे तेज़ कर सकता है।

— Ned64

Answer 5

इसके अलावा, आप के साथ निर्देशिका देख सकते हैं watch

watch -n0,1 "ls -lrt /directory/ | tail"

Comments

माइनर नाइटपिक: कमांड से आउटपुट watchकी पहली x लाइनों के साथ, वैकल्पिक बफर में स्क्रीन को फिर से रीड करता है । बिना किसी परिवर्तन के कई फ़ाइलों के साथ, यदि पहले की फ़ाइलें नहीं बदलती हैं, तो tailहर बार एक ही चीज़ प्रस्तुत कर सकते हैं, इसलिए आपको कोई अतिरिक्त प्रविष्टियाँ नहीं मिलेंगी, क्योंकि वे बाद की फ़ाइलों में 'नीचे' के नीचे खींची जाती हैं। स्क्रीन। एक छोटी फ़ाइल के लिए, हालांकि, यह ठीक है ...

— jimbobmcgee 20

यह मूल समस्या का हल नहीं देता है। यह निर्देशिका watchमें सभी फ़ाइलों (नई वाली सहित) की नवीनतम लाइनों के बजाय केवल एक निर्देशिका लिस्टिंग (बार-बार, हमेशा चालू - धन्यवाद ) की आउटपुट (अंतिम कुछ पंक्तियाँ) ।

— trs