Studi Kasus: Bagaimana Nearley Digunakan untuk Menganalisis Data Terstruktur dan Mengurai Sintaks yang Kompleks

Membaca tentang parser dan parser generator seperti Nearley bisa terasa sangat teoretis. Namun, kekuatan sesungguhnya dari teknologi ini terlihat ketika diterapkan untuk memecahkan masalah nyata. Artikel ini akan membawa Anda ke dalam sebuah studi kasus hipotetis, namun sangat relevan, untuk menunjukkan bagaimana Nearley digunakan sebagai alat esensial dalam menganalisis data terstruktur dan mengurai sintaks yang kompleks di dunia nyata.

Baca juga:Lebih dari Sekadar Mainan: Mengupas Teknologi Canggih di Balik Drone Parrot, Pesaing Serius DJI dari Eropa

Masalah: Menganalisis File Log Kustom

Bayangkan Anda adalah seorang pengembang di sebuah perusahaan game online. Tim teknis Anda menggunakan sebuah sistem logging internal yang menghasilkan file teks besar dengan format yang sangat spesifik dan unik. Setiap baris log memiliki struktur yang rumit dan tidak teratur, membuat analisis manual menjadi pekerjaan yang sangat memakan waktu dan rentan kesalahan. Format log terlihat seperti ini:

[2025-08-27 10:30:15] INFO: User 'Alpha_Gamer' logged in from 192.168.1.10. Session ID: 5f9e8f8e-4b4c-4a3a-a1c2-c5c5c5c5c5c5.
[2025-08-27 10:31:02] WARN: Failed to load item 'Sword_of_Zeus' for player 'Alpha_Gamer'. Reason: ItemNotFound.
[2025-08-27 10:32:45] ERROR: Database connection lost. Reconnecting in 30 seconds.

Anda diminta untuk membuat sebuah tool yang dapat:

1. Mengurai setiap baris log menjadi objek JavaScript yang terstruktur (misalnya, {"timestamp": ..., "level": ..., "message": ...}).
2. Mengekstrak informasi spesifik dari pesan log, seperti nama pengguna, ID sesi, atau nama item.
3. Memfilter log berdasarkan kriteria tertentu (misalnya, hanya menampilkan log ERROR dari pengguna tertentu).

Mencoba mengurai ini dengan regex tradisional akan sangat rumit dan rentan terhadap perubahan format. Ini adalah masalah yang sempurna untuk diselesaikan dengan parser, dan Nearley adalah pilihan yang ideal.

Solusi: Membangun Parser Log dengan Nearley

Berikut adalah langkah-langkah yang diambil untuk membangun parser log menggunakan Nearley.

Langkah 1: Mendefinisikan Grammar yang Tepat

Hal pertama yang dilakukan adalah mendefinisikan aturan grammar untuk setiap komponen dari baris log. Aturan-aturan ini mencerminkan struktur yang diharapkan dari setiap entri log.

Code snippet

// @lexer moo
// Import lexer definition from a separate file for clarity.

// Aturan utama: sebuah file log terdiri dari nol atau lebih baris log
logfile -> log_entry:* {%
    d => d[0].filter(Boolean)
%}

// Sebuah entri log adalah timestamp, level, pesan, dan diakhiri dengan baris baru.
log_entry -> timestamp _ level _ log_message _ {%
    ([timestamp, , level, , log_message, ,]) => ({
        timestamp: timestamp,
        level: level,
        message: log_message
    })
%}
          | _ // Mengabaikan baris kosong

// Mendefinisikan struktur pesan log
log_message -> user_login_message
             | item_load_message
             | database_message
             | generic_message

// Aturan untuk pesan login pengguna
user_login_message -> "User " single_quoted_string " logged in from " ip_address ". Session ID: " guid "." {%
    ([, username, , ip, , guid]) => ({
        type: "user_login",
        user: username,
        ip: ip,
        sessionId: guid
    })
%}

// Aturan untuk pesan item yang gagal dimuat
item_load_message -> "Failed to load item " single_quoted_string " for player " single_quoted_string ". Reason: " word "." {%
    ([, item_name, , player_name, , reason]) => ({
        type: "item_load_failure",
        item: item_name,
        player: player_name,
        reason: reason
    })
%}

// Aturan untuk pesan database
database_message -> "Database connection lost. Reconnecting in " number_token " seconds." {%
    ([, , seconds]) => ({
        type: "database_error",
        reconnect_in: seconds
    })
%}

// Aturan untuk pesan generic
generic_message -> rest_of_line

// Aturan terminal untuk mengenali token dasar
single_quoted_string -> `'` [a-zA-Z0-9_]+ `'`
word -> [a-zA-Z0-9_]+
ip_address -> // regex untuk format IP
guid -> // regex untuk format GUID
rest_of_line -> // regex untuk mengambil sisa baris
number_token -> [0-9]+
_ -> " " // Spasi tunggal
... // Aturan lainnya

Dengan mendeklarasikan grammar seperti ini, kita memberikan Nearley "instruksi" tentang bagaimana setiap jenis pesan log harus diuraikan. Blok {% ... %} di setiap aturan bertindak sebagai postprocessor, yang mengubah teks yang diurai menjadi objek JavaScript yang terstruktur dan mudah diakses.

Langkah 2: Menggunakan Nearley untuk Menggenerasi dan Mengeksekusi Parser

Dengan file grammar di tangan, pengembang menjalankan perintah Nearley CLI untuk menghasilkan parser JavaScript yang dapat digunakan:

Bash

nearleyc log_grammar.ne -o log_parser.js

Kemudian, sebuah skrip Node.js ditulis untuk membaca file log, mengirimkan isinya ke parser, dan memproses hasilnya.

JavaScript

const fs = require('fs');
const nearley = require('nearley');
const grammar = require('./log_parser.js'); // Parser yang digenerasi

const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
const logContent = fs.readFileSync('game.log', 'utf-8');

try {
    parser.feed(logContent);
    const parsedLogs = parser.results[0]; // Hasil yang diurai
    
    // Kini, parsedLogs adalah array of objects!
    // Contoh penggunaan: memfilter hanya log error.
    const errors = parsedLogs.filter(log => log.level === "ERROR");

    // Contoh penggunaan: menemukan log login dari pengguna tertentu
    const alpha_gamer_logins = parsedLogs.filter(log =>
        log.message.type === "user_login" && log.message.user === "Alpha_Gamer"
    );

    console.log("Daftar Kesalahan (Errors):", errors);
    console.log("Logins dari Alpha_Gamer:", alpha_gamer_logins);

} catch (e) {
    console.error("Gagal mengurai file log:", e);
}

Hasil dan Manfaat: Mengapa Ini Sukses?

Pendekatan menggunakan Nearley memberikan keuntungan signifikan dibandingkan metode konvensional:

1. Keterbacaan dan Kemudahan Perawatan: Aturan grammar yang terstruktur jauh lebih mudah dibaca dan dirawat daripada serangkaian regex yang kompleks. Jika format log berubah, pengembang hanya perlu memodifikasi file .ne dan meregenerasi parser, tanpa harus mengubah logika program utama.
2. Kecepatan dan Efisiensi: Nearley, dengan algoritma Earley yang kuat, mampu mengurai file log yang sangat besar dengan cepat dan akurat. Hasilnya adalah Abstract Syntax Tree (AST) yang dapat dengan mudah diubah menjadi objek JavaScript yang siap digunakan.
3. Fleksibilitas: Karena Nearley dapat menangani grammar yang ambigu, ia dapat mengurai struktur yang tumpang tindih atau kompleks, sesuatu yang akan menjadi mimpi buruk bagi parser lain. Ini membuat solusi menjadi lebih kokoh.
4. Ekstraksi Data Terstruktur: Manfaat terbesar adalah kemampuan untuk mengubah teks yang tidak terstruktur menjadi data yang terstruktur. Daripada berurusan dengan string mentah, pengembang kini dapat bekerja dengan objek JavaScript yang memiliki properti yang jelas seperti level, timestamp, dan message.user. Ini sangat menyederhanakan proses analisis dan pengolahan data.

Baca juga: Mahasiswa Teknokrat Juara KTI dan Best Expodi PIMPI 2025 IPB University

Nearley Sebagai Alat Analisis Data yang Cerdas

Studi kasus ini menunjukkan bahwa Nearley bukanlah hanya alat teoretis untuk ilmuwan komputer, tetapi merupakan solusi praktis dan kuat untuk masalah sehari-hari dalam pengembangan. Dengan Nearley, kita dapat mengurai data yang paling rumit sekalipun menjadi representasi yang dapat digunakan, mengubah proses yang membosankan menjadi tugas yang efisien dan otomatis.

Jika Anda menghadapi tantangan dalam menganalisis data terstruktur, mengurai sintaks yang kompleks, atau membangun bahasa kustom, Nearley menawarkan pendekatan yang cerdas dan efektif. Ini bukan hanya tentang menghasilkan parser, melainkan tentang membangun sistem yang dapat memahami informasi dengan cara yang lebih mendalam. Dengan Nearley, Anda memiliki kunci untuk membuka wawasan dari data yang sebelumnya tidak dapat diakses.

Penulis: Fiska Anggraini