Giới Thiệu
Trong quy trình phát triển phần mềm hiện đại, đặc biệt là các hệ thống phân tán yêu cầu độ sẵn sàng cao, việc giám sát log đóng vai trò then chốt để đảm bảo tính ổn định. Các giải pháp truyền thống thường gặp khó khăn về độ trễ khi xử lý lượng dữ liệu lớn. Bài viết này sẽ hướng dẫn cách xây dựng một hệ thống giám sát log thời gian thực tối ưu trên nền tảng HarmonyNext, tận dụng sức mạnh của ngôn ngữ ArkTS.
1. Tổng Quan Kiến Trúc
Để đạt được hiệu suất cao và khả năng mở rộng, hệ thống được thiết kế theo mô hình module hóa, tách biệt rõ ràng các trách nhiệm xử lý dữ liệu. Kiến trúc bao gồm bốn thành phần chính:
- Module Thu Thập (Collector): Đảm nhiệm việc hứng dữ liệu log từ ứng dụng nguồn.
- Module Xử Lý (Processor): Thực hiện lọc, phân loại và làm giàu thông tin log.
- Module Lưu Trữ (Storage): Quản lý việc ghi dữ liệu vào bộ nhớ persistent của thiết bị.
- Module Hiển Thị (Viewer): Trực quan hóa dữ liệu log cho người quản trị.
2. Triển Khai Chi Tiết Các Module
2.1. Module Thu Thập Dữ Liệu (LogBufferManager)
Thay vì ghi log trực tiếp ngay lập tức gây tốn tài nguyên I/O, module này sử dụng kỹ thuật đệm (buffering). Dữ liệu sẽ được tích lũy và chỉ ghi khi đạt ngưỡng nhất định hoặc sau một khoảng thời gian cụ thể.
import { Injectable } from '@ohos.core';
@Injectable()
export class LogBufferManager {
private bufferPool: string[] = [];
private readonly MAX_BUFFER_SIZE = 50;
private isFlushing: boolean = false;
public capture(message: string): void {
this.bufferPool.push(message);
if (!this.isFlushing && this.bufferPool.length >= this.MAX_BUFFER_SIZE) {
this.executeFlush();
}
}
private async executeFlush(): Promise<void> {
this.isFlushing = true;
const payload = this.bufferPool.splice(0, this.bufferPool.length);
// Chuyển dữ liệu sang module xử lý
await this.dispatchToProcessor(payload);
this.isFlushing = false;
}
private async dispatchToProcessor(data: string[]): Promise<void> {
console.info('Dispatching batch logs:', data.length);
// Logic gọi service xử lý tiếp theo
}
}
Đoạn code trên sử dụng cơ chế khóa trạng thái isFlushing để tránh xung đột khi ghi dữ liệu đồng thời, đảm bảo tính toàn vẹn của队列 log.
2.2. Module Xử Lý và Lọc (LogFilterStrategy)
Module này áp dụng các quy tắc lọc linh hoạt dựa trên biểu thức chính quy (Regex) để phân loại mức độ nghiêm trọng của log trước khi lưu trữ.
import { Injectable } from '@ohos.core';
@Injectable()
export class LogFilterStrategy {
private patterns: Map = new Map();
constructor() {
this.patterns.set('ERROR', /ERROR|FATAL|CRITICAL/i);
this.patterns.set('WARN', /WARN|WARNING/i);
}
public analyze(rawLog: string): { level: string, content: string } {
for (const [level, regex] of this.patterns.entries()) {
if (regex.test(rawLog)) {
return { level, content: rawLog };
}
}
return { level: 'INFO', content: rawLog };
}
public registerRule(level: string, pattern: string): void {
this.patterns.set(level, new RegExp(pattern, 'i'));
}
}
Việc sử dụng Map và RegExp giúp tăng tốc độ tra cứu và linh hoạt trong việc định nghĩa thêm các quy tắc lọc mới mà không cần sửa đổi core logic.
2.3. Module Lưu Trữ Persistent (LogPersistenceLayer)
Trên HarmonyNext, việc lưu trữ nên sử dụng API Preferences thay vì các giải pháp web truyền thống để đảm bảo hiệu năng và bảo mật.
import { preferences } from '@ohos.data.preferences';
import { Injectable } from '@ohos.core';
@Injectable()
export class LogPersistenceLayer {
private prefName: string = 'system_logs';
private store: preferences.Preferences | null = null;
async init(): Promise<void> {
this.store = await preferences.getPreferences(this.prefName);
}
async persist(logEntry: string): Promise<void> {
if (!this.store) await this.init();
const currentLogs = await this.getAll();
currentLogs.push(logEntry);
// Giới hạn số lượng log lưu trữ để tránh tràn bộ nhớ
if (currentLogs.length > 1000) {
currentLogs.shift();
}
await this.store.put('logs', JSON.stringify(currentLogs));
await this.store.flush();
}
async getAll(): Promise {
if (!this.store) await this.init();
const data = await this.store.get('logs', '[]');
return JSON.parse(data as string);
}
}
Logic này bao gồm cơ chế giới hạn số lượng log (max 1000 bản ghi) để ngăn chặn việc chiếm dụng quá nhiều dung lượng lưu trữ trên thiết bị người dùng.
2.4. Module Giao Diện Người Dùng (LogMonitorPage)
Giao diện được xây dựng bằng ArkUI, sử dụng thành phần List để hiển thị danh sách log hiệu suất cao.
import { Component, State, View, Text, List, ListItem } from '@ohos.arkui';
import { LogPersistenceLayer } from './LogPersistenceLayer';
@Component
export struct LogMonitorPage {
@State logEntries: string[] = [];
private storage: LogPersistenceLayer = new LogPersistenceLayer();
aboutToAppear() {
this.loadLogs();
}
async loadLogs() {
this.logEntries = await this.storage.getAll();
}
build() {
Column() {
Text('Hệ Thống Giám Sát Log')
.fontSize(20)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 10 })
List({ space: 5 }) {
ForEach(this.logEntries, (item: string) => {
ListItem() {
Text(item)
.fontSize(14)
.fontColor('#333333')
.padding(10)
.backgroundColor('#F5F5F5')
.borderRadius(5)
}
})
}
.width('100%')
.height('100%')
}
.padding(15)
}
}
Component sử dụng annotation @State để tự động cập nhật giao diện khi dữ liệu log thay đổi, đảm bảo trải nghiệm người dùng mượt mà.
3. Tích Hợp và Kiểm Thử
Để hoàn thiện hệ thống, các module cần được khởi tạo và liên kết thông qua cơ chế Dependency Injection của khung làm việc. Quy trình kiểm thử nên bao gồm:
- Unit Test: Verify logic lọc log và cơ chế đệm dữ liệu.
- Integration Test: Kiểm tra luồng dữ liệu từ khi phát sinh log đến khi hiển thị trên UI.
- Performance Test: Đo lường độ trễ khi xử lý lượng log lớn (stress test).
Việc sử dụng các công cụ profiling đi kèm với HarmonyNext SDK sẽ giúp xác định các điểm nghẽn về bộ nhớ hoặc CPU trong quá trình vận hành thực tế.