save

.gitignore

@@ -1,2 +1,4 @@
 .DS_Store
 .env
+node_modules/
+__pycache__/

README.md

@@ -1,20 +1,81 @@
----
-title: DataForge
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: CodeAct Agent to process large data set
----
-
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# 🔍 DataForge - AI Assistant with File Analysis
 
+An intelligent AI assistant that combines conversational chat capabilities with advanced file analysis using CodeAct agents. Built with Gradio, LangChain, and LangGraph.
+
+## ✨ Features
+
+### 💬 Chat Assistant
+- Interactive AI chatbot powered by OpenAI GPT-4
+- Customizable system messages and parameters
+- Real-time streaming responses
+- Conversation history support
+
+### 📁 File Analysis
+- **Upload & Analyze**: Support for various file formats (.txt, .log, .csv, .json, .xml, .py, .js, .html, .md)
+- **Smart Analysis**: Automatic file type detection and tailored analysis
+- **CodeAct Integration**: Uses LangGraph CodeAct agents for deep file analysis
+- **Comprehensive Insights**: Provides security analysis, performance insights, error detection, and statistical summaries
+
+## 🚀 Getting Started
+
+### Prerequisites
+- Python 3.11+
+- OpenAI API Key
+
+### Installation
+
+1. Create and activate virtual environment:
+```bash
 uv venv --python 3.11 
-source .venv/bin/activate
-deactivate
-uv pip freeze > requirements.txt
-uv pip install -r requirements.txt
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+2. Install dependencies:
+```bash
+uv pip install -r requirements.txt
+```
+
+3. Set up environment variables:
+```bash
+# Create .env file and add your OpenAI API key
+OPENAI_API_KEY=your_openai_api_key_here
+```
+
+### Running the Application
+```bash
+python app.py
+```
+
+The application will start a Gradio interface accessible at `http://localhost:7860`
+
+## 📊 File Analysis Capabilities
+
+### Supported File Types
+- **Log files** (.log, .txt): Security analysis, performance bottlenecks, error detection
+- **Data files** (.csv, .json): Data quality assessment, statistical analysis
+- **Code files** (.py, .js, .html): Structure analysis, best practices review
+- **Configuration files** (.xml, .md): Content analysis and recommendations
+
+### Analysis Features
+- **Security Analysis**: Detect threats, suspicious activities, and security patterns
+- **Performance Insights**: Identify bottlenecks and performance issues
+- **Error Analysis**: Categorize and analyze errors and warnings
+- **Statistical Summary**: Basic statistics and data distribution
+- **Pattern Recognition**: Identify trends and anomalies
+- **Actionable Recommendations**: Suggested actions based on analysis
+
+## 🧪 Testing
+
+A sample server log file (`sample_server.log`) is included for testing the file analysis functionality.
+
+## 🛠️ Technical Architecture
+
+- **Frontend**: Gradio for web interface
+- **Backend**: LangChain for AI orchestration
+- **Analysis Engine**: LangGraph CodeAct agents with PyodideSandbox
+- **File Processing**: Custom FileInjectedPyodideSandbox for secure file analysis
+- **Model**: OpenAI GPT-4 for both chat and analysis
+
+## 📄 License
+
+MIT License

agent.py

@@ -2,6 +2,8 @@ import asyncio
 import inspect
 import uuid
 import os
+import tempfile
+import shutil
 from typing import Any
 
 from langchain.chat_models import init_chat_model
@@ -15,11 +17,17 @@ load_dotenv(find_dotenv())
 class FileInjectedPyodideSandbox(PyodideSandbox):
     """Custom PyodideSandbox that can inject files into the virtual filesystem."""
     
-    def __init__(self, file_path: str = None, virtual_path: str = "/server.log", **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, file_path: str = None, virtual_path: str = "/uploaded_file.log", sessions_dir: str = None, **kwargs):
+        # Create a temporary sessions directory if none provided
+        if sessions_dir is None:
+            sessions_dir = tempfile.mkdtemp(prefix="pyodide_sessions_")
+        
+        super().__init__(sessions_dir=sessions_dir, **kwargs)
         self.file_path = file_path
         self.virtual_path = virtual_path
         self._file_injected = False
+        self._temp_sessions_dir = sessions_dir
+        self._created_temp_dir = sessions_dir is None
     
     async def execute(self, code: str, **kwargs):
         # If we have a file to inject, prepend the injection code to the user code
@@ -40,7 +48,7 @@ class FileInjectedPyodideSandbox(PyodideSandbox):
 import base64
 import os
 
-# Decode the log file content from base64
+# Decode the file content from base64
 encoded_content = """{encoded_content}"""
 file_content = base64.b64decode(encoded_content).decode('utf-8')
 
@@ -54,7 +62,7 @@ total_lines = len(log_lines)
 
 print(f"[INJECTION] Successfully created {self.virtual_path} with {{len(file_content)}} characters")
 print(f"[INJECTION] File content available as 'file_content' variable ({{len(file_content)}} chars)")
-print(f"[INJECTION] Log lines available as 'log_lines' variable ({{total_lines}} lines)")
+print(f"[INJECTION] Lines available as 'log_lines' variable ({{total_lines}} lines)")
 
 # Verify injection worked
 if os.path.exists("{self.virtual_path}"):
@@ -64,8 +72,8 @@ else:
 
 # Variables now available for analysis:
 # - file_content: raw file content as string
-# - log_lines: list of individual log lines  
-# - total_lines: number of lines in the log
+# - log_lines: list of individual lines  
+# - total_lines: number of lines in the file
 # - File also available at: {self.virtual_path}
 
 # End of injection code
@@ -82,6 +90,19 @@ else:
                 return await super().execute(code, **kwargs)
         else:
             return await super().execute(code, **kwargs)
+    
+    def cleanup(self):
+        """Clean up temporary directories if we created them."""
+        if self._created_temp_dir and self._temp_sessions_dir and os.path.exists(self._temp_sessions_dir):
+            try:
+                shutil.rmtree(self._temp_sessions_dir)
+                print(f"Cleaned up temporary sessions directory: {self._temp_sessions_dir}")
+            except Exception as e:
+                print(f"Warning: Could not clean up temporary directory {self._temp_sessions_dir}: {e}")
+    
+    def __del__(self):
+        """Cleanup when object is destroyed."""
+        self.cleanup()
 
 def create_pyodide_eval_fn(sandbox: PyodideSandbox) -> EvalCoroutine:
     """Create an eval_fn that uses PyodideSandbox.
@@ -160,68 +181,178 @@ def read_file(file_path: str) -> str:
         return file.read()
 
 
-tools = []
-
-model = init_chat_model("gpt-4.1-2025-04-14", model_provider="openai")
-
-# Specify the log file path
-log_file_path = "/Users/hw/Desktop/codeact_agent/server.log"
-
-# Create our custom sandbox with file injection capability
-sandbox = FileInjectedPyodideSandbox(
-    file_path=log_file_path,
-    virtual_path="/server.log",
-    allow_net=True
-)
-
-eval_fn = create_pyodide_eval_fn(sandbox)
-code_act = create_codeact(model, tools, eval_fn)
-agent = code_act.compile()
-
-query = """
-Analyze these server logs and provide:
-1. Security threat summary - identify attack patterns, suspicious IPs, and breach attempts
-2. Performance bottlenecks - find slow endpoints, database issues, and resource constraints  
-3. User behavior analysis - login patterns, most accessed endpoints, session durations
-4. System health report - error rates, critical alerts, and infrastructure issues
-5. Recommended actions based on the analysis
-
-LOG FORMAT INFORMATION:
-The server logs follow this format:
-YYYY-MM-DD HH:MM:SS [LEVEL] event_type: key=value, key=value, ...
+def create_analysis_agent(file_path: str, model=None, virtual_path: str = "/uploaded_file.log", sessions_dir: str = None):
+    """
+    Create a CodeAct agent configured for file analysis.
+    
+    Args:
+        file_path: Path to the file to analyze
+        model: Language model to use (if None, will initialize default)
+        virtual_path: Virtual path where file will be mounted in sandbox
+        sessions_dir: Directory for PyodideSandbox sessions (if None, will create temp dir)
+    
+    Returns:
+        Compiled CodeAct agent ready for analysis
+    """
+    if model is None:
+        model = init_chat_model("gpt-4.1-2025-04-14", model_provider="openai")
+    
+    # Create our custom sandbox with file injection capability
+    sandbox = FileInjectedPyodideSandbox(
+        file_path=file_path,
+        virtual_path=virtual_path,
+        sessions_dir=sessions_dir,
+        allow_net=True
+    )
+    
+    eval_fn = create_pyodide_eval_fn(sandbox)
+    code_act = create_codeact(model, [], eval_fn)
+    return code_act.compile()
 
-Sample log entries:
-- 2024-01-15 08:23:45 [INFO] user_login: user=john_doe, ip=192.168.1.100, success=true
-- 2024-01-15 08:24:12 [INFO] api_request: endpoint=/api/users, method=GET, user=john_doe, response_time=45ms
-- 2024-01-15 08:27:22 [WARN] failed_login: user=admin, ip=203.45.67.89, attempts=3
-- 2024-01-15 08:38:33 [CRITICAL] security_alert: suspicious_activity, ip=185.234.72.19, pattern=sql_injection_attempt
-- 2024-01-15 08:26:01 [ERROR] database_connection: host=db-primary, error=timeout, duration=30s
 
-Key log levels: INFO, WARN, ERROR, CRITICAL
-Key event types: user_login, user_logout, api_request, failed_login, security_alert, database_connection, etc.
+def get_default_analysis_query(file_extension: str = None) -> str:
+    """
+    Get a default analysis query based on file type.
+    
+    Args:
+        file_extension: File extension (e.g., '.log', '.csv', '.txt')
+    
+    Returns:
+        Analysis query string
+    """
+    if file_extension and file_extension.lower() in ['.log', '.txt']:
+        return """
+Analyze this uploaded file and provide comprehensive insights. Follow the example code patterns below for reliable analysis.
+
+ANALYSIS REQUIREMENTS:
+1. **Content Overview** - What type of data/logs this file contains
+2. **Security Analysis** - Identify any security-related events, threats, or suspicious activities
+3. **Performance Insights** - Find bottlenecks, slow operations, or performance issues
+4. **Error Analysis** - Identify and categorize errors, warnings, and critical issues
+5. **Statistical Summary** - Basic statistics (line count, data distribution, time ranges)
+6. **Key Patterns** - Important patterns, trends, or anomalies found
+7. **Recommendations** - Suggested actions based on the analysis
 
 DATA SOURCES AVAILABLE:
-- `file_content`: Raw log content as a string
-- `log_lines`: List of individual log lines 
-- `total_lines`: Number of lines in the log
-- File path: `/server.log` (can be read with open('/server.log', 'r'))
+- `file_content`: Raw file content as a string
+- `log_lines`: List of individual lines 
+- `total_lines`: Number of lines in the file
+- File path: `/uploaded_file.log`
+
+EXAMPLE CODE PATTERNS TO FOLLOW:
+
+Start with basic analysis, then add specific patterns based on your file type:
+
+1. Import required libraries: re, Counter, defaultdict, datetime
+2. Basic file statistics: total_lines, file_content length, sample lines
+3. Pattern analysis using regex for security, performance, errors
+4. Data extraction and frequency analysis
+5. Clear formatted output with sections
+6. Actionable recommendations
+
+Use these code snippets as templates:
+- Counter() for frequency analysis
+- re.search() and re.findall() for pattern matching  
+- enumerate(log_lines, 1) for line-by-line processing
+- defaultdict(list) for grouping findings
+- Clear print statements with section headers
+
+Generate Python code following these patterns. Always include proper error handling, clear output formatting, and actionable insights.
+"""
+    else:
+        return """
+Analyze this uploaded file and provide comprehensive insights. Follow these reliable patterns:
+
+ANALYSIS REQUIREMENTS:
+1. **File Type Analysis** - What type of file this is and its structure
+2. **Content Summary** - Overview of the file contents  
+3. **Key Information** - Important data points or patterns found
+4. **Data Quality** - Assessment of data completeness and consistency
+5. **Statistical Analysis** - Basic statistics and data distribution
+6. **Insights & Findings** - Key takeaways from the analysis
+7. **Recommendations** - Suggested next steps or insights
 
-Generate python code and run it in the sandbox to get the analysis.
+DATA SOURCES AVAILABLE:
+- file_content: Raw file content as a string
+- log_lines: List of individual lines
+- total_lines: Number of lines in the file
+- File path: /uploaded_file.log
+
+RELIABLE CODE PATTERNS:
+1. Start with basic stats: total_lines, len(file_content), file preview
+2. Use Counter() for frequency analysis of patterns
+3. Use re.findall() for extracting structured data like emails, IPs, dates
+4. Analyze line structure and consistency
+5. Calculate data quality metrics
+6. Provide clear sections with === headers ===
+7. End with actionable recommendations
+
+Focus on reliability over complexity. Use simple, proven Python patterns that work consistently.
+
+Generate Python code following these guidelines for robust file analysis.
 """
 
 
-async def run_agent(query: str):
-    # Stream agent outputs
-    async for typ, chunk in agent.astream(
-        {"messages": query},
-        stream_mode=["values", "messages"],
-    ):
-        if typ == "messages":
-            print(chunk[0].content, end="")
-        elif typ == "values":
-            print("\n\n---answer---\n\n", chunk)
+async def run_file_analysis(file_path: str, query: str = None, model=None) -> str:
+    """
+    Run file analysis using CodeAct agent.
+    
+    Args:
+        file_path: Path to the file to analyze
+        query: Analysis query (if None, will use default based on file type)
+        model: Language model to use
+    
+    Returns:
+        Analysis results as string
+    """
+    if not os.path.exists(file_path):
+        return f"❌ File not found: {file_path}"
+    
+    try:
+        # Create the agent
+        agent = create_analysis_agent(file_path, model)
+        
+        # Use default query if none provided
+        if query is None:
+            file_ext = os.path.splitext(file_path)[1]
+            query = get_default_analysis_query(file_ext)
+        
+        # Run the analysis
+        result_parts = []
+        async for typ, chunk in agent.astream(
+            {"messages": query},
+            stream_mode=["values", "messages"],
+        ):
+            if typ == "messages":
+                result_parts.append(chunk[0].content)
+            elif typ == "values":
+                if chunk and "messages" in chunk:
+                    final_message = chunk["messages"][-1]
+                    if hasattr(final_message, 'content'):
+                        result_parts.append(f"\n\n**Final Analysis:**\n{final_message.content}")
+        
+        return "\n".join(result_parts) if result_parts else "Analysis completed but no output generated."
+        
+    except Exception as e:
+        return f"❌ Error analyzing file: {str(e)}"
 
 
+# Example usage and testing
 if __name__ == "__main__":
-    # Run the agent
-    asyncio.run(run_agent(query))
+    # This section is for testing only - remove or comment out in production
+    import sys
+    
+    if len(sys.argv) > 1:
+        test_file_path = sys.argv[1]
+        print(f"Testing with file: {test_file_path}")
+        
+        async def test_analysis():
+            result = await run_file_analysis(test_file_path)
+            print("Analysis Result:")
+            print("=" * 50)
+            print(result)
+        
+        asyncio.run(test_analysis())
+    else:
+        print("Usage: python agent.py <file_path>")
+        print("Or import this module and use the functions directly.")

app.py

@@ -1,11 +1,16 @@
 import os
 import gradio as gr
+import asyncio
+import tempfile
 from dotenv import find_dotenv, load_dotenv
 from langchain.chat_models import init_chat_model
 from langchain.schema import HumanMessage, SystemMessage
 from langgraph.prebuilt import create_react_agent
 from langsmith import traceable
 
+# Import the CodeAct agent functionality
+from agent import FileInjectedPyodideSandbox, create_pyodide_eval_fn, create_codeact
+
 # Load environment variables
 load_dotenv(find_dotenv())
 
@@ -15,9 +20,14 @@ openai_model = init_chat_model(
     api_key=os.getenv("OPENAI_API_KEY"),
 )
 
-# Create the agent (you can add tools here later if needed)
+# Create the basic chat agent
 chat_agent = create_react_agent(openai_model, tools=[])
 
+# Initialize CodeAct model for file analysis
+codeact_model = init_chat_model("gpt-4.1-2025-04-14", model_provider="openai")
+
+# Store uploaded file path globally
+uploaded_file_path = None
 
 @traceable
 def respond(
@@ -54,7 +64,6 @@ def respond(
             if "messages" in chunk and chunk["messages"]:
                 latest_message = chunk["messages"][-1]
                 if hasattr(latest_message, 'content'):
-                    # Extract content from the message
                     current_content = latest_message.content
                     if current_content and len(current_content) > len(response_text):
                         response_text = current_content
@@ -67,26 +76,163 @@ def respond(
     except Exception as e:
         yield f"Error: {str(e)}. Please make sure your OpenAI API key is set correctly."
 
+def handle_file_upload(file):
+    """Handle file upload and store the path globally"""
+    global uploaded_file_path
+    if file is not None:
+        uploaded_file_path = file.name
+        return f"✅ File uploaded successfully: {os.path.basename(file.name)}"
+    else:
+        uploaded_file_path = None
+        return "❌ No file uploaded"
+
+async def analyze_uploaded_file():
+    """Analyze the uploaded file using CodeAct agent"""
+    global uploaded_file_path
+    
+    if not uploaded_file_path or not os.path.exists(uploaded_file_path):
+        return "❌ No file uploaded or file not found. Please upload a file first."
+    
+    try:
+        # Create sandbox with the uploaded file
+        sandbox = FileInjectedPyodideSandbox(
+            file_path=uploaded_file_path,
+            virtual_path="/uploaded_file.log",
+            sessions_dir=None,  # Will create temp directory automatically
+            allow_net=True
+        )
+        
+        eval_fn = create_pyodide_eval_fn(sandbox)
+        code_act = create_codeact(codeact_model, [], eval_fn)
+        agent = code_act.compile()
+        
+        # Create analysis query based on file type
+        file_ext = os.path.splitext(uploaded_file_path)[1].lower()
+        
+        if file_ext in ['.log', '.txt']:
+            query = """
+Analyze this uploaded file and provide:
+1. **Content Overview** - What type of data/logs this file contains
+2. **Key Patterns** - Important patterns, trends, or anomalies found
+3. **Statistical Summary** - Basic statistics (line count, data distribution, etc.)
+4. **Insights & Findings** - Key takeaways from the analysis
+5. **Recommendations** - Suggested actions based on the analysis
+
+DATA SOURCES AVAILABLE:
+- `file_content`: Raw file content as a string
+- `log_lines`: List of individual lines 
+- `total_lines`: Number of lines in the file
+- File path: `/uploaded_file.log` (can be read with open('/uploaded_file.log', 'r'))
 
+Generate Python code to analyze the file and provide comprehensive insights.
 """
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+        else:
+            query = f"""
+Analyze this uploaded {file_ext} file and provide:
+1. **File Type Analysis** - What type of file this is and its structure
+2. **Content Summary** - Overview of the file contents
+3. **Key Information** - Important data points or patterns found
+4. **Statistical Analysis** - Basic statistics and data distribution
+5. **Recommendations** - Suggested next steps or insights
+
+DATA SOURCES AVAILABLE:
+- `file_content`: Raw file content as a string
+- `log_lines`: List of individual lines
+- `total_lines`: Number of lines in the file
+- File path: `/uploaded_file.log`
+
+Generate Python code to analyze this file and provide comprehensive insights.
 """
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a helpful AI assistant. Be friendly, informative, and concise in your responses.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+        
+        # Run the analysis
+        result_parts = []
+        async for typ, chunk in agent.astream(
+            {"messages": query},
+            stream_mode=["values", "messages"],
+        ):
+            if typ == "messages":
+                result_parts.append(chunk[0].content)
+            elif typ == "values":
+                if chunk and "messages" in chunk:
+                    final_message = chunk["messages"][-1]
+                    if hasattr(final_message, 'content'):
+                        result_parts.append(f"\n\n**Final Analysis:**\n{final_message.content}")
+        
+        return "\n".join(result_parts) if result_parts else "Analysis completed but no output generated."
+        
+    except Exception as e:
+        return f"❌ Error analyzing file: {str(e)}"
 
+def run_file_analysis():
+    """Wrapper to run async file analysis in sync context"""
+    return asyncio.run(analyze_uploaded_file())
+
+# Create the Gradio interface
+with gr.Blocks(title="DataForge - AI Assistant with File Analysis") as demo:
+    gr.Markdown("# 🔍 DataForge - AI Assistant with File Analysis")
+    gr.Markdown("Upload files for analysis or chat with the AI assistant.")
+    
+    with gr.Tab("💬 Chat Assistant"):
+        chat_interface = gr.ChatInterface(
+            respond,
+            additional_inputs=[
+                gr.Textbox(
+                    value="You are a helpful AI assistant. Be friendly, informative, and concise in your responses.", 
+                    label="System message"
+                ),
+                gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+                gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+                gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.95,
+                    step=0.05,
+                    label="Top-p (nucleus sampling)",
+                ),
+            ],
+            title="Chat with AI Assistant",
+            description="Ask questions or get help with any topic."
+        )
+    
+    with gr.Tab("📁 File Analysis"):
+        gr.Markdown("## Upload and Analyze Files")
+        gr.Markdown("Upload log files, text files, or other data files for comprehensive AI-powered analysis.")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_upload = gr.File(
+                    label="Upload File for Analysis",
+                    file_types=[".txt", ".log", ".csv", ".json", ".xml", ".py", ".js", ".html", ".md"],
+                    type="filepath"
+                )
+                upload_status = gr.Textbox(
+                    label="Upload Status",
+                    value="No file uploaded",
+                    interactive=False
+                )
+                analyze_btn = gr.Button("🔍 Analyze File", variant="primary", size="lg")
+            
+            with gr.Column(scale=2):
+                analysis_output = gr.Textbox(
+                    label="Analysis Results",
+                    lines=20,
+                    max_lines=30,
+                    placeholder="Upload a file and click 'Analyze File' to see detailed analysis results here...",
+                    interactive=False
+                )
+        
+        # Event handlers
+        file_upload.change(
+            fn=handle_file_upload,
+            inputs=[file_upload],
+            outputs=[upload_status]
+        )
+        
+        analyze_btn.click(
+            fn=run_file_analysis,
+            inputs=[],
+            outputs=[analysis_output]
+        )
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -6,6 +6,7 @@ charset-normalizer
 distro
 dotenv
 e2b-code-interpreter
+gradio
 h11
 httpcore
 httpx

sample_server.log

@@ -0,0 +1,25 @@
+2024-01-15 08:23:45 [INFO] user_login: user=john_doe, ip=192.168.1.100, success=true, session_id=abc123
+2024-01-15 08:24:12 [INFO] api_request: endpoint=/api/users, method=GET, user=john_doe, response_time=45ms, status=200
+2024-01-15 08:24:15 [INFO] api_request: endpoint=/api/dashboard, method=GET, user=john_doe, response_time=120ms, status=200
+2024-01-15 08:25:33 [INFO] user_login: user=alice_smith, ip=192.168.1.101, success=true, session_id=def456
+2024-01-15 08:26:01 [ERROR] database_connection: host=db-primary, error=timeout, duration=30s, query=SELECT * FROM users
+2024-01-15 08:26:45 [INFO] api_request: endpoint=/api/products, method=GET, user=alice_smith, response_time=2300ms, status=200
+2024-01-15 08:27:22 [WARN] failed_login: user=admin, ip=203.45.67.89, attempts=3, reason=invalid_password
+2024-01-15 08:28:11 [INFO] user_logout: user=john_doe, session_duration=4m26s, pages_visited=5
+2024-01-15 08:29:33 [CRITICAL] security_alert: suspicious_activity, ip=185.234.72.19, pattern=sql_injection_attempt, endpoint=/api/users
+2024-01-15 08:30:15 [ERROR] api_request: endpoint=/api/orders, method=POST, user=alice_smith, response_time=timeout, status=500, error=database_unavailable
+2024-01-15 08:31:45 [WARN] rate_limit: ip=203.45.67.89, endpoint=/api/login, requests_per_minute=25, limit=10
+2024-01-15 08:32:12 [INFO] user_login: user=bob_wilson, ip=192.168.1.102, success=true, session_id=ghi789
+2024-01-15 08:33:28 [CRITICAL] security_alert: brute_force_attack, ip=203.45.67.89, attempts=15, duration=5m, blocked=true
+2024-01-15 08:34:55 [INFO] api_request: endpoint=/api/reports, method=GET, user=bob_wilson, response_time=850ms, status=200
+2024-01-15 08:35:21 [ERROR] memory_usage: process=web-server, usage=85%, threshold=80%, action=alert_sent
+2024-01-15 08:36:47 [INFO] backup_completed: database=primary, size=2.3GB, duration=45m, status=success
+2024-01-15 08:37:15 [WARN] disk_space: partition=/data, usage=92%, available=800MB, threshold=90%
+2024-01-15 08:38:33 [CRITICAL] security_alert: suspicious_activity, ip=185.234.72.19, pattern=xss_attempt, endpoint=/api/comments
+2024-01-15 08:39:12 [INFO] user_login: user=carol_davis, ip=192.168.1.103, success=true, session_id=jkl012
+2024-01-15 08:40:28 [ERROR] external_api: service=payment_gateway, endpoint=charge, response_time=timeout, status=503, retry_attempt=3
+2024-01-15 08:41:15 [INFO] api_request: endpoint=/api/analytics, method=GET, user=carol_davis, response_time=1200ms, status=200
+2024-01-15 08:42:33 [WARN] slow_query: query=SELECT * FROM orders WHERE date > '2024-01', duration=5.2s, threshold=2s
+2024-01-15 08:43:47 [INFO] cache_hit: key=user_preferences_john_doe, hit_rate=89%, response_time=5ms
+2024-01-15 08:44:12 [CRITICAL] system_alert: cpu_usage=95%, memory_usage=88%, load_average=4.2, action=scaling_triggered
+2024-01-15 08:45:28 [INFO] user_logout: user=alice_smith, session_duration=19m55s, pages_visited=12