रीयलटाइम डैशबोर्ड

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

तुरंत मैं दिखाना चाहता हूं कि क्या हुआ



सर्वर साइड

प्रत्येक सर्वर पर जहां कोई लॉग होता है, हम उस पर लैच करते हैं

tail -f /var/log/log | perl frenko_sender.pl 

frenko_sender.pl

 #!/usr/local/bin/perl -w use strict; use IO::Socket; my($sock, $server_host, $msg, $PORTNO); $PORTNO = 15555; $server_host = '188.xxx'; $sock = IO::Socket::INET->new(Proto => 'udp', PeerPort => $PORTNO, PeerAddr => $server_host) or die "Creating socket: $!\n"; while (<>){ $sock->send($_) } 

जैसा कि आप देख सकते हैं, frenko_sender.pl बस यूडीपी लॉग से प्रत्येक लाइन को सर्वर पर भेजता है जहां डेटा एकत्र किया जाएगा। वैसे, आप इस स्क्रिप्ट के बिना भी कर सकते हैं, यदि आप udp लॉग को तुरंत उस जगह पर भेजना सिखाते हैं, जिसकी हमें ज़रूरत है, अच्छी तरह से, और जैसा कि Dreadatour nc ( Netcat ) ने नोट किया, किसी ने भी रद्द नहीं किया:

 tail -f /var/log/log | nc -u 188.xxx 15555 

एक मोती संस्करण को चुना गया था, क्योंकि योजनाओं में सर्वरों के बीच लोड को वितरित करने के लिए वहाँ लुटेरों के एक दौर को पेंच करना शामिल है जो लॉग को संसाधित करेगा।

अब उस सर्वर (frenko_listen.pl) के बारे में जो हमारे लिए आंकड़ों पर विचार करता है, IO :: Lambda के लिए Dima Karasik के लिए धन्यवाद, क्योंकि यह उस पर था जिसे मैंने चुना था।

frenko_listen.pl लाइन (1-30)

 #!/usr/local/bin/perl -w use strict; use warnings; use Cache::Memcached::Fast; use IO::Socket; use IO::Lambda qw(:all); use IO::Lambda::Socket qw(:all); use Getopt::Std; use POSIX qw/setsid/; my $PORT=15555; my $LOCALHOST ='188.xxx'; my $CONFIG='./frenko_config'; my $time_to_die=0; my $memd = new Cache::Memcached::Fast({ servers => [ { address => 'localhost:11211', weight => 2.5 }], connect_timeout => 0.2, io_timeout => 0.5, close_on_error => 1, max_failures => 3, failure_timeout => 2, ketama_points => 150, nowait => 1, utf8 => ($^V >= 5.008001 ? 1 : 0), }); 

$ LOCALHOST हमारे सर्वर के लिए एक बाहरी IP पता है जो UDP पर पोर्ट 15555 पर सुनता है। जैसा कि आपने अनुमान लगाया था, हम संस्मरण =) में संख्याएँ लिखेंगे।

frenko_listen.pl लाइन (32-46)

 my %Regexps=(); load_config(\%Regexps); sub load_config{ my $re=shift; %{$re}=(); open (F,$CONFIG) || die 'cant open config '.$CONFIG; while (<F>){ next if /^[\s\n]+$/; my ($regexp,$key,undef,$rate)=split("\t",$_,4); $$re{$key}{re}=$regexp; $$re{$key}{rate}=$rate || 1; } close (F); } 

यहां हम कॉन्फ़िगरेशन को नियमित अभिव्यक्तियों के साथ लोड करते हैं, जिसके द्वारा हम आँकड़ों की गणना के नियमों को निर्धारित करेंगे। विन्यास इस तरह दिखता है:

frenko_config

 errdescr= 9 [E2;Javascript error at web interface - nginx acclog] 1 errorcode=\d+ 10 [E3;Fail upload with errorcode - nginx acclog] 1 

पहले कॉलम में एक नियमितता है, फिर एक अद्वितीय कुंजी जिसके द्वारा हम चार्ट पर डेटा पढ़ेंगे और प्रदर्शित करेंगे, तीसरे कॉलम में त्रुटि विवरण छोटा और पूर्ण है, लेकिन अंतिम कॉलम में यह संभावना है जिसके साथ हम डेटा को बचाएंगे। उदाहरण के लिए, यदि हम उपयोगकर्ता को एक ग्राफ पर हिट करते हैं, तो हमारे पास एक ही ग्राफ पर घटता के बीच एक बड़ा अंतर होगा, उदाहरण के लिए, इस दौरान 3 त्रुटियां और 30,000 हिट, वे इस स्थिति के लिए एक लघुगणकीय पैमाने का उपयोग करते हैं, लेकिन मैं चाहता हूं कि यह सुंदर हो। इसलिए, हिट के लिए हम उदाहरण के लिए सेट करेंगे 0.1 - इसका मतलब है कि केवल 10% में हम हिट काउंटर को बढ़ाएंगे।

frenko_listen.pl लाइन (49-80)

 sub sendstat{ my ($key,$rate,$memd)= @ _; if ($rate==1 || $rate<rand()){ saver($key,$_,$memd) for (2,300,1200) } } sub saver{ my ($key,$accur,$memd)=@ _; my $memc=startpoint($accur); $key=$key.'_'.$accur.'_'.$memc; my $ttl=1000; if ($accur==300){$ttl=7400} elsif($accur==1200){$ttl=87000} $memd->set($key,1,$ttl) unless $memd->incr($key); } sub startpoint{ my $accur=shift; my $t=time(); my $x=$t % $accur; my $memc=$t-$x; return $memc; } 

यहां हम सीधे अपने डेटा के लिए काउंटर बढ़ाते हैं। और हम शेड्यूल के लिए 2x, 300 और 1200 दूसरी कोशिकाओं में डेटा स्टोर करते हैं, जो हर 3 सेकंड में अपडेट होते हैं, हर 5 मिनट में एक बार और 20 मिनट के बाद। 2 सेकंड सेल के लिए उदाहरण के लिए मेम्के की कुंजी (हमारे frenko_config से जावास्क्रिप्ट त्रुटि के लिए) इस तरह दिखाई देगी: 300-300 सेल के लिए 9_2_1338129044, 9_2_1338129046: 9_300_1338121800, 9_300_1338122100 आदि।

frenko_listen.pl लाइन (82-128)

 sub udp_server(&@) { my ($callback, $port, $host) = @ _ ; my $server = IO::Socket::INET-> new( Proto => 'udp', LocalPort => $port, LocalHost => $host, Blocking => 0, ); return $! unless $server; return lambda { context $server, 65536, 0; recv { my ( $addr, $msg) = @ _ ; again; context $callback-> (), $addr, $msg; &tail(); }} } sub handle_incoming_connection_udp { lambda { my ( $addr, $msg ) = @ _ ; if (length($msg)>5){ if (! index($msg,'reconfig')){ load_config(\%Regexps); } else { foreach (keys %Regexps){ if ($msg=~/$Regexps{$_}{re}/){ sendstat($_,$Regexps{$_}{rate},$memd); last; } } } } } } sub runserv{ my $server = udp_server { handle_incoming_connection_udp } $PORT,$LOCALHOST; die $server unless ref $server; $server-> wait; } 

लॉग प्रोसेसिंग सब हैंडल_इनिंग_कनेक्शन_यूडीपी के अंदर होती है। हम देखते हैं कि यदि रेखा 5 वर्णों से अधिक लंबी है, तो हम इसे पार्स करना शुरू करते हैं। कॉन्फिग से लोड किए गए हमारे नियमित की सूची के माध्यम से जा रहे हैं।

एक स्थिति की कल्पना करें, उदाहरण के लिए, आप तीन सौ सर्वरों पर लॉग सुनते हैं, और आपको कॉन्फ़िगरेशन में एक नई नियमितता जोड़ने की आवश्यकता है, यदि आप frenko_listen.pl को रोकते हैं, तो आप डेटा खो देंगे। ऐसी स्थितियों से बचने के लिए, आपको हमारे सर्वर को फ़्लाई पर अपडेट करने के लिए सिखाना होगा, जो ऊपर किया गया है। अगर हमें एक लाइन मिलती है जो 'रीकफिग' से शुरू होती है, तो हम कॉन्फिगरेशन को ओवरलोड करते हैं। और हां, रैपर के बारे में मत भूलो जो गिरावट के दौरान हमारे frenko_sender.pl को बढ़ाएगा।

यहां, वैसे, आपको यह सोचने की ज़रूरत है कि माइलेज =) का अनुकूलन कैसे करें।

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

फिलहाल, यह पता चला है कि जब 1042 लॉग लाइनें प्रति सेकंड (15 नियमित के विन्यास में) प्रसंस्करण होती हैं, तो प्रोसेसर लोड 30-32% होता है

  4-  Intel(R) Xeon(R) CPU E5405 @ 2.00GHz 

जब आप ऐसी संख्या देखते हैं, तो यह दुखी हो जाता है। हम चौथे पैरामीटर के रूप में सूचकांक () के लिए एक अभिव्यक्ति जोड़कर हमारे कॉन्फिगर को फिर से करेंगे - इससे चीजों को गति मिलनी चाहिए।

frenko_config

 errdescr= 9 [E2;Javascript error at web interface - nginx acclog] 1 errdescr= errorcode=\d+ 10 [E3;Fail upload with errorcode - nginx acclog] 1 errorcode= 

और हमारे कॉन्फ़िगर लोडिंग और पार्सिंग फ़ंक्शन को भी थोड़ा बदलें:

 sub load_config{ my $re=shift; %{$re}=(); open (F,$CONFIG) || die 'cant open config '.$CONFIG; while (<F>){ next if /^[\s\n]+$/; my ($regexp,$key,undef,$rate,$index)=split("\t",$_,5); $index=~s/[\n\t\r]//g; $$re{$key}{re}=$regexp; $$re{$key}{index}=$index; $$re{$key}{rate}=$rate || 1; } close (F); } sub handle_incoming_connection_udp { lambda { my ( $addr, $msg ) = @_; if (length($msg)>5){ if (substr($msg,0,8) eq 'reconfig'){ load_config(\%Regexps); } else { foreach my $key(keys %Regexps){ if (index($msg,$Regexps{$key}{index})>=0){ if ($Regexps{$key}{index} eq $Regexps{$key}{re}){ sendstat($key,$Regexps{$key}{rate},$memd); last; }elsif($msg=~/$Regexps{$key}{re}/){ sendstat($key,$Regexps{$key}{rate},$memd); last; } } } } } } } 

इन संशोधनों ने प्रतिशत लोड को थोड़ा कम कर दिया, यह 25-28% निकला। आदर्श रूप से, कम से कम 10% प्राप्त करें।

मेमेकटेड डेटा इस प्रकार है:

 STAT uptime 601576 STAT bytes_read 358221242 STAT bytes_written 92007777 STAT bytes 5018318 STAT curr_items 62269 STAT total_items 557908 STAT reclaimed 372969 

आगे बढ़ते हैं

frenko_listen.pl लाइन (130-157)

 sub signal_handler{ $time_to_die=1; } getopts('d:', my $opts = {}); if (exists $opts->{d}) { print "start daemon\n"; my $pid=fork; exit if $pid; die 'Couldn\'t fork: '.$! unless defined($pid); for my $handle (*STDIN, *STDOUT, *STDERR){ open ($handle, '+<', '/dev/null' ) || die 'Cant\t reopen '.$handle.' to /dev/null: '.$!; } POSIX::setsid() || die 'Can\'t start a new session: '.$!; $time_to_die=0; $SIG{TERM} = $SIG{INT} = $SIG{HUP}= \&signal_handler; until ($time_to_die){ runserv(); } } else { runserv() } 

यहाँ, हमने अपने सर्वर को -d फ्लैग द्वारा डिमॉनेटाइज़ करना सिखाया।

कुल मिलाकर, हमें एक अच्छी तरह से स्केलेबल सर्वर आर्किटेक्चर मिला। यह छोटे के लिए मामला है। चलो ग्राहक पक्ष पर चलते हैं।

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

मैं ग्राहक भाग के लिए डेटा को फास्टकॉग स्क्रिप्ट के साथ देता हूं, यह मेमचैच में जाता है और दिए गए समय के लिए अंक देता है।

चार्ट स्वयं दो प्रश्न करता है: यह प्रारंभिक आरंभीकरण है और चार्ट के लिए नए बिंदुओं का एक हिस्सा है। इन प्रश्नों के उत्तर इस तरह दिखते हैं:
/frenky.fpl?init=1&accur=2

 {"status":"1","init":[["U1",[[1338188480,19],[1338188482,21],[1338188484,11],[1338188486,19],[1338188488,13],[1338188490,9],[1338188492,13],[1338188494,18],[1338188496,14],[1338188498,21],[1338188500,17],[1338188502,13],[1338188504,21],[1338188506,19],[1338188508,22],[1338188510,23],[1338188512,14],[1338188514,17],[1338188516,24],[1338188518,15],[1338188520,23],[1338188522,19],[1338188524,20]],"User uploaded the file - apache errlog"]]} 

/frenky.fpl?refresh=1&accur=2

 {"status":"1","refresh":[[1338188814,20],[1338188814,1],[1338188814,0],[1338188814,0],[1338188814,0],[1338188814,0],[1338188814,0],[1338188814,8],[1338188814,7],[1338188814,0],[1338188814,0],[1338188814,0]]} 

जिन समस्याओं का मुझे सामना करना पड़ा है, उनमें से एक यह है कि, अगर दो चल रही फास्टैगी प्रक्रियाओं के मामले में, हम चाहते हैं कि वे नियमित रूप से अपने कॉन्फ़िगरेशन को अपडेट करें। वेब इंटरफेस के माध्यम से दोनों प्रक्रियाओं तक कैसे पहुंचें - मुझे अभी तक एक सुंदर समाधान नहीं मिला है, इसलिए मैं अपाचे को फिर से शुरू करता हूं।

आप js और fcgi, rdash.rar सहित सभी स्रोतों को डाउनलोड कर सकते हैं

अद्यतन
टिप्पणियों में वर्णित सभी अनुकूलन के बाद, निम्नलिखित संख्याएं प्राप्त हुईं:
80 हजार सीपीयू के प्रति सेकंड 50 हजार लाइनों के भार पर
यदि आप छँटाई के नियम जोड़ते हैं तो 80 हज़ार लाइनें प्रति सेकंड और CPU का 90%

https://github.com/frenkyoptic/rdash