Open-Telemorph-Prime

Philosophy: Simplicity First

Single Binary Deployment

One executable, zero configuration. Download and run immediately without complex setup procedures.

# Download and run in seconds
wget https://github.com/nadx/open-telemorph-prime/releases/latest/download/open-telemorph-prime-linux-amd64
chmod +x open-telemorph-prime-linux-amd64
./open-telemorph-prime-linux-amd64
                        

Minimal Resource Usage

Runs on any modern machine with less than 2GB RAM. Perfect for development environments and small teams.

# Resource requirements
CPU: 1 core minimum
RAM: 512MB minimum
Storage: 1GB for 30 days of data
Startup: <5 seconds
                        

Progressive Complexity

Start simple and scale up when needed. Optional advanced features available through configuration.

# Simple mode (default)
mode: "simple"
storage: "sqlite"

# Advanced mode (optional)
mode: "advanced"
storage: "postgres"
messaging: "kafka"
                        

Simplified Architecture

Unified Service

Everything in a single binary - no microservices complexity.

gRPC/HTTP Receivers (OTLP)
Storage Engine (SQLite/PostgreSQL)
Query Engine (Built-in)
Web UI (Embedded)
REST API Endpoints
Health Checks

Data Flow

Simple, direct data flow without complex message queues or stream processing.

# Simple data flow
Application → OTEL SDK → Direct HTTP/gRPC
                ↓
Unified Service → Parse & Validate → Storage
                ↓
Query Engine → Filter & Aggregate → Web UI/API
                        

Storage Backend

Configurable storage options based on your needs.

SQLite (default) - for single user
PostgreSQL - for multi-user
File-based - for minimal setup

Quick Start (5 minutes)

Option 1: Docker Compose (Recommended)

# Clone the repository
git clone https://github.com/nadx/open-telemorph-prime.git
cd open-telemorph-prime

# Start the service
docker-compose up -d

# Open your browser
open http://localhost:8080
                        

Option 2: Direct Binary

# Download the latest release
wget https://github.com/nadx/open-telemorph-prime/releases/latest/download/open-telemorph-prime-linux-amd64
chmod +x open-telemorph-prime-linux-amd64

# Run
./open-telemorph-prime-linux-amd64

# Open your browser
open http://localhost:8080
                        

Option 3: Build from Source

# Prerequisites: Go 1.24+
git clone https://github.com/nadx/open-telemorph-prime.git
cd open-telemorph-prime

# Install dependencies
go mod tidy

# Build
go build -o open-telemorph-prime .

# Run
./open-telemorph-prime
                        

Key Features

⚡

High Performance

Ingest 1K+ spans/sec, 10K+ metrics/sec with sub-second query latency.

🔧

Easy Integration

Standard OpenTelemetry protocols with minimal configuration required.

📊

Built-in Analytics

PromQL support, log filtering, and trace search capabilities.

🌐

Web UI

Simple, responsive interface for data exploration and visualization.

💾

SQLite Storage

Lightweight, file-based storage with automatic data retention.

🔍

REST API

Query your data programmatically with comprehensive REST endpoints.

Configuration

Simple Configuration

YAML-based configuration with sensible defaults.

# config.yaml
server:
  port: 8080
  environment: "development"

storage:
  type: "sqlite"
  path: "./data/telemorph.db"
  retention_days: 30

ingestion:
  grpc_port: 4317
  http_port: 4318

web:
  enabled: true
  title: "Open-Telemorph-Prime"

logging:
  level: "info"
  format: "json"
                        

Advanced Configuration

Optional advanced features for power users.

# Advanced mode configuration
mode: "advanced"

storage:
  type: "postgres"
  host: "localhost"
  port: 5432
  database: "telemorph"

messaging:
  kafka:
    enabled: true
    brokers: ["localhost:9092"]
    topics:
      metrics: "otel.metrics"
      traces: "otel.traces"
      logs: "otel.logs"

alerting:
  enabled: true
  rules:
    - name: "High Error Rate"
      query: "rate(http_requests_total{status=~'5..'}[5m]) > 0.05"
      duration: "2m"
                        

API Endpoints

Health & Status

GET  /health                    # Health check
GET  /ready                     # Readiness check
                        

Data Retrieval

GET  /api/v1/metrics            # List metrics
GET  /api/v1/traces             # List traces
GET  /api/v1/logs               # List logs
GET  /api/v1/services           # List services
POST /api/v1/query              # Generic query endpoint
                        

Web Interface

GET  /                          # Home page
GET  /dashboard                 # Dashboard
GET  /metrics                   # Metrics explorer
GET  /traces                    # Traces explorer
GET  /logs                      # Logs viewer
                        

Sending Data

HTTP Endpoint

# Send traces
curl -X POST http://localhost:4318/v1/traces \
  -H "Content-Type: application/json" \
  -d '{"resourceSpans": [...]}'

# Send metrics
curl -X POST http://localhost:4318/v1/metrics \
  -H "Content-Type: application/json" \
  -d '{"resourceMetrics": [...]}'

# Send logs
curl -X POST http://localhost:4318/v1/logs \
  -H "Content-Type: application/json" \
  -d '{"resourceLogs": [...]}'
                        

OpenTelemetry SDK Integration

// Go example - HTTP endpoint
import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/http"
)

exporter, err := otlptracehttp.New(
    context.Background(),
    otlptracehttp.WithEndpoint("http://localhost:4318"),
    otlptracehttp.WithInsecure(),
)
                        

gRPC Endpoint

// Go example - gRPC endpoint
import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/grpc"
)

exporter, err := otlptracegrpc.New(
    context.Background(),
    otlptracegrpc.WithEndpoint("localhost:4317"),
    otlptracegrpc.WithInsecure(),
)
                        

Performance Targets

Simple Mode (Default)

Ingestion: 1K+ spans/sec, 10K+ metrics/sec
Query Latency: <100ms for simple queries
Storage: <1GB for 30 days of data
Memory Usage: <512MB RAM
Startup Time: <5 seconds

Advanced Mode (Optional)

Ingestion: 10K+ spans/sec, 100K+ metrics/sec
Query Latency: <500ms for complex queries
Storage: <10GB for 30 days of data
Memory Usage: <2GB RAM
Startup Time: <30 seconds

Resource Requirements

CPU: 1 core minimum, 2 cores recommended
RAM: 512MB minimum, 2GB recommended
Storage: 1GB minimum, 10GB recommended
OS: Linux, macOS, Windows

Open Source vs Enterprise

Feature	Open-Telemorph-Prime	Telemorph-Prime Enterprise
Complexity	Low (1-3 services)	High (20+ services)
Resource Usage	<2GB RAM, 1 machine	1TB+ RAM, 50+ nodes
Setup Time	Minutes	Hours/Days
Learning Curve	Hours	Weeks
Target Users	Home/Dev	Enterprise
Scalability	10-100 services	1000+ services
Features	Essential features	Full enterprise

Contributing

Development Setup

# Clone repository
git clone https://github.com/nadx/open-telemorph-prime.git
cd open-telemorph-prime

# Install dependencies
go mod tidy

# Run in development mode
go run main.go -config config.yaml

# Build binary
go build -o open-telemorph-prime .
                        

How to Contribute

Fork the repository
Create a feature branch
Make your changes (keep it simple!)
Add tests (if applicable)
Submit a pull request

Project Structure

open-telemorph-prime/
├── main.go                 # Entry point
├── internal/
│   ├── config/            # Configuration management
│   ├── ingestion/         # OTLP receivers
│   ├── storage/           # SQLite/PostgreSQL interface
│   ├── query/             # Basic query engine
│   └── web/               # Embedded web UI
├── web/                   # Static web assets
│   ├── index.html
│   ├── dashboard.js
│   └── styles.css
└── config.yaml            # Configuration file
                        