Add service filter, use realtime for timestamp, add category to desktop file, improve summary

Author: mingue

.eslintrc.cjs

@@ -12,4 +12,7 @@ module.exports = {
   parserOptions: {
     ecmaVersion: "latest",
   },
+  rules: {
+    "vue/require-v-for-key": "warn",
+  },
 };

.github/workflows/release.yaml

@@ -34,5 +34,3 @@ jobs:
           draft: true
           prerelease: true
           generate_release_notes: true
-
-      #TODO: Use tag as version for tauri packages

TODO.md

@@ -13,8 +13,9 @@
 
 - [x] Priority
 - [x] Message text
-- [ ] Unit
+- [x] Unit
 - [ ] Time range
+- [ ] Transports
 
 ## Quick filter bar
 
@@ -40,7 +41,7 @@
 ## Automate relase process
 
 - [x] Document build & publish process
-- [ ] Automate process
+- [ ] Automate process, partially done, missing aur upload
 
 ## Investigate possibility of flatpak
 

package.json

@@ -33,4 +33,4 @@
     "vite": "~3.2",
     "vue-tsc": "~1.0"
   }
-}
+}

package/journal-viewer.desktop

@@ -1,9 +1,9 @@
-#!/usr/bin/env xdg-open
 [Desktop Entry]
 Name=Journal Viewer
 Comment=Visualize systemd logs
 Exec=journal-viewer
 Terminal=false
 Icon=logviewer
 StartupNotify=false
-Type=Application
+Type=Application
+Categories=Settings;

src-tauri/src/journal.rs

@@ -3,8 +3,10 @@ use crate::journal_fields;
 use crate::libsdjournal::*;
 use crate::query::Query;
 use crate::query_builder::QueryBuilder;
+use crate::unit::Unit;
 use bitflags::bitflags;
 use libc::c_void;
+use std::process::Command;
 
 bitflags! {
     #[repr(C)]
@@ -74,6 +76,12 @@ impl Journal {
 
         loop {
             let more = sd_journal_previous(self.ptr)?;
+
+            if !more {
+                debug!("No more entries");
+                break;
+            }
+            
             if let Ok(updated_timestamp) = self.get_field(journal_fields::SOURCE_REALTIME_TIMESTAMP)
             {
                 last_timestamp = updated_timestamp.parse().unwrap();
@@ -87,11 +95,6 @@ impl Journal {
                 }
             }
 
-            if !more {
-                debug!("No more entries");
-                break;
-            }
-
             if q.limit > 0 && count >= q.limit {
                 debug!("Reached limit of {}", q.limit);
                 break;
@@ -105,14 +108,26 @@ impl Journal {
             let mut row: Vec<String> = Vec::with_capacity(q.fields.len());
 
             for field in q.fields.iter() {
-                match self.get_field(field) {
-                    Ok(data) => {
-                        row.push(data);
-                    }
-                    Err(e) => {
-                        row.push(String::new());
-                        warn!("Could not find the field: {}, JournalError: {}", &field, e);
+                match field.as_str() {
+                    "__REALTIME" => {
+                        let mut realtime: u64 = 0;
+                        match sd_journal_get_realtime_usec(self.ptr, &mut realtime) {
+                            Err(JournalError(e)) => {
+                                row.push(String::new());
+                                warn!("Could not get realtime field, error: {}", e);
+                            }
+                            Ok(()) => row.push(realtime.to_string()),
+                        }
                     }
+                    _ => match self.get_field(field) {
+                        Ok(data) => {
+                            row.push(data);
+                        }
+                        Err(e) => {
+                            row.push(String::new());
+                            warn!("Could not find the field: {}, JournalError: {}", &field, e);
+                        }
+                    },
                 }
             }
 
@@ -182,6 +197,20 @@ impl Journal {
             }
         }
     }
+
+    pub fn list_services() -> Vec<Unit> {
+        let output = Command::new("systemctl")
+            .arg("list-unit-files")
+            .arg("*.service")
+            .arg("-o")
+            .arg("json")
+            .output()
+            .expect("Failed to execute command");
+
+        let stdout = String::from_utf8(output.stdout).unwrap();
+
+        serde_json::from_str(&stdout).unwrap()
+    }
 }
 
 impl Drop for Journal {

src-tauri/src/libsdjournal.rs

@@ -8,7 +8,7 @@ use std::{
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct JournalError(i32);
+pub struct JournalError(pub i32);
 
 impl Display for JournalError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -171,7 +171,7 @@ pub fn sd_journal_seek_tail(sd_journal: *mut c_void) -> Result<(), JournalError>
     Ok(())
 }
 
-pub fn sd_journal_add_conjunction(sd_journal: *mut c_void) -> Result<bool, JournalError> {
+pub fn sd_journal_add_conjunction(sd_journal: *mut c_void) -> Result<(), JournalError> {
     let ret: libc::c_int;
 
     unsafe {
@@ -182,10 +182,10 @@ pub fn sd_journal_add_conjunction(sd_journal: *mut c_void) -> Result<bool, Journ
         return Err(JournalError(ret));
     }
 
-    Ok(ret > 0)
+    Ok(())
 }
 
-pub fn sd_journal_add_disjunction(sd_journal: *mut c_void) -> Result<bool, JournalError> {
+pub fn sd_journal_add_disjunction(sd_journal: *mut c_void) -> Result<(), JournalError> {
     let ret: libc::c_int;
 
     unsafe {
@@ -196,11 +196,28 @@ pub fn sd_journal_add_disjunction(sd_journal: *mut c_void) -> Result<bool, Journ
         return Err(JournalError(ret));
     }
 
-    Ok(ret > 0)
+    Ok(())
 }
 
 pub fn sd_journal_flush_matches(sd_journal: *mut c_void) {
     unsafe {
         libsdjournal_bindings::sd_journal_flush_matches(sd_journal);
     }
 }
+
+pub fn sd_journal_get_realtime_usec(
+    sd_journal: *mut c_void,
+    microseconds: &mut u64,
+) -> Result<(), JournalError> {
+    let ret: libc::c_int;
+
+    unsafe {
+        ret = libsdjournal_bindings::sd_journal_get_realtime_usec(sd_journal, microseconds);
+    }
+
+    if ret < 0 {
+        return Err(JournalError(ret));
+    }
+
+    Ok(())
+}

src-tauri/src/libsdjournal_bindings.rs

@@ -49,4 +49,7 @@ extern "C" {
 
     //void sd_journal_flush_matches(sd_journal *j);
     pub fn sd_journal_flush_matches(sd_journal: *mut c_void);
+
+    //int sd_journal_get_realtime_usec(sd_journal *j, uint64_t *usec);
+    pub fn sd_journal_get_realtime_usec(sd_journal: *mut c_void, microseconds: *mut u64) -> c_int;
 }

src-tauri/src/main.rs

@@ -11,6 +11,7 @@ mod libsdjournal;
 mod libsdjournal_bindings;
 mod query;
 mod query_builder;
+mod unit;
 
 #[macro_use]
 extern crate log;
@@ -23,6 +24,7 @@ use journal_entries::JournalEntries;
 use libsdjournal::JournalError;
 use serde::Deserialize;
 use tauri::async_runtime::Mutex;
+use unit::Unit;
 
 fn main() {
     let env = Env::default()
@@ -41,7 +43,11 @@ fn main() {
     info!("Starting journal logger");
     tauri::Builder::default()
         .manage(Mutex::new(j))
-        .invoke_handler(tauri::generate_handler![get_logs, get_summary])
+        .invoke_handler(tauri::generate_handler![
+            get_logs,
+            get_summary,
+            get_services
+        ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
@@ -54,6 +60,7 @@ pub struct JournalQuery {
     limit: u64,
     quick_search: String,
     reset_position: bool,
+    service: String,
 }
 
 #[tauri::command]
@@ -70,6 +77,7 @@ async fn get_logs(
         .with_quick_search(query.quick_search)
         .reset_position(query.reset_position)
         .with_priority_above_or_equal_to(query.priority)
+        .with_unit(query.service)
         .build();
 
     let lock = journal.lock().await;
@@ -79,8 +87,14 @@ async fn get_logs(
     Ok(logs)
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SummaryQuery {
+    priority: u32,
+}
+
 #[tauri::command]
-async fn get_summary(query: JournalQuery) -> Result<JournalEntries, JournalError> {
+async fn get_summary(query: SummaryQuery) -> Result<JournalEntries, JournalError> {
     debug!("Getting summary...");
     let j = Journal::open(
         OpenFlags::SD_JOURNAL_LOCAL_ONLY
@@ -92,7 +106,7 @@ async fn get_summary(query: JournalQuery) -> Result<JournalEntries, JournalError
     let from = Utc::now() - Duration::days(1);
     let mut qb = QueryBuilder::default();
     let q = qb
-        .with_fields(vec![journal_fields::SOURCE_REALTIME_TIMESTAMP.into()])
+        .with_fields(vec!["__REALTIME".into()])
         .with_limit(10_000)
         .with_date_from(from.timestamp_micros() as u64)
         .with_priority_above_or_equal_to(query.priority)
@@ -103,3 +117,12 @@ async fn get_summary(query: JournalQuery) -> Result<JournalEntries, JournalError
 
     Ok(logs)
 }
+
+#[tauri::command]
+async fn get_services() -> Result<Vec<Unit>, JournalError> {
+    debug!("Getting services...");
+    let services = Journal::list_services();
+    debug!("found {} services", services.len());
+
+    Ok(Journal::list_services())
+}

src-tauri/src/query_builder.rs

@@ -21,6 +21,7 @@ impl QueryBuilder {
                 "syslog".into(),
                 "journal".into(),
                 "stdout".into(),
+                // "kernel".into(),
             ],
             from_epoch: 0,
             quick_search: "".into(),
@@ -103,13 +104,12 @@ impl QueryBuilder {
         self
     }
 
-    pub fn with_unit(&mut self, unit: &str) -> &mut Self {
-        let mut full_unit: String = String::from(unit);
-        if !full_unit.contains('.') {
-            full_unit.push_str(".service");
+    pub fn with_unit(&mut self, mut unit: String) -> &mut Self {
+        if !unit.is_empty() && !unit.contains('.') {
+            unit.push_str(".service");
         }
 
-        self.query.unit = full_unit;
+        self.query.unit = unit;
         self
     }