Amazon Athena અને Cube.js નો ઉપયોગ કરીને Nginx લોગ એનાલિટિક્સ

સામાન્ય રીતે, વ્યાપારી ઉત્પાદનો અથવા તૈયાર ઓપન-સોર્સ વિકલ્પો, જેમ કે પ્રોમિથિયસ + ગ્રાફના, નો ઉપયોગ Nginx ની કામગીરીનું નિરીક્ષણ અને વિશ્લેષણ કરવા માટે થાય છે. મોનિટરિંગ અથવા રીઅલ-ટાઇમ એનાલિટિક્સ માટે આ એક સારો વિકલ્પ છે, પરંતુ ઐતિહાસિક વિશ્લેષણ માટે ખૂબ અનુકૂળ નથી. કોઈપણ લોકપ્રિય સંસાધન પર, nginx લૉગ્સમાંથી ડેટાની માત્રા ઝડપથી વધી રહી છે, અને મોટી માત્રામાં ડેટાનું વિશ્લેષણ કરવા માટે, વધુ વિશિષ્ટ કંઈકનો ઉપયોગ કરવો તે તાર્કિક છે.

આ લેખમાં હું તમને કહીશ કે તમે તેનો ઉપયોગ કેવી રીતે કરી શકો એથેના લૉગ્સનું પૃથ્થકરણ કરવા માટે, Nginx ને ઉદાહરણ તરીકે લઈ, અને હું ઓપન-સોર્સ cube.js ફ્રેમવર્કનો ઉપયોગ કરીને આ ડેટામાંથી વિશ્લેષણાત્મક ડેશબોર્ડ કેવી રીતે એસેમ્બલ કરવું તે બતાવીશ. અહીં સંપૂર્ણ સોલ્યુશન આર્કિટેક્ચર છે:

TL:DR;
ફિનિશ્ડ ડેશબોર્ડની લિંક.

માહિતી એકત્રિત કરવા માટે અમે ઉપયોગ કરીએ છીએ અસ્ખલિતપ્રક્રિયા માટે - AWS Kinesis ડેટા ફાયરહોઝ и AWS ગુંદર, સંગ્રહ માટે - AWS S3. આ બંડલનો ઉપયોગ કરીને, તમે માત્ર nginx લૉગ્સ જ નહીં, પણ અન્ય ઇવેન્ટ્સ તેમજ અન્ય સેવાઓના લૉગ્સ પણ સ્ટોર કરી શકો છો. તમે તમારા સ્ટેક માટે સમાન ભાગો સાથે કેટલાક ભાગોને બદલી શકો છો, ઉદાહરણ તરીકે, તમે સીધા જ nginx માંથી કિનેસિસ પર લોગ લખી શકો છો, ફ્લુએન્ટડને બાયપાસ કરી શકો છો અથવા આ માટે લોગસ્ટેશનો ઉપયોગ કરી શકો છો.

Nginx લોગ એકત્રિત કરી રહ્યા છીએ

ડિફૉલ્ટ રૂપે, 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 માં ડેટા સાથે કામ કરી શકે છે. લેખમાં પછીથી હું તમને કહીશ કે લૉગ્સને કેવી રીતે યોગ્ય રીતે ઉમેરવું અને પ્રક્રિયા કરવી, પરંતુ પહેલા અમને S3 માં સ્વચ્છ બકેટની જરૂર છે, જેમાં બીજું કંઈ સંગ્રહિત કરવામાં આવશે નહીં. તમે કયા પ્રદેશમાં તમારી બકેટ બનાવશો તે અગાઉથી ધ્યાનમાં લેવા યોગ્ય છે, કારણ કે એથેના બધા પ્રદેશોમાં ઉપલબ્ધ નથી.

એથેના કન્સોલમાં સર્કિટ બનાવવી

ચાલો લોગ માટે એથેનામાં એક ટેબલ બનાવીએ. જો તમે કિનેસિસ ફાયરહોઝનો ઉપયોગ કરવાની યોજના ઘડી રહ્યા હોવ તો તે લખવા અને વાંચવા બંને માટે જરૂરી છે. એથેના કન્સોલ ખોલો અને ટેબલ બનાવો:

એસક્યુએલ ટેબલ બનાવટ

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 પસંદ કરેલા ફોર્મેટમાં Nginx થી S3 પર પ્રાપ્ત ડેટા લખશે, તેને YYYY/MM/DD/HH ફોર્મેટમાં ડિરેક્ટરીઓમાં વિભાજીત કરશે. ડેટા વાંચતી વખતે આ કામમાં આવશે. તમે, અલબત્ત, fluentd થી સીધા S3 પર લખી શકો છો, પરંતુ આ કિસ્સામાં તમારે JSON લખવું પડશે, અને ફાઇલોના મોટા કદને કારણે આ બિનકાર્યક્ષમ છે. વધુમાં, PrestoDB અથવા Athena નો ઉપયોગ કરતી વખતે, JSON એ સૌથી ધીમું ડેટા ફોર્મેટ છે. તેથી Kinesis Firehose કન્સોલ ખોલો, "ડિલિવરી સ્ટ્રીમ બનાવો" પર ક્લિક કરો, "ડિલિવરી" ફીલ્ડમાં "ડાયરેક્ટ PUT" પસંદ કરો:

આગલા ટૅબમાં, "રેકોર્ડ ફોર્મેટ કન્વર્ઝન" - "સક્ષમ" પસંદ કરો અને રેકોર્ડિંગ ફોર્મેટ તરીકે "Apache ORC" પસંદ કરો. કેટલાક સંશોધન મુજબ ઓવેન ઓ'મેલી, આ PrestoDB અને Athena માટે શ્રેષ્ઠ ફોર્મેટ છે. અમે ઉપર બનાવેલ કોષ્ટકનો ઉપયોગ સ્કીમા તરીકે કરીએ છીએ. મહેરબાની કરીને નોંધ કરો કે તમે કિનેસિસમાં કોઈપણ S3 સ્થાનનો ઉલ્લેખ કરી શકો છો; કોષ્ટકમાંથી ફક્ત સ્કીમાનો ઉપયોગ કરવામાં આવે છે. પરંતુ જો તમે અલગ S3 સ્થાનનો ઉલ્લેખ કરો છો, તો પછી તમે આ કોષ્ટકમાંથી આ રેકોર્ડ્સ વાંચી શકશો નહીં.

અમે સ્ટોરેજ માટે S3 પસંદ કરીએ છીએ અને અમે અગાઉ બનાવેલ બકેટ. Aws Glue Crawler, જેના વિશે હું થોડી વાર પછી વાત કરીશ, S3 બકેટમાં ઉપસર્ગ સાથે કામ કરી શકતું નથી, તેથી તેને ખાલી છોડવું મહત્વપૂર્ણ છે.

બાકીના વિકલ્પો તમારા લોડના આધારે બદલી શકાય છે; હું સામાન્ય રીતે ડિફોલ્ટનો ઉપયોગ કરું છું. નોંધ કરો કે S3 કમ્પ્રેશન ઉપલબ્ધ નથી, પરંતુ ORC મૂળભૂત રીતે મૂળ કમ્પ્રેશનનો ઉપયોગ કરે છે.

અસ્ખલિત

હવે જ્યારે અમે લોગ્સ સંગ્રહિત કરવા અને પ્રાપ્ત કરવા માટે રૂપરેખાંકિત કર્યું છે, તો અમારે મોકલવાનું રૂપરેખાંકિત કરવાની જરૂર છે. અમે ઉપયોગ કરીશું અસ્ખલિત, કારણ કે હું રૂબીને પ્રેમ કરું છું, પરંતુ તમે લોગસ્ટેશનો ઉપયોગ કરી શકો છો અથવા સીધા કાઇનેસિસને લોગ મોકલી શકો છો. Fluentd સર્વર ઘણી રીતે લોન્ચ કરી શકાય છે, હું તમને ડોકર વિશે કહીશ કારણ કે તે સરળ અને અનુકૂળ છે.

પ્રથમ, આપણને fluent.conf રૂપરેખાંકન ફાઇલની જરૂર છે. તેને બનાવો અને સ્ત્રોત ઉમેરો:

પ્રકાર ફોરવર્ડ
24224 બંદર
બાંધો 0.0.0.0

હવે તમે Fluentd સર્વર શરૂ કરી શકો છો. જો તમને વધુ અદ્યતન ગોઠવણીની જરૂર હોય, તો પર જાઓ ડોકર હબ તમારી છબી કેવી રીતે એસેમ્બલ કરવી તે સહિત વિગતવાર માર્ગદર્શિકા છે.

$ 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 એ ડિફોલ્ટ ફ્લુએન્ટ પોર્ટ છે.

હવે અમારી પાસે Fluentd ચાલી રહ્યું છે, અમે ત્યાં Nginx લોગ મોકલી શકીએ છીએ. અમે સામાન્ય રીતે ડોકર કન્ટેનરમાં Nginx ચલાવીએ છીએ, આ કિસ્સામાં Docker પાસે Fluentd માટે મૂળ લોગિંગ ડ્રાઇવર છે:

$ 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 અલગ રીતે ચલાવો છો, તો તમે લોગ ફાઇલોનો ઉપયોગ કરી શકો છો, Fluentd પાસે છે ફાઇલ પૂંછડી પ્લગઇન.

ચાલો ઉપર રૂપરેખાંકિત કરેલ લોગ પાર્સિંગને ફ્લુઅન્ટ રૂપરેખાંકનમાં ઉમેરીએ:

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

અને 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 માં લોગ ફાઇલો જોવી જોઈએ. કિનેસિસ ફાયરહોઝના "મોનિટરિંગ" મેનૂમાં તમે જોઈ શકો છો કે S3 માં કેટલો ડેટા રેકોર્ડ કરવામાં આવ્યો છે, તેમજ ભૂલો. Kinesis ભૂમિકા માટે S3 બકેટમાં લખવાની ઍક્સેસ આપવાનું ભૂલશો નહીં. જો Kinesis કંઈક પાર્સ કરી શકતું નથી, તો તે સમાન બકેટમાં ભૂલો ઉમેરશે.

હવે તમે એથેનામાં ડેટા જોઈ શકો છો. ચાલો નવીનતમ વિનંતીઓ શોધીએ કે જેના માટે અમે ભૂલો પરત કરી છે:

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

દરેક વિનંતી માટે તમામ રેકોર્ડ્સ સ્કેન કરી રહ્યાં છે

હવે અમારા લોગ પર પ્રક્રિયા કરવામાં આવી છે અને ORC માં S3 માં સંગ્રહિત કરવામાં આવી છે, સંકુચિત અને વિશ્લેષણ માટે તૈયાર છે. કિનેસિસ ફાયરહોઝે તેમને દરેક કલાક માટે ડિરેક્ટરીઓમાં ગોઠવ્યા. જો કે, જ્યાં સુધી કોષ્ટકનું વિભાજન ન થાય ત્યાં સુધી, એથેના દુર્લભ અપવાદો સાથે, દરેક વિનંતી પર તમામ સમયનો ડેટા લોડ કરશે. આ બે કારણોસર મોટી સમસ્યા છે:

• ડેટાની માત્રા સતત વધી રહી છે, ક્વેરીઝને ધીમું કરી રહી છે;
• એથેનાનું બિલ સ્કેન કરેલા ડેટાના જથ્થાના આધારે કરવામાં આવે છે, વિનંતી દીઠ ઓછામાં ઓછા 10 MB સાથે.

આને ઠીક કરવા માટે, અમે AWS Glue Crawler નો ઉપયોગ કરીએ છીએ, જે S3 માં ડેટાને ક્રોલ કરશે અને Glue Metastore પર પાર્ટીશનની માહિતી લખશે. આ અમને એથેનાને ક્વેરી કરતી વખતે પાર્ટીશનોને ફિલ્ટર તરીકે વાપરવા દેશે, અને તે ફક્ત ક્વેરીમાં ઉલ્લેખિત ડિરેક્ટરીઓ જ સ્કેન કરશે.

Amazon Glue Crawler સેટઅપ કરી રહ્યું છે

Amazon Glue Crawler S3 બકેટમાંના તમામ ડેટાને સ્કેન કરે છે અને પાર્ટીશનો સાથે કોષ્ટકો બનાવે છે. AWS Glue કન્સોલમાંથી ગ્લુ ક્રાઉલર બનાવો અને જ્યાં તમે ડેટા સ્ટોર કરો છો ત્યાં એક બકેટ ઉમેરો. તમે ઘણી બકેટ્સ માટે એક ક્રાઉલરનો ઉપયોગ કરી શકો છો, આ કિસ્સામાં તે ઉલ્લેખિત ડેટાબેઝમાં નામો સાથે કોષ્ટકો બનાવશે જે બકેટના નામ સાથે મેળ ખાય છે. જો તમે આ ડેટાનો નિયમિત ઉપયોગ કરવાની યોજના ઘડી રહ્યા હો, તો તમારી જરૂરિયાતોને અનુરૂપ ક્રાઉલરના લોન્ચ શેડ્યૂલને ગોઠવવાની ખાતરી કરો. અમે બધા કોષ્ટકો માટે એક ક્રાઉલરનો ઉપયોગ કરીએ છીએ, જે દર કલાકે ચાલે છે.

વિભાજિત કોષ્ટકો

ક્રોલરના પ્રથમ લોંચ પછી, દરેક સ્કેન કરેલી બકેટ માટેના કોષ્ટકો સેટિંગ્સમાં ઉલ્લેખિત ડેટાબેઝમાં દેખાવા જોઈએ. એથેના કન્સોલ ખોલો અને Nginx લોગ સાથે ટેબલ શોધો. ચાલો કંઈક વાંચવાનો પ્રયત્ન કરીએ:

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

આ ક્વેરી 6 એપ્રિલ, 7ના રોજ સવારે 8 થી 2019 વાગ્યાની વચ્ચે પ્રાપ્ત થયેલા તમામ રેકોર્ડને પસંદ કરશે. પરંતુ બિન-વિભાજિત કોષ્ટકમાંથી વાંચવા કરતાં આ કેટલું વધુ કાર્યક્ષમ છે? ચાલો એ જ રેકોર્ડ્સ શોધીએ અને પસંદ કરીએ, તેમને ટાઇમસ્ટેમ્પ દ્વારા ફિલ્ટર કરીએ:

માત્ર એક અઠવાડિયાના લોગ સાથે ડેટાસેટ પર 3.59 સેકન્ડ અને 244.34 મેગાબાઇટ્સ ડેટા. ચાલો પાર્ટીશન દ્વારા ફિલ્ટર કરવાનો પ્રયાસ કરીએ:

થોડી ઝડપી, પરંતુ સૌથી અગત્યનું - માત્ર 1.23 મેગાબાઇટ્સ ડેટા! જો કિંમતમાં વિનંતી દીઠ ન્યૂનતમ 10 મેગાબાઇટ્સ ન હોય તો તે ઘણું સસ્તું હશે. પરંતુ તે હજુ પણ વધુ સારું છે, અને મોટા ડેટાસેટ્સ પર તફાવત વધુ પ્રભાવશાળી હશે.

Cube.js નો ઉપયોગ કરીને ડેશબોર્ડ બનાવવું

ડેશબોર્ડને એસેમ્બલ કરવા માટે, અમે Cube.js વિશ્લેષણાત્મક ફ્રેમવર્કનો ઉપયોગ કરીએ છીએ. તેમાં ઘણા બધા કાર્યો છે, પરંતુ અમને બેમાં રસ છે: પાર્ટીશન ફિલ્ટર્સ અને ડેટા પૂર્વ-એગ્રિગેશનનો આપમેળે ઉપયોગ કરવાની ક્ષમતા. તે ડેટા સ્કીમાનો ઉપયોગ કરે છે ડેટા સ્કીમા, SQL જનરેટ કરવા અને ડેટાબેઝ ક્વેરી ચલાવવા માટે Javascript માં લખાયેલ છે. આપણે ફક્ત ડેટા સ્કીમામાં પાર્ટીશન ફિલ્ટરનો ઉપયોગ કેવી રીતે કરવો તે સૂચવવાની જરૂર છે.

ચાલો એક નવી Cube.js એપ્લિકેશન બનાવીએ. અમે પહેલેથી જ AWS સ્ટેકનો ઉપયોગ કરી રહ્યા હોવાથી, જમાવટ માટે લેમ્બડાનો ઉપયોગ કરવો તાર્કિક છે. જો તમે Heroku અથવા Docker માં 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`
    }
  }
});

અહીં આપણે વેરીએબલનો ઉપયોગ કરી રહ્યા છીએ FILTER_PARAMSપાર્ટીશન ફિલ્ટર સાથે SQL ક્વેરી જનરેટ કરવા માટે.

અમે મેટ્રિક્સ અને પરિમાણો પણ સેટ કરીએ છીએ જે અમે ડેશબોર્ડ પર પ્રદર્શિત કરવા માંગીએ છીએ અને પૂર્વ-એગ્રિગેશન્સનો ઉલ્લેખ કરીએ છીએ. 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 ફોર્મેટ, જે જરૂરી મેટ્રિક્સનો ઉલ્લેખ કરે છે. ઉદાહરણ તરીકે, Nginx એ દિવસમાં કેટલી ભૂલો આપી તેની ગણતરી કરવા માટે, તમારે નીચેની વિનંતી મોકલવાની જરૂર છે:

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

ચાલો Cube.js ક્લાયંટ અને NPM દ્વારા પ્રતિક્રિયા ઘટક લાઇબ્રેરી ઇન્સ્ટોલ કરીએ:

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

અમે ઘટકો આયાત કરીએ છીએ cubejs и QueryRendererડેટા ડાઉનલોડ કરવા અને ડેશબોર્ડ એકત્રિત કરવા માટે:

ડેશબોર્ડ કોડ

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>
        );
      }}
    />
  )
}

ડેશબોર્ડ સ્ત્રોતો પર ઉપલબ્ધ છે કોડસેન્ડબોક્સ.

સોર્સ: www.habr.com