logtap 0.2.0__py3-none-any.whl

logtap/core/search.py

@@ -0,0 +1,142 @@
+"""
+Search and filtering functionality for logtap.
+
+Provides substring, regex-based, and severity-based filtering of log lines.
+"""
+
+import re
+from typing import List, Optional, Set
+
+from logtap.core.parsers.base import LogLevel, ParsedLogEntry
+
+
+def filter_lines(
+    lines: List[str],
+    term: Optional[str] = None,
+    regex: Optional[str] = None,
+    case_sensitive: bool = True,
+) -> List[str]:
+    """
+    Filter lines by substring or regex pattern.
+
+    Args:
+        lines: List of log lines to filter.
+        term: Substring to search for. If provided, only lines containing
+              this term will be returned.
+        regex: Regular expression pattern to match. If provided, only lines
+               matching this pattern will be returned. Takes precedence over term.
+        case_sensitive: Whether the search should be case-sensitive.
+                       Defaults to True.
+
+    Returns:
+        Filtered list of lines matching the criteria.
+    """
+    if not term and not regex:
+        return lines
+
+    if regex:
+        flags = 0 if case_sensitive else re.IGNORECASE
+        try:
+            pattern = re.compile(regex, flags)
+            return [line for line in lines if pattern.search(line)]
+        except re.error:
+            # Invalid regex, return empty list
+            return []
+
+    if term:
+        if case_sensitive:
+            return [line for line in lines if term in line]
+        return [line for line in lines if term.lower() in line.lower()]
+
+    return lines
+
+
+def filter_by_level(
+    entries: List[ParsedLogEntry],
+    min_level: Optional[LogLevel] = None,
+    levels: Optional[List[LogLevel]] = None,
+) -> List[ParsedLogEntry]:
+    """
+    Filter parsed log entries by severity level.
+
+    Args:
+        entries: List of ParsedLogEntry objects to filter.
+        min_level: Minimum severity level to include. Entries at this level
+                  or more severe will be included.
+        levels: Specific levels to include. If provided, only entries with
+               these exact levels will be returned.
+
+    Returns:
+        Filtered list of ParsedLogEntry objects.
+
+    Example:
+        # Get only ERROR and more severe
+        filter_by_level(entries, min_level=LogLevel.ERROR)
+
+        # Get only WARNING and ERROR
+        filter_by_level(entries, levels=[LogLevel.WARNING, LogLevel.ERROR])
+    """
+    if not min_level and not levels:
+        return entries
+
+    if levels:
+        level_set: Set[LogLevel] = set(levels)
+        return [e for e in entries if e.level in level_set]
+
+    if min_level:
+        min_severity = min_level.severity
+        return [
+            e for e in entries
+            if e.level is not None and e.level.severity <= min_severity
+        ]
+
+    return entries
+
+
+def filter_entries(
+    entries: List[ParsedLogEntry],
+    term: Optional[str] = None,
+    regex: Optional[str] = None,
+    min_level: Optional[LogLevel] = None,
+    levels: Optional[List[LogLevel]] = None,
+    case_sensitive: bool = True,
+) -> List[ParsedLogEntry]:
+    """
+    Filter parsed log entries by multiple criteria.
+
+    Combines text search and level filtering.
+
+    Args:
+        entries: List of ParsedLogEntry objects to filter.
+        term: Substring to search for in the message.
+        regex: Regex pattern to match against the message.
+        min_level: Minimum severity level to include.
+        levels: Specific levels to include.
+        case_sensitive: Whether text search is case-sensitive.
+
+    Returns:
+        Filtered list of ParsedLogEntry objects matching all criteria.
+    """
+    result = entries
+
+    # Apply level filter first (usually more restrictive)
+    if min_level or levels:
+        result = filter_by_level(result, min_level=min_level, levels=levels)
+
+    # Apply text filter
+    if term or regex:
+        if regex:
+            flags = 0 if case_sensitive else re.IGNORECASE
+            try:
+                pattern = re.compile(regex, flags)
+                result = [e for e in result if pattern.search(e.message)]
+            except re.error:
+                result = []
+        elif term:
+            if case_sensitive:
+                result = [e for e in result if term in e.message]
+            else:
+                term_lower = term.lower()
+                result = [e for e in result if term_lower in e.message.lower()]
+
+    return result

logtap/core/validation.py

@@ -0,0 +1,52 @@
+"""
+Input validation functions for logtap.
+
+These functions validate user input to prevent security issues
+like path traversal attacks and DoS via overly large inputs.
+"""
+
+
+def is_filename_valid(filename: str) -> bool:
+    """
+    Validates a filename for path traversal and absolute paths.
+
+    The filename is considered valid if it does not contain any ".."
+    (used for path traversal) and does not start with "/" (indicating an absolute path).
+
+    Args:
+        filename: The filename to be checked.
+
+    Returns:
+        True if filename is valid, False otherwise.
+    """
+    return ".." not in filename and not filename.startswith("/")
+
+
+def is_search_term_valid(search_term: str) -> bool:
+    """
+    Validates a search term based on its length.
+
+    The search term is considered valid if its length is less than or equal to 100.
+
+    Args:
+        search_term: The search term to be checked.
+
+    Returns:
+        True if search term is valid, False otherwise.
+    """
+    return len(search_term) <= 100
+
+
+def is_limit_valid(limit: int) -> bool:
+    """
+    Validates a limit for the number of lines to return.
+
+    The limit is considered valid if it's within the range 1 to 1000, inclusive.
+
+    Args:
+        limit: The limit to be checked.
+
+    Returns:
+        True if limit is valid, False otherwise.
+    """
+    return 1 <= limit <= 1000

logtap/models/__init__.py

@@ -0,0 +1,11 @@
+"""Pydantic models for logtap API requests and responses."""
+
+from logtap.models.config import Settings
+from logtap.models.responses import ErrorResponse, FileListResponse, LogResponse
+
+__all__ = [
+    "LogResponse",
+    "ErrorResponse",
+    "FileListResponse",
+    "Settings",
+]

logtap/models/config.py

@@ -0,0 +1,39 @@
+"""Configuration settings for logtap."""
+
+from typing import Optional
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """
+    Application settings loaded from environment variables.
+
+    Environment variables are prefixed with LOGTAP_ (e.g., LOGTAP_API_KEY).
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="LOGTAP_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # Server settings
+    host: str = "0.0.0.0"
+    port: int = 8000
+
+    # Log directory configuration
+    log_directory: str = "/var/log"
+    testing: bool = False
+
+    # Authentication
+    api_key: Optional[str] = None
+
+    # Query defaults
+    default_limit: int = 50
+    max_limit: int = 1000
+
+    def get_log_directory(self) -> str:
+        """Get the log directory. Uses log_directory setting directly."""
+        return self.log_directory

logtap/models/responses.py

@@ -0,0 +1,65 @@
+"""Response models for logtap API."""
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class LogResponse(BaseModel):
+    """Response model for log queries."""
+
+    lines: List[str] = Field(description="Log lines matching the query")
+    count: int = Field(description="Number of lines returned")
+    filename: str = Field(description="Name of the log file queried")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "lines": [
+                    "Jan  8 10:23:45 server sshd[1234]: Accepted publickey",
+                    "Jan  8 10:23:46 server systemd[1]: Started session",
+                ],
+                "count": 2,
+                "filename": "syslog",
+            }
+        }
+    }
+
+
+class ErrorResponse(BaseModel):
+    """Response model for errors."""
+
+    error: str = Field(description="Error message")
+    detail: Optional[str] = Field(default=None, description="Additional error details")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "error": "File not found",
+                "detail": "/var/log/nonexistent does not exist",
+            }
+        }
+    }
+
+
+class FileListResponse(BaseModel):
+    """Response model for listing available log files."""
+
+    files: List[str] = Field(description="List of available log files")
+    directory: str = Field(description="Log directory path")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "files": ["syslog", "auth.log", "kern.log", "dpkg.log"],
+                "directory": "/var/log",
+            }
+        }
+    }
+
+
+class HealthResponse(BaseModel):
+    """Response model for health check."""
+
+    status: str = Field(default="healthy", description="Service status")
+    version: str = Field(description="logtap version")

logtap-0.2.0.dist-info/METADATA

@@ -0,0 +1,317 @@
+Metadata-Version: 2.4
+Name: logtap
+Version: 0.2.0
+Summary: A CLI-first log access tool for Unix systems. Remote log file access without SSH.
+License: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: logs,monitoring,cli,devops,sysadmin
+Author: cainky
+Author-email: kylecain.me@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Requires-Dist: aiofiles (>=23.2.1)
+Requires-Dist: fastapi (>=0.109.0)
+Requires-Dist: httpx (>=0.26.0)
+Requires-Dist: pydantic (>=2.5.0)
+Requires-Dist: pydantic-settings (>=2.1.0)
+Requires-Dist: python-dotenv (>=1.0.1)
+Requires-Dist: rich (>=13.7.0)
+Requires-Dist: typer[all] (>=0.9.0)
+Requires-Dist: uvicorn[standard] (>=0.27.0)
+Requires-Dist: websockets (>=12.0)
+Project-URL: Homepage, https://github.com/cainky/logtap
+Project-URL: Repository, https://github.com/cainky/logtap
+Description-Content-Type: text/markdown
+
+# logtap
+
+[![PyPI version](https://badge.fury.io/py/logtap.svg)](https://badge.fury.io/py/logtap)
+[![Tests](https://github.com/cainky/logtap/actions/workflows/tests.yml/badge.svg)](https://github.com/cainky/logtap/actions/workflows/tests.yml)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+**A CLI-first log access tool for Unix systems. Remote log file access without SSH.**
+
+> The simplest way to access log files remotely. No database. No complex setup.
+
+## Features
+
+- **Remote Log Access** - Query log files via REST API without SSH
+- **Beautiful CLI** - Colored output with rich formatting
+- **Regex Search** - Powerful filtering with regex patterns
+- **Real-time Streaming** - Follow logs like `tail -f` (WebSocket)
+- **Lightweight** - No database required, minimal dependencies
+- **Secure** - Optional API key authentication
+- **Docker Ready** - One-command deployment
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install logtap
+```
+
+Or with Docker:
+
+```bash
+docker pull cainky/logtap
+```
+
+### Start the Server
+
+On the machine with log files:
+
+```bash
+logtap serve
+```
+
+With authentication:
+
+```bash
+logtap serve --api-key your-secret-key
+```
+
+### Query Logs
+
+From anywhere:
+
+```bash
+# Basic query
+logtap query syslog
+
+# Search for errors
+logtap query syslog --term "error"
+
+# Regex search
+logtap query auth.log --regex "Failed password.*root"
+
+# Last 100 lines
+logtap query syslog --limit 100
+
+# From a remote server
+logtap query syslog --server http://myserver:8000 --api-key secret
+```
+
+### List Available Files
+
+```bash
+logtap files
+```
+
+### Real-time Streaming
+
+```bash
+logtap tail syslog --follow
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `logtap serve` | Start the API server |
+| `logtap query <file>` | Query log files |
+| `logtap tail <file>` | Tail logs (with `--follow` for streaming) |
+| `logtap files` | List available log files |
+
+### Common Options
+
+```bash
+# Server options
+logtap serve --host 0.0.0.0 --port 8000
+logtap serve --api-key mysecret --log-dir /var/log
+
+# Client options
+logtap query syslog --server http://host:8000 --api-key mysecret
+logtap query syslog --term "error" --limit 50
+logtap query syslog --regex "pattern" --ignore-case
+logtap query syslog --output json  # json, plain, pretty
+```
+
+## API Reference
+
+### GET /logs
+
+Query log file contents.
+
+**Parameters:**
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `filename` | string | `syslog` | Log file name |
+| `term` | string | - | Substring to search for |
+| `regex` | string | - | Regex pattern to match |
+| `limit` | int | `50` | Number of lines (1-1000) |
+| `case_sensitive` | bool | `true` | Case-sensitive search |
+
+**Example:**
+```bash
+curl "http://localhost:8000/logs?filename=syslog&term=error&limit=10"
+```
+
+**Response:**
+```json
+{
+  "lines": ["Jan 8 10:23:45 server error: connection failed", "..."],
+  "count": 10,
+  "filename": "syslog"
+}
+```
+
+### GET /files
+
+List available log files.
+
+```bash
+curl "http://localhost:8000/files"
+```
+
+### GET /health
+
+Health check endpoint.
+
+```bash
+curl "http://localhost:8000/health"
+```
+
+### Authentication
+
+If `LOGTAP_API_KEY` is set, all requests require the `X-API-Key` header:
+
+```bash
+curl -H "X-API-Key: your-secret" "http://localhost:8000/logs"
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `LOGTAP_HOST` | `0.0.0.0` | Server bind host |
+| `LOGTAP_PORT` | `8000` | Server bind port |
+| `LOGTAP_LOG_DIRECTORY` | `/var/log` | Log files directory |
+| `LOGTAP_API_KEY` | - | API key (optional) |
+
+### Using .env File
+
+Create a `.env` file:
+
+```env
+LOGTAP_LOG_DIRECTORY=/var/log
+LOGTAP_API_KEY=your-secret-key
+```
+
+## Docker Deployment
+
+### Using Docker Compose
+
+```yaml
+version: "3.8"
+
+services:
+  logtap:
+    image: cainky/logtap
+    ports:
+      - "8000:8000"
+    volumes:
+      - /var/log:/var/log:ro
+    environment:
+      - LOGTAP_API_KEY=your-secret-key
+```
+
+```bash
+docker-compose up -d
+```
+
+### Using Docker Directly
+
+```bash
+docker run -d \
+  -p 8000:8000 \
+  -v /var/log:/var/log:ro \
+  -e LOGTAP_API_KEY=your-secret \
+  cainky/logtap
+```
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/cainky/logtap.git
+cd logtap
+
+# Install dependencies
+poetry install
+
+# Run tests
+poetry run pytest
+
+# Run the server in development mode
+poetry run logtap serve --reload
+```
+
+### Project Structure
+
+```
+logtap/
+├── src/logtap/
+│   ├── api/          # FastAPI server
+│   ├── cli/          # Typer CLI commands
+│   ├── core/         # Core business logic
+│   └── models/       # Pydantic models
+├── tests/
+│   ├── unit/         # Unit tests
+│   └── integration/  # API tests
+├── Dockerfile
+└── docker-compose.yml
+```
+
+### Running Tests
+
+```bash
+# All tests
+poetry run pytest
+
+# With coverage
+poetry run pytest --cov=logtap
+
+# Specific test file
+poetry run pytest tests/unit/test_reader.py
+```
+
+## Security Considerations
+
+- **Path Traversal Protection**: Filenames are validated to prevent `../` attacks
+- **Input Validation**: Search terms limited to 100 chars, limits capped at 1000
+- **Read-Only**: Log directory is mounted read-only in Docker
+- **API Authentication**: Optional API key for production use
+
+## License
+
+GPL v3 License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue to discuss potential changes before submitting a pull request.
+
+## Author
+
+Kyle Cain - [@cainky](https://github.com/cainky)
+

logtap-0.2.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+logtap/__init__.py,sha256=AZzOTH4EFgrz3x5g_i6HELBi5Cg8pOXqCWbJbCWnl2A,179
+logtap/__main__.py,sha256=vqJPz3Zf-ICn_4P3B1o7U4NxcCo0qWgfAGEE_j13t-c,138
+logtap/api/__init__.py,sha256=80bP-eIxtAzidgv5nzcfyCEdl8EI2QjVY_eyxjvvhA0,98
+logtap/api/app.py,sha256=BBphxLKvk7yIiLyQ3tdiagqtjc7xFixd_FUzNFjlC0c,1176
+logtap/api/dependencies.py,sha256=1cx1qrp0O6v1fHXA2JdEhC8P4caG2oUSCfMk2-8zmGs,1620
+logtap/api/routes/__init__.py,sha256=XYvFyTP4zKywRZH0v97k0EZCYgxdL2PSUaNet20znPE,29
+logtap/api/routes/files.py,sha256=bqZYrX6jrF5-7GzBpUIXXoPVdxUwm6o0LTcJBLtaJUE,991
+logtap/api/routes/health.py,sha256=Ak-z2ChqZZ7FgHdu1JDo3v5aDBPR3VIICyXTLDBf75E,462
+logtap/api/routes/logs.py,sha256=rIc9pkn7YtVjf0mAluJztVocJ_P9THR280KTEDN1zqE,8431
+logtap/api/routes/parsed.py,sha256=XVvkKBE_hQvfJyrDBBPR_PpVxvof-y4B77xKe9Rr0Qk,3367
+logtap/cli/__init__.py,sha256=U4zaUJ1rm0qHXqeArpzC45S5N-5SBdd8K6foe513msk,31
+logtap/cli/commands/__init__.py,sha256=U4zaUJ1rm0qHXqeArpzC45S5N-5SBdd8K6foe513msk,31
+logtap/cli/commands/files.py,sha256=WFr8kA0SdgQHz3ZyONTaljxHMcD-nQlndp3UIOwZATc,2455
+logtap/cli/commands/query.py,sha256=uD9nH5E-7EqJryLf3hHkDbJSQo4kWFGmzzHgTfAKFwk,3418
+logtap/cli/commands/serve.py,sha256=9OvfII21q6cel3zZfSsAsiERKwKFt0ZFTXmUd2Psthg,1910
+logtap/cli/commands/tail.py,sha256=dwPRXub1dcRwKulDt_qNa2waQm1YPOxIg0QokAK6Gyw,3648
+logtap/cli/main.py,sha256=fWSuQdin9G-RC7Oqzesfp93WZI1-v7227P-WWTsxtIQ,1045
+logtap/core/__init__.py,sha256=tsoL0XuDrPd5xHEu975WqFHoA7EQgloxrum7CjsWHuk,450
+logtap/core/parsers/__init__.py,sha256=5f3hFxf_DgNScRDchRT8ocFVgi7Md4xuMN-ShvlssBo,575
+logtap/core/parsers/apache.py,sha256=JjuQ4v-b7HJvTCcjbOMgv5_dSdiNVPX_EUyplc3f5Qw,5332
+logtap/core/parsers/auto.py,sha256=OLLuX7XIxS0Upnv9FQ-_B0sGAyZmfNxjnMDGdZtUIO4,3565
+logtap/core/parsers/base.py,sha256=HK886mB2mOuRwsVit_U8UgSfrrQOYwMt_XQm-bgso40,4829
+logtap/core/parsers/json_parser.py,sha256=_3uMGT0EW0wwKzXk1Uc9A7iNvey0Ijqr0uRnJuU1_XM,3728
+logtap/core/parsers/nginx.py,sha256=j_oILELOM0azDPLc41wXrLu5o_LhnPs9fT0_iaOqqAQ,3526
+logtap/core/parsers/syslog.py,sha256=gBNQ39QXsigOpfnq3cEdmvFa8NLp_wmiSMDlTt0SIbs,2430
+logtap/core/reader.py,sha256=YY3wyV9NvYiskTh2nrl1tZAZNY11fr33vo85OhW1qHc,5247
+logtap/core/search.py,sha256=-P2KLkjTWANyLQhdxqZc3I-0UpbhWjQQK_yHHxwYJaA,4350
+logtap/core/validation.py,sha256=Nk86jHqEfI4H96fk-1rjbC5sBwfzls43hyOhnRV6rxI,1359
+logtap/models/__init__.py,sha256=tce3Q0QjPhnlAYG8IcwxPedyh1ibBlKIF3CjXe5wwgo,280
+logtap/models/config.py,sha256=8x6OR_y2ZB8SSoQWQGwDB7DXH30UyMNXUcRWOctjUn8,927
+logtap/models/responses.py,sha256=45J-Xw1Gb35uP5188wxy2QZlyy3Fh18fpAFizZnpi3A,1850
+logtap-0.2.0.dist-info/METADATA,sha256=RUTmgmA8QlKTgWT0ch5QPQ21ltJIay2j5SL44_qGBZc,7372
+logtap-0.2.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+logtap-0.2.0.dist-info/entry_points.txt,sha256=NsN54PsyqB2TA7b8W9-nH4_CNl2_biG4i4FhOQAU9rQ,46
+logtap-0.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+logtap-0.2.0.dist-info/RECORD,,

logtap-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

logtap-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+logtap=logtap.cli.main:app
+