Amazon Athena සහ Cube.js භාවිතයෙන් Nginx ලොග් විශ්ලේෂණ

සාමාන්‍යයෙන්, Nginx හි ක්‍රියාකාරිත්වය නිරීක්ෂණය කිරීමට සහ විශ්ලේෂණය කිරීමට වාණිජ නිෂ්පාදන හෝ Prometheus + Grafana වැනි සූදානම් කළ විවෘත මූලාශ්‍ර විකල්ප භාවිතා වේ. මෙය නිරීක්ෂණ හෝ තත්‍ය කාලීන විශ්ලේෂණ සඳහා හොඳ විකල්පයකි, නමුත් ඓතිහාසික විශ්ලේෂණය සඳහා ඉතා පහසු නොවේ. ඕනෑම ජනප්‍රිය සම්පතක් මත, nginx ලඝු-සටහන් වලින් දත්ත පරිමාව ශීඝ්‍රයෙන් වර්ධනය වන අතර, විශාල දත්ත ප්‍රමාණයක් විශ්ලේෂණය කිරීමට, වඩාත් විශේෂිත දෙයක් භාවිතා කිරීම තාර්කික වේ.

ඔබට භාවිතා කළ හැකි ආකාරය මෙම ලිපියෙන් මම ඔබට කියමි ඇතීනා ලඝු-සටහන් විශ්ලේෂණය කිරීමට, Nginx උදාහරණයක් ලෙස ගනිමින්, විවෘත මූලාශ්‍ර cube.js රාමුව භාවිතයෙන් මෙම දත්ත වලින් විශ්ලේෂණාත්මක උපකරණ පුවරුවක් එකලස් කරන ආකාරය මම පෙන්වන්නම්. මෙන්න සම්පූර්ණ විසඳුම් ගෘහ නිර්මාණ ශිල්පය:

TL:DR;
නිමි උපකරණ පුවරුව වෙත සබැඳිය.

අපි භාවිතා කරන තොරතුරු රැස් කිරීමට චතුර ලෙස, සැකසීම සඳහා - AWS Kinesis Data Firehose и AWS මැලියම්ගබඩා කිරීම සඳහා - AWS S3. මෙම බණ්ඩලය භාවිතා කිරීමෙන්, ඔබට nginx ලඝු-සටහන් පමණක් නොව, අනෙකුත් සිදුවීම් මෙන්ම වෙනත් සේවාවන්හි ලොග් ගබඩා කළ හැක. ඔබට ඔබේ තොගය සඳහා සමහර කොටස් සමාන ඒවා සමඟ ප්‍රතිස්ථාපනය කළ හැකිය, උදාහරණයක් ලෙස, ඔබට nginx වෙතින් කෙලින්ම kinesis වෙත ලොග් ලිවිය හැකිය, fluentd මඟ හැරීම හෝ මේ සඳහා logstash භාවිතා කරන්න.

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 භාවිතා කරන්නෙමු. Athena හට S3 හි දත්ත සමඟ කෙලින්ම ක්‍රියා කළ හැකි බැවින්, ලොග එක තැනක ගබඩා කර විශ්ලේෂණය කිරීමට මෙය ඔබට ඉඩ සලසයි. පසුව ලිපියෙන් මම ඔබට ලොග් නිවැරදිව එකතු කරන්නේ කෙසේද සහ සැකසීමට ඔබට කියමි, නමුත් පළමුව අපට S3 හි පිරිසිදු බාල්දියක් අවශ්‍ය වේ, එහි වෙන කිසිවක් ගබඩා නොවේ. Athena සෑම ප්‍රදේශයකම නොමැති නිසා ඔබ ඔබේ බාල්දිය නිර්මාණය කරන්නේ කුමන ප්‍රදේශයේදැයි කල්තියා සලකා බැලීම වටී.

Athena කොන්සෝලය තුළ පරිපථයක් නිර්මාණය කිරීම

ලඝු-සටහන් සඳහා Athena හි වගුවක් නිර්මාණය කරමු. ඔබ Kinesis Firehose භාවිතා කිරීමට අදහස් කරන්නේ නම් එය ලිවීම සහ කියවීම යන දෙකටම අවශ්‍ය වේ. Athena කොන්සෝලය විවෘත කර වගුවක් සාදන්න:

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 Stream නිර්මාණය කිරීම

Kinesis Firehose විසින් Nginx සිට S3 වෙත ලැබුණු දත්ත තෝරාගත් ආකෘතියෙන් ලියයි, එය YYYY/MM/DD/HH ආකෘතියෙන් නාමාවලිවලට බෙදයි. දත්ත කියවීමේදී මෙය ප්රයෝජනවත් වනු ඇත. ඔබට ඇත්ත වශයෙන්ම fluentd වෙතින් S3 වෙත කෙලින්ම ලිවිය හැකිය, නමුත් මෙම අවස්ථාවේදී ඔබට JSON ලිවීමට සිදුවනු ඇත, සහ ගොනු විශාලත්වය නිසා මෙය අකාර්යක්ෂම වේ. මීට අමතරව, PrestoDB හෝ Athena භාවිතා කරන විට, JSON මන්දගාමී දත්ත ආකෘතිය වේ. එබැවින් Kinesis ෆයර්හෝස් කොන්සෝලය විවෘත කරන්න, "බෙදාහැරීමේ ප්‍රවාහය සාදන්න" ක්ලික් කරන්න, "බෙදා හැරීම" ක්ෂේත්රයේ "සෘජු PUT" තෝරන්න:

මීළඟ පටිත්තෙහි, "වාර්තා ආකෘතිය පරිවර්තනය" - "සක්රිය" තෝරන්න සහ පටිගත කිරීමේ ආකෘතිය ලෙස "Apache ORC" තෝරන්න. සමහර පර්යේෂණ වලට අනුව Owen O'Mally, PrestoDB සහ Athena සඳහා ප්‍රශස්ත ආකෘතිය මෙයයි. අපි ඉහත නිර්මාණය කර ඇති වගුව අපි යෝජනා ක්රමයක් ලෙස භාවිතා කරමු. ඔබට කයිනසිස් තුළ ඕනෑම S3 ස්ථානයක් සඳහන් කළ හැකි බව කරුණාවෙන් සලකන්න; වගුවෙන් භාවිතා වන්නේ ක්‍රමලේඛය පමණි. නමුත් ඔබ වෙනත් S3 ස්ථානයක් සඳහන් කරන්නේ නම්, ඔබට මෙම වගුවෙන් මෙම වාර්තා කියවීමට නොහැකි වනු ඇත.

ගබඩා කිරීම සඳහා අපි S3 සහ අපි කලින් නිර්මාණය කළ බාල්දිය තෝරා ගනිමු. මම ටිකක් පසුව කතා කරන Aws Glue Crawler, S3 බාල්දියක උපසර්ග සමඟ වැඩ කළ නොහැක, එබැවින් එය හිස්ව තැබීම වැදගත් වේ.

ඔබගේ භාරය අනුව ඉතිරි විකල්ප වෙනස් කළ හැකිය; මම සාමාන්‍යයෙන් පෙරනිමි ඒවා භාවිතා කරමි. S3 සම්පීඩනය නොමැති බව සලකන්න, නමුත් ORC පෙරනිමියෙන් දේශීය සම්පීඩනය භාවිතා කරයි.

චතුර ලෙස

දැන් අපි ලොග් ගබඩා කිරීම සහ ලැබීම වින්‍යාස කර ඇති බැවින්, අපට යැවීම වින්‍යාසගත කළ යුතුය. අපි භාවිතා කරන්නෙමු චතුර ලෙස, මම රූබිට ආදරය කරන නිසා, නමුත් ඔබට Logstash භාවිතා කිරීමට හෝ කෙලින්ම kinesis වෙත ලොග යැවීමට හැකිය. 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 වරායයි.

දැන් අපි Fluentd ධාවනය කර ඇති නිසා, අපට Nginx ලඝු-සටහන් එහි යැවිය හැක. අපි සාමාන්‍යයෙන් Nginx ධාවනය කරන්නේ Docker කන්ටේනරයකයි, මෙම අවස්ථාවේදී 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 සතුව ඇත ගොනු වලිගය ප්ලගිනය.

ඉහත වින්‍යාස කර ඇති ලඝු විග්‍රහය Fluent වින්‍යාසයට එකතු කරමු:

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

සහ භාවිතා කරමින් Kinesis වෙත ලඝු-සටහන් යැවීම kinesis firehose ප්ලගිනය:

<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>

ඇතීනා

ඔබ සියල්ල නිවැරදිව වින්‍යාස කර ඇත්නම්, ටික වේලාවකට පසු (පෙරනිමියෙන්, Kinesis වාර්තා සෑම මිනිත්තු 10 කට වරක් දත්ත ලබා ගනී) ඔබ S3 හි ලොග් ගොනු දැකිය යුතුය. Kinesis Firehose හි "අධීක්ෂණ" මෙනුවෙහි S3 හි කොපමණ දත්ත සටහන් කර ඇත්ද යන්න මෙන්ම දෝෂ ද දැක ගත හැකිය. Kinesis භූමිකාවට S3 බාල්දියට ලිවීමට ප්‍රවේශය ලබා දීමට අමතක නොකරන්න. Kinesis හට යමක් විග්‍රහ කිරීමට නොහැකි වූයේ නම්, එය එම බාල්දියටම දෝෂ එක් කරයි.

දැන් ඔබට Athena හි දත්ත බැලීමට හැකිය. අපි දෝෂ ලබා දුන් නවතම ඉල්ලීම් සොයා බලමු:

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

එක් එක් ඉල්ලීම සඳහා සියලුම වාර්තා පරිලෝකනය කිරීම

දැන් අපගේ ලඝු-සටහන් සකස් කර ORC හි S3 හි ගබඩා කර, සම්පීඩනය කර විශ්ලේෂණය සඳහා සූදානම් කර ඇත. Kinesis Firehose ඒවා සෑම පැයකටම නාමාවලිවලට පවා සංවිධානය කළේය. කෙසේ වෙතත්, වගුව කොටස් කර නොමැති තාක්, Athena විසින් දුර්ලභ ව්‍යතිරේක සහිතව, සෑම ඉල්ලීමකම සර්වකාලීන දත්ත පූරණය කරනු ඇත. මෙය හේතු දෙකක් නිසා විශාල ගැටලුවකි:

• දත්ත පරිමාව නිරන්තරයෙන් වර්ධනය වේ, විමසුම් මන්දගාමී වේ;
• එක් ඉල්ලීමකට අවම වශයෙන් 10 MB ප්‍රමාණයක් සහිතව, ස්කෑන් කරන ලද දත්ත පරිමාව මත පදනම්ව Athena බිල්පත් කරනු ලැබේ.

මෙය නිවැරදි කිරීම සඳහා, අපි AWS Glue Crawler භාවිතා කරමු, එය S3 හි දත්ත බඩගාගෙන කොටස් තොරතුරු Glue Metastore වෙත ලියයි. මෙය Athena විමසන විට පෙරහන ලෙස කොටස් භාවිතා කිරීමට අපට ඉඩ සලසයි, එය විමසුමේ දක්වා ඇති නාමාවලි පමණක් පරිලෝකනය කරයි.

Amazon Glue Crawler පිහිටුවීම

Amazon Glue Crawler S3 බාල්දියේ ඇති සියලුම දත්ත ස්කෑන් කර කොටස් සහිත වගු නිර්මාණය කරයි. AWS Glue කොන්සෝලයෙන් Glue Crawler එකක් සාදා ඔබ දත්ත ගබඩා කරන බාල්දියක් එක් කරන්න. ඔබට බාල්දි කිහිපයක් සඳහා එක් ක්‍රෝලර් එකක් භාවිතා කළ හැකිය, මෙම අවස්ථාවේදී එය බාල්දිවල නම් වලට ගැලපෙන නම් සහිත නිශ්චිත දත්ත ගබඩාවේ වගු නිර්මාණය කරයි. ඔබ මෙම දත්ත නිතිපතා භාවිතා කිරීමට අදහස් කරන්නේ නම්, Crawler දියත් කිරීමේ කාලසටහන ඔබේ අවශ්‍යතාවයට ගැලපෙන පරිදි වින්‍යාස කිරීමට වග බලා ගන්න. අපි සෑම පැයකටම ක්‍රියාත්මක වන සියලුම වගු සඳහා එක් Crawler එකක් භාවිතා කරමු.

කොටස් කළ වගු

ක්‍රෝලර් පළමු දියත් කිරීමෙන් පසු, එක් එක් ස්කෑන් කරන ලද බාල්දිය සඳහා වගු සැකසුම් වල දක්වා ඇති දත්ත ගබඩාවේ දිස්විය යුතුය. Athena කොන්සෝලය විවෘත කර 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 තොගය භාවිතා කරන බැවින්, යෙදවීම සඳහා Lambda භාවිතා කිරීම තාර්කික ය. ඔබ Cube.js පසුපෙළ Heroku හෝ Docker හි සත්කාරකත්වය කිරීමට අදහස් කරන්නේ නම්, ඔබට උත්පාදනය සඳහා අධිවේගී අච්චුව භාවිතා කළ හැක. ලේඛන වෙනත් අය විස්තර කරයි සත්කාරක ක්රම.

$ 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 පෙර-එකතු කළ දත්ත සමඟ අමතර වගු සාදනු ඇති අතර දත්ත පැමිණෙන විට ස්වයංක්‍රීයව යාවත්කාලීන කරනු ඇත. මෙය විමසුම් වේගවත් කරනවා පමණක් නොව, Athena භාවිතා කිරීමේ පිරිවැය ද අඩු කරයි.

අපි මෙම තොරතුරු දත්ත යෝජනා ක්‍රමය ගොනුවට එක් කරමු:

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