feat: Implement merged, time-sorted log view

Refactors the application to display a merged and time-sorted view of all uploaded log files in a table.

Key changes:
- Replaced the single-file text view with a multi-file `gr.DataFrame`.
- Implemented timestamp parsing on file load, storing parsed timestamps in the application state.
- Created a new `generate_merged_view` function to handle filtering, merging, and sorting of logs.
- Added `pandas` as a dependency for data manipulation.
- Updated the design document to reflect the new architecture and user flow.
- Added a help icon for regular expression syntax.

README.md

@@ -1,166 +1,166 @@
----
-title: LogViewer
-license: mit
-sdk: gradio
-app_file: logviewer/app.py
-colorFrom: blue
-colorTo: green
-sdk_version: 5.35.0
----
-
-# LogViewer
-
-LogViewer is a versatile tool designed for efficient viewing and filtering of log files. It offers both a user-friendly web interface built with Gradio and a powerful command-line interface (CLI) for automated processing.
-
-## Features
-
-*   **Web Interface (Gradio):**
-    *   Upload and display log files.
-    *   Apply multiple filters (include/exclude text, include/exclude regex).
-    *   Case-sensitive filtering option.
-    *   Reorder applied filters to control processing order.
-    *   Save and load filter configurations (JSON format).
-    *   Download filtered log content.
-*   **Command-Line Interface (CLI):**
-    *   Process log files using pre-defined filter configurations.
-    *   Automate log analysis workflows.
-
-## Installation
-
-To set up LogViewer on your local machine, follow these steps:
-
-### Prerequisites
-
-*   Python 3.8 or higher
-*   pip (Python package installer)
-*   `venv` (Python's built-in virtual environment module)
-
-### Steps
-
-1.  **Clone the repository:**
-    ```bash
-    git clone https://github.com/your-username/LogViewer.git
-    cd LogViewer
-    ```
-    *(Note: Replace `your-username` with the actual GitHub username once the repository is created.)*
-
-2.  **Create and activate a virtual environment:**
-    It's highly recommended to use a virtual environment to manage project dependencies.
-    ```bash
-    python -m venv venv
-    # On Linux/macOS:
-    source venv/bin/activate
-    # On Windows:
-    .\venv\Scripts\activate
-    ```
-
-3.  **Install dependencies:**
-    ```bash
-    pip install -r requirements.txt
-    ```
-
-## Usage
-
-### Running with Docker Compose
-
-Docker Compose provides an easy way to set up and run the LogViewer application in a containerized environment.
-
-#### Prerequisites
-
-*   Docker and Docker Compose installed on your system.
-
-#### Steps
-
-1.  **Build and run the services:**
-    Navigate to the root directory of the cloned repository and run:
-    ```bash
-    docker compose up --build -d
-    ```
-    This command builds the Docker image (if not already built) and starts the LogViewer service in detached mode.
-
-2.  **Access the Web UI:**
-    Open your web browser and navigate to `http://localhost:7860`.
-
-3.  **Using the CLI with Docker Compose:**
-    If you are running the web interface via Docker Compose, the CLI tool (`cli_app.py`) needs to connect to the Dockerized service. You will need to modify the `Client` URL in `cli_app.py` to point to the Docker container's exposed port (which is `http://localhost:7860` by default).
-
-    Locate the line `client = Client("http://localhost:7860/")` in `cli_app.py` and ensure it points to the correct address where your Docker container is accessible.
-
-    Then, you can run the CLI as usual:
-    ```bash
-    python cli_app.py <log_file_path> <filter_file_path> [-o <output_file_path>]
-    ```
-
-4.  **Stopping the services:**
-    To stop the running Docker containers, use:
-    ```bash
-    docker compose down
-    ```
-
-### Web Interface (Gradio App)
-
-To launch the interactive web interface:
-
-1.  **Start the application:**
-    Ensure your virtual environment is activated.
-    ```bash
-    python app.py
-    ```
-2.  **Access the UI:**
-    Open your web browser and navigate to the URL displayed in your terminal (usually `http://127.0.0.1:7860`).
-
-**How to use:**
-*   **Upload Log File:** Click the "Upload Log File" button to select your log file.
-*   **Add Filters:** Choose a "Filter Type" (e.g., "Include Text", "Exclude Regex"), enter a "Filter Value", and check "Case Sensitive" if needed. Click "Add Filter".
-*   **Manage Filters:** Applied filters will appear in the "Applied Filters" list. You can select a filter and use "Remove Selected Filter", "Move Up", or "Move Down" to adjust them.
-*   **Save/Load Filters:** Use "Save Filters" to download your current filter configuration as a JSON file, or "Load Filters (.json)" to upload a previously saved configuration.
-*   **Save Filtered Log:** After applying filters, click "Save Filtered Log" to download the processed log content.
-
-### Command-Line Interface (CLI)
-
-To process log files using the CLI, the Gradio web application (`app.py`) **must be running** in the background, as the CLI interacts with its API.
-
-1.  **Ensure the Gradio app is running:**
-    Open a separate terminal, activate your virtual environment, and run:
-    ```bash
-    python app.py
-    ```
-    Keep this terminal open.
-
-2.  **Run the CLI tool:**
-    In a new terminal, activate your virtual environment and use `cli_app.py`:
-    ```bash
-    python cli_app.py <log_file_path> <filter_file_path> [-o <output_file_path>]
-    ```
-    *   `<log_file_path>`: The path to the input log file you want to process.
-    *   `<filter_file_path>`: The path to a JSON file containing your filter configurations (e.g., `filters.json` saved from the web UI).
-    *   `-o <output_file_path>` (optional): The path where the filtered log content will be saved. If not provided, a default name will be generated (e.g., `your_log_filters_filtered.txt`).
-
-**Example:**
-
-```bash
-python cli_app.py my_application.log my_filters.json -o processed_log.txt
-```
-
-## Filter File Format
-
-Filter configurations are saved and loaded as JSON files. Each filter is an object within a list, with the following structure:
-
-```json
-[
-  {
-    "type": "Include Text",
-    "value": "ERROR",
-    "case_sensitive": true
-  },
-  {
-    "type": "Exclude Regex",
-    "value": "DEBUG|INFO",
-    "case_sensitive": false
-  }
-]
-```
-
-*   `type`: Can be "Include Text", "Exclude Text", "Include Regex", or "Exclude Regex".
-*   `value`: The string or regex pattern for the filter.
+---
+title: LogViewer
+license: mit
+sdk: gradio
+app_file: logviewer/app.py
+colorFrom: blue
+colorTo: green
+sdk_version: 5.35.0
+---
+
+# LogViewer
+
+LogViewer is a versatile tool designed for efficient viewing and filtering of log files. It offers both a user-friendly web interface built with Gradio and a powerful command-line interface (CLI) for automated processing.
+
+## Features
+
+*   **Web Interface (Gradio):**
+    *   Upload and display log files.
+    *   Apply multiple filters (include/exclude text, include/exclude regex).
+    *   Case-sensitive filtering option.
+    *   Reorder applied filters to control processing order.
+    *   Save and load filter configurations (JSON format).
+    *   Download filtered log content.
+*   **Command-Line Interface (CLI):**
+    *   Process log files using pre-defined filter configurations.
+    *   Automate log analysis workflows.
+
+## Installation
+
+To set up LogViewer on your local machine, follow these steps:
+
+### Prerequisites
+
+*   Python 3.8 or higher
+*   pip (Python package installer)
+*   `venv` (Python's built-in virtual environment module)
+
+### Steps
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/your-username/LogViewer.git
+    cd LogViewer
+    ```
+    *(Note: Replace `your-username` with the actual GitHub username once the repository is created.)*
+
+2.  **Create and activate a virtual environment:**
+    It's highly recommended to use a virtual environment to manage project dependencies.
+    ```bash
+    python -m venv venv
+    # On Linux/macOS:
+    source venv/bin/activate
+    # On Windows:
+    .\venv\Scripts\activate
+    ```
+
+3.  **Install dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Usage
+
+### Running with Docker Compose
+
+Docker Compose provides an easy way to set up and run the LogViewer application in a containerized environment.
+
+#### Prerequisites
+
+*   Docker and Docker Compose installed on your system.
+
+#### Steps
+
+1.  **Build and run the services:**
+    Navigate to the root directory of the cloned repository and run:
+    ```bash
+    docker compose up --build -d
+    ```
+    This command builds the Docker image (if not already built) and starts the LogViewer service in detached mode.
+
+2.  **Access the Web UI:**
+    Open your web browser and navigate to `http://localhost:7860`.
+
+3.  **Using the CLI with Docker Compose:**
+    If you are running the web interface via Docker Compose, the CLI tool (`cli_app.py`) needs to connect to the Dockerized service. You will need to modify the `Client` URL in `cli_app.py` to point to the Docker container's exposed port (which is `http://localhost:7860` by default).
+
+    Locate the line `client = Client("http://localhost:7860/")` in `cli_app.py` and ensure it points to the correct address where your Docker container is accessible.
+
+    Then, you can run the CLI as usual:
+    ```bash
+    python cli_app.py <log_file_path> <filter_file_path> [-o <output_file_path>]
+    ```
+
+4.  **Stopping the services:**
+    To stop the running Docker containers, use:
+    ```bash
+    docker compose down
+    ```
+
+### Web Interface (Gradio App)
+
+To launch the interactive web interface:
+
+1.  **Start the application:**
+    Ensure your virtual environment is activated.
+    ```bash
+    python app.py
+    ```
+2.  **Access the UI:**
+    Open your web browser and navigate to the URL displayed in your terminal (usually `http://127.0.0.1:7860`).
+
+**How to use:**
+*   **Upload Log File:** Click the "Upload Log File" button to select your log file.
+*   **Add Filters:** Choose a "Filter Type" (e.g., "Include Text", "Exclude Regex"), enter a "Filter Value", and check "Case Sensitive" if needed. Click "Add Filter".
+*   **Manage Filters:** Applied filters will appear in the "Applied Filters" list. You can select a filter and use "Remove Selected Filter", "Move Up", or "Move Down" to adjust them.
+*   **Save/Load Filters:** Use "Save Filters" to download your current filter configuration as a JSON file, or "Load Filters (.json)" to upload a previously saved configuration.
+*   **Save Filtered Log:** After applying filters, click "Save Filtered Log" to download the processed log content.
+
+### Command-Line Interface (CLI)
+
+To process log files using the CLI, the Gradio web application (`app.py`) **must be running** in the background, as the CLI interacts with its API.
+
+1.  **Ensure the Gradio app is running:**
+    Open a separate terminal, activate your virtual environment, and run:
+    ```bash
+    python app.py
+    ```
+    Keep this terminal open.
+
+2.  **Run the CLI tool:**
+    In a new terminal, activate your virtual environment and use `cli_app.py`:
+    ```bash
+    python cli_app.py <log_file_path> <filter_file_path> [-o <output_file_path>]
+    ```
+    *   `<log_file_path>`: The path to the input log file you want to process.
+    *   `<filter_file_path>`: The path to a JSON file containing your filter configurations (e.g., `filters.json` saved from the web UI).
+    *   `-o <output_file_path>` (optional): The path where the filtered log content will be saved. If not provided, a default name will be generated (e.g., `your_log_filters_filtered.txt`).
+
+**Example:**
+
+```bash
+python cli_app.py my_application.log my_filters.json -o processed_log.txt
+```
+
+## Filter File Format
+
+Filter configurations are saved and loaded as JSON files. Each filter is an object within a list, with the following structure:
+
+```json
+[
+  {
+    "type": "Include Text",
+    "value": "ERROR",
+    "case_sensitive": true
+  },
+  {
+    "type": "Exclude Regex",
+    "value": "DEBUG|INFO",
+    "case_sensitive": false
+  }
+]
+```
+
+*   `type`: Can be "Include Text", "Exclude Text", "Include Regex", or "Exclude Regex".
+*   `value`: The string or regex pattern for the filter.
 *   `case_sensitive`: A boolean (`true` or `false`) indicating whether the filter should be case-sensitive.

design.md

@@ -2,73 +2,64 @@
 
 ## 1. Overview
 
-LogViewer is a web-based application built with Python and Gradio that allows users to upload and inspect log files. It provides dynamic filtering capabilities to help users analyze log data by including or excluding lines based on text or regular expressions.
+LogViewer is a web-based application built with Python, Gradio, and Pandas that allows users to upload and inspect multiple log files. It provides a merged, time-sorted view of all logs and allows for dynamic filtering with separate filter sets for each file. This helps users analyze log data by including or excluding lines based on text or regular expressions.
 
 ## 2. Components
 
-The application consists of two main Python files:
+The application consists of three main Python files:
 
 ### 2.1. `app.py`
 
 This is the main application file that creates the user interface and handles all user interactions.
 
 *   **UI Structure:** The UI is built using `gradio.Blocks` with the `Soft` theme. It includes:
-    *   A file upload component (`gr.File`) for loading log files.
-    *   A large, non-interactive textbox (`gr.Textbox`) to display the processed log content.
+    *   A file upload component (`gr.File`) for loading multiple log files.
+    *   A dropdown (`gr.Dropdown`) to select the log file whose filters you want to manage.
+    *   A `gr.DataFrame` to display the merged, filtered, and time-sorted log content in a table with columns for "File", "Timestamp", and "Log Entry".
     *   A section for adding new filters, containing:
         *   A dropdown (`gr.Dropdown`) to select the filter type (Include/Exclude Text, Include/Exclude Regex).
-        *   A textbox (`gr.Textbox`) to input the filter pattern.
+        *   A textbox (`gr.Textbox`) to input the filter pattern, accompanied by a help button (`gr.Button`) that provides a popup with a regex guide.
         *   A checkbox (`gr.Checkbox`) to control case sensitivity for the filter.
         *   An "Add Filter" button (`gr.Button`).
-        *   "Save Filters" button (`gr.Button`) to download the current filter set as a JSON file.
-        *   "Load Filters" button (`gr.UploadButton`) to upload a JSON file and apply saved filters.
-    *   A section to display and manage active filters:
-        *   A radio button group (`gr.Radio`) that lists the currently applied filters, showing their type, value, and case sensitivity.
+        *   "Save Filters" button (`gr.Button`) to download the current filter set for the selected file as a JSON file.
+        *   "Load Filters" button (`gr.UploadButton`) to upload a JSON file and apply saved filters to the selected file.
+    *   A section to display and manage active filters for the selected file:
+        *   A radio button group (`gr.Radio`) that lists the currently applied filters.
         *   A "Remove Selected Filter" button (`gr.Button`).
-        *   "Move Up" button (`gr.Button`) to move the selected filter up in the list.
-        *   "Move Down" button (`gr.Button`) to move the selected filter down in the list.
-    *   A "Save Filtered Log" button (`gr.Button`) to download the currently displayed filtered log content.
+        *   "Move Up" and "Move Down" buttons to reorder filters.
+    *   A "Save Filtered Log" button (`gr.Button`) to download the currently displayed merged log content.
 
 *   **State Management:**
-    *   A `gr.State` object (`filters_state`) is used to maintain the list of active filters as a list of dictionaries. Each dictionary represents a single filter.
+    *   A `gr.State` object (`files_state`) maintains the application's state. It's a dictionary where keys are filenames and values are dictionaries containing:
+        *   `lines`: A list of objects, where each object represents a line and stores its parsed timestamp, the raw content, and the source filename.
+        *   `filters`: A list of active filter dictionaries for that file.
 
 *   **Core Logic:**
-    *   **`add_filter()`:** Adds a new filter dictionary to the `filters_state` list.
-    *   **`remove_filter()`:** Removes a filter from the `filters_state` list based on the user's selection.
-    *   **`move_filter_up()`:** Moves the selected filter up in the `filters_state` list.
-    *   **`move_filter_down()`:** Moves the selected filter down in the `filters_state` list.
-    *   **`apply_filters()`:** This is the main processing function. It reads the uploaded file and applies the sequence of filters stored in `filters_state` by calling the `filter_lines` utility function for each filter.
-    *   **`update_filter_list()`:** Generates a list of strings from the `filters_state` list to display it in the UI.
-    *   **`save_filters()`:** Saves the current `filters_state` to a JSON file.
-    *   **`load_filters()`:** Loads filters from a JSON file into `filters_state`.
-    *   **`save_filtered_log()`:** Saves the current content of the log display to a text file.
+    *   **`add_file()`:** Handles file uploads. For each line in a new file, it calls `timestamp_utils.parse_timestamp` and stores the result along with the line content in `files_state`.
+    *   **`select_file()`:** Triggered when a user selects a file from the dropdown. It updates the UI to show the filters for the selected file.
+    *   **`add_filter()`, `remove_filter()`, `move_filter_up()`, `move_filter_down()`:** These functions manage the filter list for the currently selected file.
+    *   **`generate_merged_view()`:** This is the main processing function. It iterates through all files in `files_state`, applies the respective filters to each file's lines, combines the filtered lines into a single list, sorts them by timestamp, and returns a Pandas DataFrame for display.
+    *   **`update_filter_list()`:** Generates a list of strings from the filter list of the selected file to display it in the UI.
+    *   **`save_filters()` & `load_filters()`:** Handle saving and loading of filter sets.
+    *   **`save_filtered_log()`:** Saves the content of the DataFrame to a text file.
+    *   **`show_regex_help()`:** Displays an informational popup with a guide to using regular expressions.
 
 *   **Event Handling:**
-    *   Uploading a file triggers `apply_filters`.
-    *   Clicking "Add Filter" triggers `add_filter`, then `update_filter_list`, and finally `apply_filters`.
-    *   Clicking "Remove Selected Filter" triggers `remove_filter`, then `update_filter_list`, and finally `apply_filters`.
-    *   Clicking "Move Up" triggers `move_filter_up`, then `update_filter_list`, and finally `apply_filters`.
-    *   Clicking "Move Down" triggers `move_filter_down`, then `update_filter_list`, and finally `apply_filters`.
-    *   Clicking "Save Filters" triggers `save_filters`.
-    *   Uploading a file to "Load Filters" triggers `load_filters`, then `update_filter_list`, and finally `apply_filters`.
-    *   Clicking "Save Filtered Log" triggers `save_filtered_log`.
-
-*   **API Endpoints:**
-    *   The Gradio application is mounted on a FastAPI app, which exposes all public functions as API endpoints. The endpoints are accessible at `http://<host>:<port>/api/<function_name>/`.
+    *   Uploading a file triggers `add_file` and then `generate_merged_view`.
+    *   Changing the file selection in the dropdown triggers `select_file` to update the displayed filter list.
+    *   Any action that modifies filters (add, remove, move, load) triggers `generate_merged_view` to refresh the log table.
 
 ### 2.2. `filter_utils.py`
 
 This module provides the core filtering logic.
 
-*   **`filter_lines()`:** A pure function that takes a list of text lines and applies a single filtering criterion (e.g., include text, exclude regex). It handles both plain text and regular expression matching, with an option for case sensitivity. It returns a new list of filtered lines.
+*   **`filter_lines()`:** A pure function that takes a list of text lines and applies a single filtering criterion.
 
 ### 2.3. `timestamp_utils.py`
 
-This module provides utilities for parsing and filtering log lines based on timestamps.
+This module provides utilities for parsing timestamps from log lines.
 
-*   **`parse_timestamp()`:** Attempts to parse a timestamp from a log line. Designed to be extensible for various timestamp formats.
-*   **`get_timestamp_range()`:** Extracts the earliest and latest timestamps from a list of log lines.
-*   **`filter_by_time_range()`:** Filters log lines to include only those within a specified time range, based on parsed timestamps.
+*   **`parse_timestamp()`:** Attempts to parse a timestamp from a log line, supporting multiple formats.
 
 ### 2.4. `cli_app.py`
 
@@ -76,23 +67,22 @@ This is a command-line interface (CLI) application that interacts with the runni
 
 *   **Functionality:**
     *   Takes a log file path and a filter JSON file path as arguments.
-    *   Optionally takes an output file path; otherwise, it generates one.
-    *   Uses the `requests` library to send POST requests to the `/api/apply_filters/` endpoint of the Gradio app.
-    *   Saves the filtered log content to the specified output file.
+    *   Uses the `requests` library to send POST requests to the Gradio app's API endpoints.
+    *   Saves the filtered log content to an output file.
 
 ## 3. User Interaction Flow
 
 1.  The user opens the application in their browser.
-2.  The user uploads a log file using the file upload component. The log content is immediately displayed.
-3.  To filter the log, the user selects a filter type, enters a value, and clicks "Add Filter".
-4.  The filter is added to the "Applied Filters" list, and the log view is automatically updated to reflect the new filter.
-5.  The user can add multiple filters sequentially. Each new filter is applied to the result of the previous ones.
-6.  To remove a filter, the user selects it from the "Applied Filters" radio group.
-7.  The user then clicks the "Remove Selected Filter" button.
-8.  The filter is removed from the list, and the log view is updated to reflect the change.
-9.  The user can reorder filters by selecting a filter and clicking "Move Up" or "Move Down" buttons.
-10. The user can save the current set of filters by clicking the "Save Filters" button, which will prompt a file download.
-11. The user can load a previously saved set of filters by clicking the "Load Filters" button and selecting a JSON file.
-12. The user can save the currently displayed filtered log content by clicking the "Save Filtered Log" button, which will prompt a file download.
-
-This design allows for a flexible and interactive way to analyze log files by building a chain of filters.
+2.  The user uploads one or more log files. The application immediately processes them, parses timestamps, and displays a merged, time-sorted view of all log entries in a table.
+3.  The filenames appear in a dropdown. The user can select a file from this dropdown to manage its specific filters.
+4.  When a file is selected, its associated filters are displayed in the "Applied Filters" list.
+5.  To filter a log, the user selects the corresponding file, defines a filter (e.g., "Include Text", "Exclude Regex"), and clicks "Add Filter".
+6.  The filter is added to the selected file's filter list, and the main log table automatically updates to reflect the change.
+7.  The user can add multiple filters to each file. Filters are applied sequentially.
+8.  The user can reorder or remove filters for the selected file, and the view will update accordingly.
+9.  The user can save the filter set for a selected file to a JSON file for later use.
+10. The user can load a saved filter set and apply it to the selected file.
+11. The user can click the "?" button for help with writing regular expressions.
+12. The user can save the currently displayed merged and filtered log content to a text file at any time.
+
+This design provides a powerful and interactive way to analyze multiple log files simultaneously in a unified, time-ordered view.

logviewer/app.py

@@ -1,122 +1,199 @@
 import gradio as gr
 import json
 import os
+import pandas as pd
 from filter_utils import filter_lines
+from timestamp_utils import parse_timestamp
+
+def add_file(files, state):
+    if files:
+        for file in files:
+            filename = os.path.basename(file.name)
+            if filename not in state:
+                with open(file.name) as f:
+                    lines = f.readlines()
+                
+                parsed_lines = []
+                for line in lines:
+                    parsed_lines.append({
+                        "timestamp": parse_timestamp(line),
+                        "content": line,
+                        "source": filename
+                    })
+                state[filename] = {"lines": parsed_lines, "filters": []}
+    
+    file_selector_update = gr.update(choices=list(state.keys()), value=list(state.keys())[0] if state else None)
+    selected_file = list(state.keys())[0] if state else None
+    
+    table_output_update = generate_merged_view(state)
+    filter_list_update = update_filter_list(selected_file, state)
+
+    return state, file_selector_update, table_output_update, filter_list_update
+
+def select_file(selected_file, state):
+    if selected_file and selected_file in state:
+        filter_list_update = update_filter_list(selected_file, state)
+        return filter_list_update
+    return gr.update(choices=[])
 
-def add_filter(filters, filter_type, filter_value, case_sensitive):
-    if filter_value:
-        filters.append({"type": filter_type, "value": filter_value, "case_sensitive": case_sensitive})
-    return filters, ""
+def add_filter(state, selected_file, filter_type, filter_value, case_sensitive):
+    if selected_file and filter_value:
+        state[selected_file]["filters"].append({"type": filter_type, "value": filter_value, "case_sensitive": case_sensitive})
+    return state, ""
 
-def remove_filter(filters, selected_filter):
-    if selected_filter:
+def remove_filter(state, selected_file, selected_filter):
+    if selected_file and selected_filter:
         parts = selected_filter.split(" - ")
         if len(parts) == 3:
             filter_type, filter_value, case_str = parts
             case_sensitive = case_str == "Case Sensitive: True"
+            filters = state[selected_file]["filters"]
             for i, f in enumerate(filters):
                 if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
                     filters.pop(i)
                     break
-    return filters, None
+    return state, None
 
-def move_filter_up(filters, selected_filter):
-    if selected_filter:
+def move_filter_up(state, selected_file, selected_filter):
+    if selected_file and selected_filter:
         parts = selected_filter.split(" - ")
         if len(parts) == 3:
             filter_type, filter_value, case_str = parts
             case_sensitive = case_str == "Case Sensitive: True"
+            filters = state[selected_file]["filters"]
             for i, f in enumerate(filters):
                 if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
                     if i > 0:
                         filters[i], filters[i-1] = filters[i-1], filters[i]
                     break
-    return filters, selected_filter
+    return state, selected_filter
 
-def move_filter_down(filters, selected_filter):
-    if selected_filter:
+def move_filter_down(state, selected_file, selected_filter):
+    if selected_file and selected_filter:
         parts = selected_filter.split(" - ")
         if len(parts) == 3:
             filter_type, filter_value, case_str = parts
             case_sensitive = case_str == "Case Sensitive: True"
+            filters = state[selected_file]["filters"]
             for i, f in enumerate(filters):
                 if f["type"] == filter_type and f["value"] == filter_value and f["case_sensitive"] == case_sensitive:
                     if i < len(filters) - 1:
                         filters[i], filters[i+1] = filters[i+1], filters[i]
                     break
-    return filters, selected_filter
+    return state, selected_filter
 
-def apply_filters(file, filters):
-    if file is not None:
-        with open(file.name) as f:
-            lines = f.readlines()
-
-        if not filters:
-            return "".join(lines)
+def generate_merged_view(state):
+    all_lines = []
+    for filename, data in state.items():
+        lines = data["lines"]
+        filters = data["filters"]
 
         processed_lines = lines
         for f in filters:
             filter_type = f["type"]
             value = f["value"]
             case = f["case_sensitive"]
+            
+            content_lines = [line["content"] for line in processed_lines]
 
             if filter_type == "Include Text":
-                processed_lines = filter_lines(processed_lines, include_text=value, case_sensitive=case)
+                filtered_content = filter_lines(content_lines, include_text=value, case_sensitive=case)
             elif filter_type == "Exclude Text":
-                processed_lines = filter_lines(processed_lines, exclude_text=value, case_sensitive=case)
+                filtered_content = filter_lines(content_lines, exclude_text=value, case_sensitive=case)
             elif filter_type == "Include Regex":
-                processed_lines = filter_lines(processed_lines, include_regex=value, case_sensitive=case)
+                filtered_content = filter_lines(content_lines, include_regex=value, case_sensitive=case)
             elif filter_type == "Exclude Regex":
-                processed_lines = filter_lines(processed_lines, exclude_regex=value, case_sensitive=case)
+                filtered_content = filter_lines(content_lines, exclude_regex=value, case_sensitive=case)
+            
+            processed_lines = [line for line in processed_lines if line["content"] in filtered_content]
 
-        return "".join(processed_lines)
-    return ""
+        all_lines.extend(processed_lines)
 
-def update_filter_list(filters):
-    filter_strings = [f'{f["type"]} - {f["value"]} - Case Sensitive: {f["case_sensitive"]}' for f in filters]
-    return gr.update(choices=filter_strings)
+    if not all_lines:
+        return pd.DataFrame(columns=["File", "Timestamp", "Log Entry"])
 
-def save_filters(filters):
-    with open("filters.json", "w") as f:
-        json.dump(filters, f)
-    return "filters.json"
+    # Sort lines by timestamp
+    all_lines.sort(key=lambda x: x["timestamp"] if x["timestamp"] is not None else pd.Timestamp.min)
 
-def load_filters(filter_file):
-    if filter_file is not None:
-        with open(filter_file.name) as f:
-            return json.load(f)
-    return []
+    df = pd.DataFrame(all_lines)
+    df["Timestamp"] = df["timestamp"].apply(lambda x: x.strftime('%Y-%m-%d %H:%M:%S') if pd.notnull(x) else "")
+    df = df.rename(columns={"source": "File", "content": "Log Entry"})
+    
+    return df[["File", "Timestamp", "Log Entry"]]
+
+def update_filter_list(selected_file, state):
+    if selected_file and selected_file in state:
+        filters = state[selected_file]["filters"]
+        filter_strings = [f'{f["type"]} - {f["value"]} - Case Sensitive: {f["case_sensitive"]}' for f in filters]
+        return gr.update(choices=filter_strings)
+    return gr.update(choices=[])
+
+def save_filters(selected_file, state):
+    if selected_file and selected_file in state:
+        filters = state[selected_file]["filters"]
+        with open(f"{selected_file}_filters.json", "w") as f:
+            json.dump(filters, f)
+        return f"{selected_file}_filters.json"
+    return None
 
-def save_filtered_log(log_content):
-    if log_content:
+def load_filters(selected_file, state, filter_file):
+    if selected_file and filter_file is not None:
+        with open(filter_file.name) as f:
+            state[selected_file]["filters"] = json.load(f)
+    return state
+
+def save_filtered_log(log_data):
+    if not log_data.empty:
+        log_content = ""
+        for index, row in log_data.iterrows():
+            log_content += f"[{row['File']}] [{row['Timestamp']}] {row['Log Entry']}"
+        
         with open("filtered_log.txt", "w") as f:
             f.write(log_content)
         return "filtered_log.txt"
     return None
 
-with gr.Blocks(theme=gr.themes.Soft(), css="#log_content textarea { font-family: monospace; }") as demo:
-    filters_state = gr.State([])
+def show_regex_help():
+    gr.Info("""
+    **Regular Expression Quick Guide**
+
+    - `.` : Matches any single character.
+    - `*` : Matches the preceding character zero or more times.
+    - `+` : Matches the preceding character one or more times.
+    - `^` : Matches the start of a line.
+
+ : Matches the end of a line.
+    - `|` : Acts as an OR operator (e.g., `error|warn`).
+    - `[...]`: Matches any single character within the brackets (e.g., `[aeiou]`).
+    - `(...)`: Groups expressions.
+
+    **Example:** `^ERROR.*database` will find lines starting with "ERROR" that also contain "database".
+    """)
+
+with gr.Blocks(theme=gr.themes.Soft(), css="#log_content .gr-dataframe { font-family: monospace; } .gradio-toast { max-width: 500px !important; }") as demo:
+    files_state = gr.State({})
 
     gr.Markdown("## Log File Viewer")
 
     with gr.Row():
-        file_input = gr.File(label="Upload Log File")
+        file_input = gr.File(label="Upload Log File(s)", file_count="multiple")
+        file_selector = gr.Dropdown(label="Select Log File")
 
     gr.Markdown("### Filters")
 
-    with gr.Row():
+    with gr.Row(elem_id="filter_row"):
         filter_type = gr.Dropdown([
             "Include Text", "Exclude Text", "Include Regex", "Exclude Regex"
         ], label="Filter Type")
-        filter_value = gr.Textbox(label="Filter Value")
+        filter_value = gr.Textbox(label="Filter Value", scale=4)
+        with gr.Column(scale=0, min_width=50):
+            help_button = gr.Button("?", scale=0)
         case_sensitive_checkbox = gr.Checkbox(label="Case Sensitive", value=True)
         with gr.Column(scale=0):
             add_filter_button = gr.Button("Add Filter")
             save_filters_button = gr.Button("Save Filters")
             load_filters_file = gr.UploadButton("Load Filters (.json)", file_types=[".json"])
 
-    
-
     with gr.Row():
         applied_filters_list = gr.Radio(label="Applied Filters", interactive=True)
         remove_filter_button = gr.Button("Remove Selected Filter")
@@ -125,107 +202,109 @@ with gr.Blocks(theme=gr.themes.Soft(), css="#log_content textarea { font-family:
 
     with gr.Row():
         save_filtered_log_button = gr.Button("Save Filtered Log")
-    text_output = gr.Textbox(label="Log Content", lines=20, max_lines=1000, interactive=False, elem_id="log_content")
+    
+    log_table = gr.DataFrame(headers=["File", "Timestamp", "Log Entry"], interactive=False, elem_id="log_content")
 
     # Event Handlers
+    help_button.click(show_regex_help, inputs=None, outputs=None)
+    
+    file_input.upload(
+        add_file,
+        inputs=[file_input, files_state],
+        outputs=[files_state, file_selector, log_table, applied_filters_list]
+    )
+
+    file_selector.change(
+        select_file,
+        inputs=[file_selector, files_state],
+        outputs=[applied_filters_list]
+    ).then(
+        generate_merged_view,
+        inputs=files_state,
+        outputs=log_table
+    )
+
     add_filter_button.click(
         add_filter,
-        inputs=[filters_state, filter_type, filter_value, case_sensitive_checkbox],
-        outputs=[filters_state, filter_value]
+        inputs=[files_state, file_selector, filter_type, filter_value, case_sensitive_checkbox],
+        outputs=[files_state, filter_value]
     ).then(
         update_filter_list,
-        inputs=filters_state,
+        inputs=[file_selector, files_state],
         outputs=applied_filters_list
     ).then(
-        apply_filters,
-        inputs=[file_input, filters_state],
-        outputs=text_output
+        generate_merged_view,
+        inputs=files_state,
+        outputs=log_table
     )
 
     remove_filter_button.click(
         remove_filter,
-        inputs=[filters_state, applied_filters_list],
-        outputs=[filters_state, applied_filters_list]
+        inputs=[files_state, file_selector, applied_filters_list],
+        outputs=[files_state, applied_filters_list]
     ).then(
         update_filter_list,
-        inputs=filters_state,
+        inputs=[file_selector, files_state],
         outputs=applied_filters_list
     ).then(
-        apply_filters,
-        inputs=[file_input, filters_state],
-        outputs=text_output
+        generate_merged_view,
+        inputs=files_state,
+        outputs=log_table
     )
 
     move_up_button.click(
         move_filter_up,
-        inputs=[filters_state, applied_filters_list],
-        outputs=[filters_state, applied_filters_list]
+        inputs=[files_state, file_selector, applied_filters_list],
+        outputs=[files_state, applied_filters_list]
     ).then(
         update_filter_list,
-        inputs=filters_state,
+        inputs=[file_selector, files_state],
         outputs=applied_filters_list
     ).then(
-        apply_filters,
-        inputs=[file_input, filters_state],
-        outputs=text_output
+        generate_merged_view,
+        inputs=files_state,
+        outputs=log_table
     )
 
     move_down_button.click(
         move_filter_down,
-        inputs=[filters_state, applied_filters_list],
-        outputs=[filters_state, applied_filters_list]
+        inputs=[files_state, file_selector, applied_filters_list],
+        outputs=[files_state, applied_filters_list]
     ).then(
         update_filter_list,
-        inputs=filters_state,
+        inputs=[file_selector, files_state],
         outputs=applied_filters_list
     ).then(
-        apply_filters,
-        inputs=[file_input, filters_state],
-        outputs=text_output
+        generate_merged_view,
+        inputs=files_state,
+        outputs=log_table
     )
 
     save_filters_button.click(
         save_filters,
-        inputs=filters_state,
+        inputs=[file_selector, files_state],
         outputs=gr.File(label="Download Filter File")
     )
 
     load_filters_file.upload(
         load_filters,
-        inputs=load_filters_file,
-        outputs=filters_state
+        inputs=[file_selector, files_state, load_filters_file],
+        outputs=files_state
     ).then(
         update_filter_list,
-        inputs=filters_state,
+        inputs=[file_selector, files_state],
         outputs=applied_filters_list
     ).then(
-        apply_filters,
-        inputs=[file_input, filters_state],
-        outputs=text_output
-    )
-
-    file_input.upload(
-        apply_filters,
-        inputs=[file_input, filters_state],
-        outputs=text_output
+        generate_merged_view,
+        inputs=files_state,
+        outputs=log_table
     )
 
     save_filtered_log_button.click(
         save_filtered_log,
-        inputs=text_output,
+        inputs=log_table,
         outputs=gr.File(label="Download Filtered Log")
     )
 
-from fastapi import FastAPI
-
-app = FastAPI()
-app = gr.mount_gradio_app(app, demo, path="/", root_path=os.environ.get("GRADIO_ROOT_PATH", ""))
-
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        app,
-        host="0.0.0.0",
-        port=7860,
-        root_path=os.environ.get("GRADIO_ROOT_PATH", "")
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860)

logviewer/timestamp_utils.py

@@ -4,26 +4,24 @@ import re
 def parse_timestamp(log_line: str) -> datetime.datetime | None:
     """
     Attempts to parse a timestamp from the beginning of a log line.
-    This is a placeholder and should be extended to handle various timestamp formats.
+    This function supports multiple timestamp formats.
     """
-    # Example: YYYY-MM-DD HH:MM:SS.milliseconds or YYYY-MM-DDTHH:MM:SS,SSS
-    # This regex is a starting point and might need to be adjusted for specific log formats.
+    # Format 1: YYYY-MM-DD HH:MM:SS.milliseconds or YYYY-MM-DDTHH:MM:SS,SSS
     match = re.match(r'^(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[.,]\d{3})', log_line)
     if match:
         try:
-            # Try parsing with milliseconds
             return datetime.datetime.strptime(match.group(1).replace('T', ' ').replace(',', '.'), '%Y-%m-%d %H:%M:%S.%f')
         except ValueError:
             pass
-    
-    # Add more parsing attempts for other common formats here
-    # Example: "MMM DD HH:MM:SS" (e.g., "Jun 28 10:30:00")
+
+    # Format 2: "MMM DD HH:MM:SS" (e.g., "Jun 29 14:22:27")
     match = re.match(r'^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}', log_line)
     if match:
         try:
-            # For this format, we might need to assume the current year or pass it in
-            # For simplicity, let's just return None for now if it's not a full datetime
-            pass
+            # This format doesn't have a year, so we assume the current year.
+            current_year = datetime.datetime.now().year
+            timestamp_str = f"{current_year} {match.group(0)}"
+            return datetime.datetime.strptime(timestamp_str, '%Y %b %d %H:%M:%S')
         except ValueError:
             pass
 

requirements.txt

@@ -1,3 +1,4 @@
 gradio
 uvicorn
-requests
+requests
+pandas