Merge pull request #932 from sarub0b0/feat/log-buffer-limit

feat: add log buffer line limit to prevent excessive memory usage

Author: sarub0b0

src/app.rs

@@ -73,6 +73,7 @@ impl App {
             default_pod_columns,
             config.theme.clone(),
             cmd.clipboard,
+            config.logging.max_lines,
         );
 
         logger!(info, "app start");

src/config.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 
 use anyhow::Result;
 use figment::{
-    providers::{Env, Format, Serialized, YamlExtended},
+    providers::{Env, Format, Serialized, Yaml},
     Figment,
 };
 use serde::{Deserialize, Serialize};
@@ -19,9 +19,16 @@ pub enum ConfigLoadOption {
     Path(PathBuf),
 }
 
+#[derive(Default, Debug, Deserialize, Serialize)]
+pub struct LoggingConfig {
+    pub max_lines: Option<usize>,
+}
+
 #[derive(Default, Debug, Deserialize, Serialize)]
 pub struct Config {
     pub theme: ThemeConfig,
+    #[serde(default)]
+    pub logging: LoggingConfig,
 }
 
 impl Config {
@@ -30,7 +37,9 @@ impl Config {
 
         let config = match option {
             ConfigLoadOption::Default => figment.merge(Serialized::defaults(Self::default())),
-            ConfigLoadOption::Path(path) => figment.merge(YamlExtended::file(path)),
+            ConfigLoadOption::Path(path) => figment
+                .merge(Serialized::defaults(Self::default()))
+                .merge(Yaml::file(path)),
         }
         .merge(Env::prefixed("KUBETUI_").split("__"))
         .extract_lossy()?;

src/features/pod/kube/filter.rs

@@ -90,6 +90,8 @@ pub struct Filter {
     pub exclude_log: Option<Vec<Regex>>,
     /// JSONログに適用するフィルター（jq、JMESPathなど）
     pub json_filter: Option<JsonFilter>,
+    /// ログバッファの最大行数
+    pub limit: Option<usize>,
 }
 
 impl Filter {
@@ -238,6 +240,10 @@ impl Filter {
 
                     filter.json_filter = Some(json_filter);
                 }
+
+                FilterAttribute::Limit(n) => {
+                    filter.limit = Some(n);
+                }
             }
         }
 
@@ -251,6 +257,7 @@ impl Filter {
                 .fold((false, false), |(ls, rl), filter| match filter {
                     FilterAttribute::Resource(_) => (ls, true),
                     FilterAttribute::LabelSelector(_) => (true, rl),
+                    FilterAttribute::Limit(_) => (ls, rl),
                     _ => (ls, rl),
                 });
 
@@ -398,6 +405,10 @@ impl std::fmt::Display for Filter {
             }
         }
 
+        if let Some(limit) = self.limit {
+            buf.push(format!("limit={}", limit));
+        }
+
         write!(f, "{}", buf.join(" "))
     }
 }
@@ -476,6 +487,7 @@ pub enum FilterAttribute<'a> {
     ExcludeLog(Cow<'a, str>),
     Jq(Cow<'a, str>),
     JMESPath(Cow<'a, str>),
+    Limit(usize),
 }
 
 struct FilterAttributes;
@@ -659,4 +671,30 @@ mod tests {
         assert!(display2.contains("jq=.message"));
         assert!(!display2.contains("jmespath="));
     }
+
+    #[test]
+    fn test_parse_with_limit() {
+        let filter = Filter::parse("limit:5000").unwrap();
+        assert_eq!(filter.limit, Some(5000));
+    }
+
+    #[test]
+    fn test_parse_with_limit_and_other_filters() {
+        let filter = Filter::parse("pod:api limit:5000 log:error").unwrap();
+        assert_eq!(filter.limit, Some(5000));
+        assert!(filter.pod.is_some());
+        assert!(filter.include_log.is_some());
+    }
+
+    #[test]
+    fn test_parse_without_limit() {
+        let filter = Filter::parse("pod:api").unwrap();
+        assert_eq!(filter.limit, None);
+    }
+
+    #[test]
+    fn test_parse_with_lim_alias() {
+        let filter = Filter::parse("lim:10000").unwrap();
+        assert_eq!(filter.limit, Some(10000));
+    }
 }

src/features/pod/kube/filter/parser.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use nom::{
     branch::alt,
     bytes::complete::{is_not, tag},
-    character::complete::{alphanumeric1, anychar, char, multispace0, multispace1},
+    character::complete::{alphanumeric1, anychar, char, digit1, multispace0, multispace1},
     combinator::{all_consuming, map, recognize, value, verify},
     error::{ContextError, ParseError},
     multi::{fold_many0, many1_count, separated_list1},
@@ -235,6 +235,28 @@ fn jmespath<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
     Ok((remaining, FilterAttribute::JMESPath(value)))
 }
 
+fn positive_integer<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
+    s: &'a str,
+) -> IResult<&'a str, usize, E> {
+    let (remaining, digits) = digit1(s)?;
+    let n = digits
+        .parse::<usize>()
+        .map_err(|_| nom::Err::Error(E::from_error_kind(s, nom::error::ErrorKind::Digit)))?;
+    Ok((remaining, n))
+}
+
+fn limit<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
+    s: &'a str,
+) -> IResult<&'a str, FilterAttribute<'a>, E> {
+    let (remaining, (_, value)) = separated_pair(
+        alt((tag("limit"), tag("lim"))),
+        char(':'),
+        positive_integer,
+    )
+    .parse(s)?;
+    Ok((remaining, FilterAttribute::Limit(value)))
+}
+
 fn specified_daemonset<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
     s: &'a str,
 ) -> IResult<&'a str, FilterAttribute<'a>, E> {
@@ -349,6 +371,7 @@ fn attribute<'a, E: ParseError<&'a str> + ContextError<&'a str>>(
         specified_statefulset,
         field_selector,
         label_selector,
+        limit,
         pod,
         exclude_pod,
         container,
@@ -714,6 +737,18 @@ mod tests {
         assert_eq!(remaining, "");
     }
 
+    #[rstest]
+    #[case("limit:5000", 5000)]
+    #[case("lim:5000", 5000)]
+    #[case("limit:1", 1)]
+    #[case("limit:100000", 100000)]
+    fn limit(#[case] query: &str, #[case] expected: usize) {
+        let (remaining, actual) = super::limit::<Error<_>>(query).unwrap();
+
+        assert_eq!(actual, FilterAttribute::Limit(expected));
+        assert_eq!(remaining, "");
+    }
+
     #[rustfmt::skip]
     #[rstest]
     #[case("pod:hoge", FilterAttribute::Pod("hoge".into()))]
@@ -735,6 +770,8 @@ mod tests {
     #[case("jmespath:message", FilterAttribute::JMESPath("message".into()))]
     #[case("jmes:level", FilterAttribute::JMESPath("level".into()))]
     #[case("jm:data.id", FilterAttribute::JMESPath("data.id".into()))]
+    #[case("limit:5000", FilterAttribute::Limit(5000))]
+    #[case("lim:1000", FilterAttribute::Limit(1000))]
     fn attribute(#[case] query: &str, #[case] expected: FilterAttribute) {
         let (remaining, actual) = super::attribute::<Error<_>>(query).unwrap();
 
@@ -763,6 +800,7 @@ mod tests {
             "statefulset/app",
             "jq:.message",
             "jmespath:data.id",
+            "limit:5000",
             "     ",
         ]
         .join("  ");
@@ -787,6 +825,7 @@ mod tests {
             FilterAttribute::Resource(SpecifiedResource::StatefulSet("app")),
             FilterAttribute::Jq(".message".into()),
             FilterAttribute::JMESPath("data.id".into()),
+            FilterAttribute::Limit(5000),
         ];
 
         assert_eq!(actual, expected);

src/features/pod/kube/log.rs

@@ -18,6 +18,7 @@ use kube::Api;
 use tokio::task::{JoinError, JoinHandle};
 
 use crate::{
+    features::pod::message::LogMessage,
     kube::{context::Namespace, KubeClient},
     logger,
     message::Message,
@@ -148,6 +149,13 @@ impl AbortWorker for LogWorker {
     async fn run(&self) {
         match Filter::parse(&self.config.query) {
             Ok(filter) => {
+                // Send SetMaxLines message if limit is specified in the query
+                if filter.limit.is_some() {
+                    self.tx
+                        .send(LogMessage::SetMaxLines(filter.limit).into())
+                        .expect("Failed to send LogMessage::SetMaxLines");
+                }
+
                 match self.spawn_tasks(filter).await {
                     Ok(mut handles) => {
                         handles.join().await;

src/features/pod/message.rs

@@ -9,6 +9,7 @@ pub enum LogMessage {
     Request(LogConfig),
     Response(Result<Vec<String>>),
     ToggleJsonPrettyPrint,
+    SetMaxLines(Option<usize>),
 }
 
 impl From<LogMessage> for Message {

src/features/pod/view/tab.rs

@@ -38,11 +38,12 @@ impl PodTab {
         namespaces: Rc<RefCell<Namespace>>,
         default_columns: Option<PodColumns>,
         theme: WidgetThemeConfig,
+        log_max_lines: Option<usize>,
     ) -> Self {
         let pod_widget = pod_widget(tx, theme.clone());
         let log_query_widget = log_query_widget(tx, namespaces, theme.clone());
         let pod_columns_dialog = pod_columns_dialog(tx, default_columns, theme.clone());
-        let log_widget = log_widget(tx, clipboard, theme);
+        let log_widget = log_widget(tx, clipboard, theme, log_max_lines);
         let log_query_help_widget = log_query_help_widget();
 
         let layout = TabLayout::new(layout, split_direction);

src/features/pod/view/widgets/log.rs

@@ -22,6 +22,7 @@ pub fn log_widget(
     tx: &Sender<Message>,
     clipboard: &Option<Rc<RefCell<Clipboard>>>,
     theme: WidgetThemeConfig,
+    max_lines: Option<usize>,
 ) -> Widget<'static> {
     let widget_theme = WidgetTheme::from(theme.clone());
 
@@ -36,7 +37,7 @@ pub fn log_widget(
 
     let text_theme = TextTheme::from(theme);
 
-    let builder = Text::builder()
+    let mut builder = Text::builder()
         .id(POD_LOG_WIDGET_ID)
         .widget_base(widget_base)
         .search_form(search_form)
@@ -54,6 +55,10 @@ pub fn log_widget(
             toggle_json_pretty_print(tx.clone()),
         );
 
+    if let Some(max) = max_lines {
+        builder = builder.max_lines(Some(max));
+    }
+
     if let Some(cb) = clipboard {
         builder.clipboard(cb.clone())
     } else {

src/features/pod/view/widgets/log_query_help.rs

@@ -36,6 +36,7 @@ fn content() -> Vec<String> {
            field:<selector>      (alias: fields)
            jq:<expr>
            jmespath:<expr>       (alias: jmes, jm)
+           limit:<number>        (alias: lim)
            <resource>/<name>
 
         Resources: