🚀 👇🏽 🔫 अमेज़ॅन एथेना और क्यूब.जेएस का उपयोग करके नंगेक्स एनालिटिक्स 👩🏾‍⚖️ 👩‍🎨 🧜🏻

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

इस लेख में मैं आपको बताऊंगा कि नग्नेक्स का उपयोग करते हुए लॉग का विश्लेषण करने के लिए एथेना का उपयोग कैसे किया जाता है, और यह दिखाते हैं कि खुले स्रोत वाले क्यूब.जेएस ढांचे का उपयोग करके इस डेटा से विश्लेषणात्मक डैशबोर्ड कैसे संकलित किया जाए । यहाँ पूर्ण समाधान वास्तुकला है:

आर्किटेक्चर

टीएल: डीआर;
तैयार डैशबोर्ड से लिंक करें ।

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

नग्नेक्स लॉग्स एकत्रित करना

डिफ़ॉल्ट रूप से, Nginx लॉग कुछ इस तरह दिखता है:

4/9/2019 12:58:17 PM1.1.1.1 - - [09/Apr/2019:09:58:17 +0000] "GET /sign-up HTTP/2.0" 200 9168 "https://example.com/sign-in" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36" "-" 4/9/2019 12:58:17 PM1.1.1.1 - - [09/Apr/2019:09:58:17 +0000] "GET /sign-in HTTP/2.0" 200 9168 "https://example.com/sign-up" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36" "-"

उन्हें पार्स किया जा सकता है, लेकिन Nginx कॉन्फ़िगरेशन को ठीक करना बहुत आसान है ताकि यह JSON में लॉग प्रदर्शित करे:

 log_format json_combined escape=json '{ "created_at": "$msec", ' '"remote_addr": "$remote_addr", ' '"remote_user": "$remote_user", ' '"request": "$request", ' '"status": $status, ' '"bytes_sent": $bytes_sent, ' '"request_length": $request_length, ' '"request_time": $request_time, ' '"http_referrer": "$http_referer", ' '"http_x_forwarded_for": "$http_x_forwarded_for", ' '"http_user_agent": "$http_user_agent" }'; access_log /var/log/nginx/access.log json_combined;

भंडारण के लिए S3

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

एथेना कंसोल में एक आरेख बनाएं

लॉग के लिए एथेना में एक तालिका बनाएं। यदि आपको Kinesis Firehose का उपयोग करने की योजना है, तो इसे लिखने और पढ़ने दोनों के लिए आवश्यक है। एथेना कंसोल खोलें और एक टेबल बनाएं:

SQL तालिका निर्माण

 CREATE EXTERNAL TABLE `kinesis_logs_nginx`( `created_at` double, `remote_addr` string, `remote_user` string, `request` string, `status` int, `bytes_sent` int, `request_length` int, `request_time` double, `http_referrer` string, `http_x_forwarded_for` string, `http_user_agent` string) ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.orc.OrcSerde' STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.orc.OrcInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat' LOCATION 's3://<YOUR-S3-BUCKET>' TBLPROPERTIES ('has_encrypted_data'='false');

Kinesis Firehose स्ट्रीम बनाएँ

Kinesis Firehose, चयनित YYYY / MM / DD / HH प्रारूप में निर्देशिकाओं में विभाजित Nginx से S3 तक प्राप्त डेटा को चयनित प्रारूप में लिखेगा। डेटा पढ़ते समय यह उपयोगी है। आप निश्चित रूप से धाराप्रवाह से सीधे S3 पर लिख सकते हैं, लेकिन इस मामले में आपको JSON लिखना होगा, जो बड़े फ़ाइल आकार के कारण अक्षम है। इसके अलावा, PrestoDB या एथेना का उपयोग करते समय, JSON सबसे धीमा डेटा प्रारूप है। तो Kinesis Firehose कंसोल खोलें, "डिलीवरी स्ट्रीम बनाएं" पर क्लिक करें, "डिलीवरी" फ़ील्ड में "डायरेक्ट PUT" चुनें:

किनेसिस फायरहॉस कंसोल 1

अगले टैब में, "रिकॉर्ड स्वरूप रूपांतरण" - "सक्षम" चुनें और रिकॉर्डिंग के लिए प्रारूप के रूप में "अपाचे ओआरसी" चुनें। कुछ ओवेन ओ'माली के अनुसार, यह प्रेस्टोबीडी और एथेना के लिए इष्टतम प्रारूप है। आरेख के रूप में, हम उस तालिका को इंगित करते हैं जो हमने ऊपर बनाई थी। कृपया ध्यान दें कि आप kinesis में किसी भी S3 स्थान को निर्दिष्ट कर सकते हैं, केवल योजना का उपयोग तालिका से किया जाता है। लेकिन यदि आप एक और एस 3 स्थान निर्दिष्ट करते हैं, तो इस तालिका से इन रिकॉर्डों को पढ़ने से काम नहीं चलेगा।

किनेसिस फायरहॉस कंसोल 2

हम भंडारण के लिए S3 और उस बाल्टी को चुनते हैं जिसे हमने पहले बनाया था। Aws Glue Crawler, जिसके बारे में मैं थोड़ी देर बाद बात करूंगा, S3 बाल्टी में उपसर्गों के साथ काम करना नहीं जानता, इसलिए इसे खाली छोड़ना महत्वपूर्ण है।

किनेसिस फायरहॉस कंसोल 3

आपके लोड के आधार पर शेष विकल्प बदले जा सकते हैं, मैं आमतौर पर डिफ़ॉल्ट का उपयोग करता हूं। ध्यान दें कि S3 संपीड़न उपलब्ध नहीं है, लेकिन ORC डिफ़ॉल्ट रूप से मूल संपीड़न का उपयोग करता है।

Fluentd

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

सबसे पहले, हमें फ्लुएंट.कॉन कॉन्फ़िगरेशन फ़ाइल की आवश्यकता है। इसे बनाएं और स्रोत जोड़ें:

आगे टाइप करें
पोर्ट 24224
बाँध 0.0.0.0

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

 $ docker run \ -d \ -p 24224:24224 \ -p 24224:24224/udp \ -v /data:/fluentd/log \ -v <PATH-TO-FLUENT-CONF>:/fluentd/etc fluentd \ -c /fluentd/etc/fluent.conf fluent/fluentd:stable

यह कॉन्फ़िगरेशन भेजने से पहले कैश लॉग में /fluentd/log पथ का उपयोग करता है। आप इसके बिना कर सकते हैं, लेकिन तब जब आप पुनः आरंभ करते हैं, तो आप अत्यधिक श्रम द्वारा कैच किए गए सब कुछ खो सकते हैं। किसी भी पोर्ट का उपयोग किया जा सकता है, 24224 डिफ़ॉल्ट फ्लुएंट पोर्ट है।

अब जबकि हमारे पास फ्लुएंटड चल रहा है, हम वहां नग्नेक्स लॉग भेज सकते हैं। हम आमतौर पर डोजर कंटेनर में नग्नेक्स चलाते हैं, जिस स्थिति में डॉकर के पास फ्लुएंट के लिए एक देशी लॉग ड्राइवर है:

 $ docker run \ --log-driver=fluentd \ --log-opt fluentd-address=<FLUENTD-SERVER-ADDRESS>\ --log-opt tag=\"{{.Name}}\" \ -v /some/content:/usr/share/nginx/html:ro \ -d \ nginx

यदि आप Nginx को अलग तरीके से चलाते हैं, तो आप लॉग फाइल का उपयोग कर सकते हैं, फ्लुएंट में एक फाइल टेल प्लगइन है ।

धाराप्रवाह कॉन्फ़िगरेशन के लिए ऊपर लॉग इन पार्सिंग जोड़ें:

 <filter YOUR-NGINX-TAG.*> @type parser key_name log emit_invalid_record_to_error false <parse> @type json </parse> </filter>

और Kinesis फ़ायरहोज़ प्लगइन का उपयोग करके Kinesis को लॉग भेज रहा है:

 <match YOUR-NGINX-TAG.*> @type kinesis_firehose region region delivery_stream_name <YOUR-KINESIS-STREAM-NAME> aws_key_id <YOUR-AWS-KEY-ID> aws_sec_key <YOUR_AWS-SEC_KEY> </match>

एथेना

यदि आपने सब कुछ सही तरीके से कॉन्फ़िगर किया है, तो थोड़ी देर बाद (डिफ़ॉल्ट रूप से, किनिस हर 10 मिनट में प्राप्त डेटा लिखता है) आपको S3 में लॉग फ़ाइलों को देखना चाहिए। Kinesis Firehose "निगरानी" मेनू में, आप देख सकते हैं कि S3 को कितना डेटा लिखा गया है, साथ ही त्रुटियां भी। काइनिस की भूमिका के लिए S3 बकेट को लिखित पहुँच देना न भूलें। यदि किनिस कुछ पार्स करने में सक्षम नहीं था, तो वह एक ही बाल्टी में त्रुटियां जोड़ देगा।

अब आप एथेना में डेटा देख सकते हैं। आइए कुछ नए प्रश्नों को देखें जिनके बारे में हमने त्रुटियां दी हैं:

 SELECT * FROM "db_name"."table_name" WHERE status > 499 ORDER BY created_at DESC limit 10;

प्रत्येक अनुरोध के लिए सभी रिकॉर्ड स्कैन करें

अब हमारे लॉग को संसाधित किया जाता है और ओआरसी में एस 3 में स्टैक किया जाता है, संकुचित और विश्लेषण के लिए तैयार होता है। Kinesis Firehose भी उन्हें हर घंटे के लिए निर्देशिका में डाल दिया। हालाँकि, जब तालिका का विभाजन नहीं किया जाता है, तो एथेना दुर्लभ अपवादों के साथ, प्रत्येक क्वेरी के लिए ऑल-टाइम डेटा लोड करेगा। यह दो कारणों से एक बड़ी समस्या है:

डेटा की मात्रा लगातार बढ़ रही है, प्रश्नों को धीमा कर रही है;
एथेना को प्रत्येक अनुरोध के लिए न्यूनतम 10 एमबी के साथ स्कैन किए गए डेटा की मात्रा के आधार पर बिल दिया जाता है।

इसे ठीक करने के लिए, हम AWS Glue Crawler का उपयोग करते हैं, जो S3 में डेटा को स्कैन करेगा और Glue Metastore में विभाजन की जानकारी रिकॉर्ड करेगा। यह हमें एथेना में अनुरोधों के लिए एक फिल्टर के रूप में विभाजन का उपयोग करने की अनुमति देगा, और यह केवल अनुरोध में निर्दिष्ट निर्देशिकाओं को स्कैन करेगा।

Amazon Glue Crawler को अनुकूलित करें

अमेज़ॅन ग्लू क्रॉलर एस 3 बाल्टी में सभी डेटा को स्कैन करता है और विभाजन तालिका बनाता है। AWS Glue कंसोल से एक Glue Crawler बनाएं और उस बाल्टी को जोड़ें जिसमें आप डेटा संग्रहीत करते हैं। आप कई बाल्टी के लिए एक क्रॉलर का उपयोग कर सकते हैं, इस मामले में यह निर्दिष्ट डेटाबेस में तालिकाओं के नामों के साथ तालिकाओं का निर्माण करेगा। यदि आप हर समय इस डेटा का उपयोग करने की योजना बनाते हैं, तो अपनी आवश्यकताओं के अनुरूप क्रॉलर लॉन्च शेड्यूल को समायोजित करना सुनिश्चित करें। हम सभी टेबल के लिए एक क्रॉलर का उपयोग करते हैं, जो हर घंटे चलता है।

विभाजन सारणी

क्रॉलर की पहली शुरुआत के बाद, सेटिंग्स में निर्दिष्ट डेटाबेस में प्रत्येक स्कैन की गई बाल्टी के लिए तालिकाओं को दिखाई देना चाहिए। एथेना कंसोल खोलें और Nginx लॉग के साथ तालिका ढूंढें। आइए कुछ पढ़ने की कोशिश करें:

 SELECT * FROM "default"."part_demo_kinesis_bucket" WHERE( partition_0 = '2019' AND partition_1 = '04' AND partition_2 = '08' AND partition_3 = '06' );

यह क्वेरी 8 अप्रैल, 2019 को सुबह 6 बजे से सुबह 7 बजे तक प्राप्त सभी रिकॉर्ड का चयन करेगी। लेकिन गैर-विभाजित तालिका से सिर्फ पढ़ने की तुलना में कितना अधिक प्रभावी है? आइए जानें और टाइमस्टैम्प द्वारा फ़िल्टर करके समान रिकॉर्ड का चयन करें:

विभाजन के बिना अनुरोध

डेटासेट पर 3.59 सेकंड और 244.34 मेगाबाइट डेटा है, जिसमें केवल एक सप्ताह का लॉग है। विभाजन द्वारा फ़िल्टर करने का प्रयास करें:

विभाजन फ़िल्टर अनुरोध

थोड़ा तेज, लेकिन सबसे महत्वपूर्ण - केवल 1.23 मेगाबाइट डेटा! यह बहुत सस्ता होगा यदि यह मूल्य निर्धारण में प्रति अनुरोध न्यूनतम 10 मेगाबाइट के लिए नहीं था। लेकिन यह वैसे भी बहुत बेहतर है, और बड़े डेटासेट पर अंतर बहुत अधिक प्रभावशाली होगा।

Cube.js का उपयोग करके एक डैशबोर्ड बनाएं

डैशबोर्ड बनाने के लिए, हम Cube.js. एनालिटिक फ्रेमवर्क का उपयोग करते हैं। इसके कुछ कार्य हैं, लेकिन हम दो में रुचि रखते हैं: विभाजन और डेटा के पूर्व एकत्रीकरण पर स्वचालित रूप से फिल्टर का उपयोग करने की क्षमता। यह SQL को उत्पन्न करने और डेटाबेस क्वेरी को निष्पादित करने के लिए जावास्क्रिप्ट में लिखे गए डेटा स्कीमा का उपयोग करता है। डेटा स्कीमा में विभाजन फ़िल्टर का उपयोग कैसे करें, यह इंगित करने के लिए हम सभी की आवश्यकता है।

चलो एक नया एप्लिकेशन Cube.js. बनाएं चूंकि हम पहले से ही एडब्ल्यूएस-स्टैक का उपयोग करते हैं, इसलिए तैनाती के लिए लैम्ब्डा का उपयोग करना तर्कसंगत है। यदि आप Cube.js बैकएंड में हरोकू या डॉकर को होस्ट करने की योजना बनाते हैं, तो आप पीढ़ी के लिए एक्सप्रेस टेम्पलेट का उपयोग कर सकते हैं। प्रलेखन अन्य होस्टिंग विधियों का वर्णन करता है।

 $ npm install -g cubejs-cli $ cubejs create nginx-log-analytics -t serverless -d athena

वातावरण चर का उपयोग cube.js. में डेटाबेस तक पहुँच को कॉन्फ़िगर करने के लिए किया जाता है जनरेटर एक .env फ़ाइल बनाएगा जिसमें आप एथेना के लिए अपनी चाबियाँ निर्दिष्ट कर सकते हैं।

अब हमें एक डेटा स्कीम की आवश्यकता है जिसमें हम यह इंगित करें कि हमारे लॉग कैसे संग्रहीत हैं। वहां आप यह निर्दिष्ट कर सकते हैं कि डैशबोर्ड के लिए मीट्रिक कैसे पढ़ें।

schema निर्देशिका में, Logs.js फ़ाइल बनाएँ। यहाँ nginx के लिए एक उदाहरण डेटा मॉडल है:

मॉडल कोड

 const partitionFilter = (from, to) => ` date(from_iso8601_timestamp(${from})) <= date_parse(partition_0 || partition_1 || partition_2, '%Y%m%d') AND date(from_iso8601_timestamp(${to})) >= date_parse(partition_0 || partition_1 || partition_2, '%Y%m%d') ` cube(`Logs`, { sql: ` select * from part_demo_kinesis_bucket WHERE ${FILTER_PARAMS.Logs.createdAt.filter(partitionFilter)} `, measures: { count: { type: `count`, }, errorCount: { type: `count`, filters: [ { sql: `${CUBE.isError} = 'Yes'` } ] }, errorRate: { type: `number`, sql: `100.0 * ${errorCount} / ${count}`, format: `percent` } }, dimensions: { status: { sql: `status`, type: `number` }, isError: { type: `string`, case: { when: [{ sql: `${CUBE}.status >= 400`, label: `Yes` }], else: { label: `No` } } }, createdAt: { sql: `from_unixtime(created_at)`, type: `time` } } });

विभाजन फ़िल्टर के साथ SQL क्वेरी बनाने के लिए यहाँ हम FILTER_PARAMS चर का उपयोग करते हैं।

हम उन मैट्रिक्स और मापदंडों को भी निर्दिष्ट करते हैं जिन्हें हम डैशबोर्ड पर प्रदर्शित करना चाहते हैं, और पूर्व-एकत्रीकरण निर्दिष्ट करते हैं। Cube.js पूर्व-एकत्रित डेटा के साथ अतिरिक्त तालिकाएँ बनाएगा और उपलब्ध होते ही डेटा को स्वचालित रूप से अपडेट कर देगा। यह न केवल अनुरोधों को गति देता है, बल्कि एथेना का उपयोग करने की लागत को भी कम करता है।

इस जानकारी को डेटा स्कीमा फ़ाइल में जोड़ें:

 preAggregations: { main: { type: `rollup`, measureReferences: [count, errorCount], dimensionReferences: [isError, status], timeDimensionReference: createdAt, granularity: `day`, partitionGranularity: `month`, refreshKey: { sql: FILTER_PARAMS.Logs.createdAt.filter((from, to) => `select CASE WHEN from_iso8601_timestamp(${to}) + interval '3' day > now() THEN date_trunc('hour', now()) END` ) } } }

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

अब हम एक डैशबोर्ड को एक साथ रख सकते हैं!

Cube.js बैकेंड लोकप्रिय फ्रंट-एंड फ्रेमवर्क के लिए एक REST API और क्लाइंट लाइब्रेरी का एक सेट प्रदान करता है। हम डैशबोर्ड बनाने के लिए क्लाइंट के रिएक्ट संस्करण का उपयोग करेंगे। Cube.js केवल डेटा प्रदान करता है, इसलिए हमें विज़ुअलाइज़ेशन के लिए एक पुस्तकालय की आवश्यकता है - मुझे रिचार्ज पसंद है, लेकिन आप किसी का उपयोग कर सकते हैं।

Cube.js सर्वर JSON प्रारूप में अनुरोध को स्वीकार करता है, जो आवश्यक मीट्रिक को इंगित करता है। उदाहरण के लिए, गणना करने के लिए कि नगीनक्स ने दिन में कितनी त्रुटियां दीं, आपको निम्नलिखित अनुरोध भेजने की आवश्यकता है:

 { "measures": ["Logs.errorCount"], "timeDimensions": [ { "dimension": "Logs.createdAt", "dateRange": ["2019-01-01", "2019-01-07"], "granularity": "day" } ] }

NPM के माध्यम से Cube.js क्लाइंट और रिएक्ट घटक लाइब्रेरी स्थापित करें:

 $ npm i --save @cubejs-client/core @cubejs-client/react

हम डेटा को अनलोड करने के लिए cubejs और क्वेरीरीडर घटक आयात करते हैं, और डैशबोर्ड एकत्र करते हैं:

डैशबोर्ड कोड

 import React from 'react'; import { LineChart, Line, XAxis, YAxis } from 'recharts'; import cubejs from '@cubejs-client/core'; import { QueryRenderer } from '@cubejs-client/react'; const cubejsApi = cubejs( 'YOUR-CUBEJS-API-TOKEN', { apiUrl: 'http://localhost:4000/cubejs-api/v1' }, ); export default () => { return ( <QueryRenderer query={{ measures: ['Logs.errorCount'], timeDimensions: [{ dimension: 'Logs.createdAt', dateRange: ['2019-01-01', '2019-01-07'], granularity: 'day' }] }} cubejsApi={cubejsApi} render={({ resultSet }) => { if (!resultSet) { return 'Loading...'; } return ( <LineChart data={resultSet.rawData()}> <XAxis dataKey="Logs.createdAt"/> <YAxis/> <Line type="monotone" dataKey="Logs.errorCount" stroke="#8884d8"/> </LineChart> ); }} /> ) } ', import React from 'react'; import { LineChart, Line, XAxis, YAxis } from 'recharts'; import cubejs from '@cubejs-client/core'; import { QueryRenderer } from '@cubejs-client/react'; const cubejsApi = cubejs( 'YOUR-CUBEJS-API-TOKEN', { apiUrl: 'http://localhost:4000/cubejs-api/v1' }, ); export default () => { return ( <QueryRenderer query={{ measures: ['Logs.errorCount'], timeDimensions: [{ dimension: 'Logs.createdAt', dateRange: ['2019-01-01', '2019-01-07'], granularity: 'day' }] }} cubejsApi={cubejsApi} render={({ resultSet }) => { if (!resultSet) { return 'Loading...'; } return ( <LineChart data={resultSet.rawData()}> <XAxis dataKey="Logs.createdAt"/> <YAxis/> <Line type="monotone" dataKey="Logs.errorCount" stroke="#8884d8"/> </LineChart> ); }} /> ) }

डैशबोर्ड स्रोत CodeSandbox पर उपलब्ध हैं।

अमेज़ॅन एथेना और क्यूब.जेएस का उपयोग करके नंगेक्स एनालिटिक्स