Merge pull request #73 from simranquirky/overview-pages

Overview pages

Author: Manazsharma

docs/.pages

@@ -1,4 +1,6 @@
 nav:
+<<<<<<< HEAD
+<<<<<<< HEAD
 - Introduction: index.md
 - Getting started: getting-started.md
 - Quickstart: quickstart.md
@@ -7,6 +9,17 @@ nav:
 - Example Queries: example-queries.md
 - SQL Function Reference: sql_reference.md
 - Architecture: architecture.md
+=======
+=======
+>>>>>>> b992089 (nav bar modification:)
+- Overview: overview
+- Architecture: architecture.md
+- Getting started: getting-started.md
+- Features: features
+- Enterprise Edition Installation Guide: openobserve-enterprise-edition-installation-guide.md
+- Releases: releases.md
+- Example Queries: example-queries.md
+- SQL Function Reference: sql_reference.md
 - HA Deployment: ha_deployment.md
 - Environment Variables: environment-variables.md
 - Data Management: data-management

docs/features/.pages

@@ -0,0 +1,7 @@
+nav:
+  - Log Management: logs.md
+  - Metric Monitoring: metrics.md
+  - Distributed Tracing: distributed-tracing.md
+  - Frontend Observability: frontend.md
+  - Enterprise Features: enterprise.md
+  - What's next: upcoming.md

docs/features/distributed-tracing.md

@@ -0,0 +1,69 @@
+# Distributed Tracing
+
+OpenObserve provides powerful distributed tracing capabilities that enable you to track requests as they flow through your microservices architecture, identify performance bottlenecks, and troubleshoot complex distributed systems with ease.
+
+## Overview
+
+Distributed tracing in OpenObserve allows you to visualize the complete journey of requests across multiple services, understand service dependencies, and pinpoint the root cause of performance issues. Built for modern cloud-native applications, OpenObserve efficiently handles trace ingestion, correlation, and analysis at enterprise scale while maintaining exceptional query performance.
+
+![Tracing Page](../images/features/traces-hero.png)
+*Distributed Tracing overview page*
+
+## Key Features
+
+### Trace Ingestion
+
+- **OpenTelemetry Native**: Full support for OpenTelemetry protocol with automatic trace collection
+
+![OpenTelemetry Native](../images/features/traces-otel-support.png)
+
+- **High Throughput**: Process millions of spans per second with sub-millisecond latency
+
+### Trace Structure & Data
+
+- **Hierarchical Spans**: Complete trace trees showing parent-child relationships between operations
+
+![Hierarchical Spans](../images/features/trace-spans.png)
+
+- **Rich Metadata**: Capture detailed span attributes, tags, and contextual information
+
+![Rich Metadata](../images/features/traces-metadata.png)
+
+- **Custom Instrumentation**: Support for manual and automatic instrumentation
+
+### Trace Analysis & Search
+
+- **Advanced Filtering**: Search traces by service, operation, duration, errors, and custom attributes
+
+![Trace Search](../images/features/trace-search.png)
+
+- **Performance Profiling**: Identify slow operations and bottlenecks across your distributed system
+
+- **Error Investigation**: Quickly locate and analyze failed requests and exceptions
+
+![Error Investigation](../images/features/trace-error.png)
+
+
+### Visualization & Insights
+
+- **Gantt Chart Views**: Interactive timeline visualization showing span relationships and durations
+
+![Traces Gnatt Chart View](../images/features/trace-timeline.png)
+
+- **Service Map**: Real-time service topology with performance metrics and error rates
+
+![Traces Service Map](../images/features/traces-service-map.png)
+
+### Storage & Performance
+
+- **Smart Indexing**: High-performance indexing optimized for trace queries and span searches
+
+![Smart Indexing](../images/features/trace-settings.png)
+
+- **Retention Management**: [Flexible retention policies](../user-guide/streams/extended-retention.md) for cost-effective long-term storage
+
+### Integration & Standards
+- **OpenTelemetry Ecosystem**: Full compatibility with OpenTelemetry collectors and instrumentation libraries
+- **Jaeger and Zipkin Compatibility**: Supports ingestion from Jaeger and Zipkin via OpenTelemetry Collector
+- **Kubernetes-Friendly:** Easily integrates into Kubernetes environments via OpenTelemetry Collector with support for service metadata enrichment.
+- **API Access**: Comprehensive REST APIs for programmatic trace access and analysis

docs/features/enterprise.md

@@ -0,0 +1,20 @@
+# Enterprise Features
+
+## Overview
+Enterprise tier includes all standard features plus the following enterprise-specific capabilities. Available free for up to 200 GB of ingestion per day.
+
+## Enterprise-Only Features
+
+### Data Management
+- **Extended Data Retention** - Keep data longer than standard retention periods
+- **Federated Search / Super Cluster** - Search across multiple Openobserve clusters from single interface
+
+### Security & Access
+- **SSO (Single Sign On)** - Integrate with existing identity providers
+- **Role-Based Access Control (RBAC)** - Manage user permissions by role
+- **Cipher Keys** - Encryption and compliance support for HIPAA and PCI
+
+### Operations
+- [**Query Management**](../work_group.md) - Optimize and manage query performance
+- **Workload Management (QoS)** - Prioritize and allocate resources
+- **Audit Trail** - Track all system activities and changes

docs/features/frontend.md

@@ -0,0 +1,49 @@
+# Frontend Observability
+
+OpenObserve provides robust frontend observability tools that help monitor user experience, track performance metrics, and capture errors in web applications. With minimal overhead, you can gain deep visibility into how users interact with your frontend—ensuring smooth performance across devices and browsers.
+
+## Overview
+
+Frontend Observability in OpenObserve enables real user monitoring, performance tracking (including Core Web Vitals), JavaScript error capture, and session replay. These tools are optimized for modern frontend architectures and come with a lightweight SDK for easy integration.
+
+
+## Key Features
+
+### Real User Monitoring (RUM)
+
+- **Page Load Performance**: Track FCP, LCP, and other performance indicators
+
+- **Web Vitals Monitoring**: Automatically capture Google's Core Web Vitals
+
+![Web Vitals Monitoring](../images/features/frontend-webvitals.png)
+
+- **Geographic & Device Context**: Analyze user experience by browser, device, and approximate location.
+
+- **Network Insights**: Track HTTP requests and network timing
+
+
+### [Error Tracking](../user-guide/rum.md#error-tracking)
+
+- **JavaScript Errors**: Automatically capture exceptions and errors with full stack traces
+- **Source Maps**: View original source files when source maps are uploaded.
+- **Error Context**: Includes user session metadata and browser details
+
+![Error Tracking](../images/frontend/error-tracking.webp)
+
+### [Session Replay](../user-guide/rum.md#session-replay)
+
+- **User Interaction Recording**: Replay user sessions to understand behavior and debug issues
+
+![User Interaction Recording](../images/features/user-interaction.png)
+
+- **Event Timeline**: View DOM changes, clicks, inputs, and navigation in order
+
+![Event Timeline](../images/features/event-timeline.png)
+
+- **Privacy Features**: Configurable masking for sensitive fields
+
+
+## Integration
+
+Getting started with [OpenObserve's RUM](../user-guide/rum.md) is straightforward. Add our JavaScript snippet to your application's entry point eg: index.js or main.js, and you'll begin collecting user experience data immediately.
+

docs/features/logs.md

@@ -0,0 +1,52 @@
+# Logs
+
+OpenObserve provides powerful log management capabilities for collecting, storing, and analyzing log data from your applications and infrastructure.
+
+## Overview
+
+Logs in OpenObserve offer comprehensive observability into your system's behavior, allowing you to track events, debug issues, and monitor application performance. Built with high performance and cost efficiency in mind, OpenObserve handles log ingestion and querying at scale.
+
+![Logs Page](../images/features/logs-page.png)
+*Logs Page view*
+
+## Key Features
+
+### Log Ingestion
+- **Multiple Protocols**: Support for multiple ingestion methods including HTTP and integration with popular log shippers like FluentBit, Vector, etc.
+- **Structured & Unstructured**: Handle both JSON structured logs and plain text logs
+- **Real-time Processing**: Immediate indexing and availability for search and analysis
+
+### Search & Query
+
+- **Field Extraction**: Automatic field detection and parsing for structured data.
+
+![Field Extraction](../images/features/log-feilds-detection.png)
+
+The [Schema Settings](../user-guide/streams/schema-settings.md) tab in the Stream Details panel allows you to inspect and manage the schema used to store and query ingested data. 
+
+- **Full-text Search**: Powerful search capabilities across all log fields
+
+![Full-text Search](../images/features/log-settings.png)
+
+- **SQL Queries**: Use familiar SQL syntax for complex filtering and aggregation.
+
+![SQL Queries](../images/features/sql-based-log-search.png)
+
+- **Time-based Filtering**: Query logs within specific time windows using absolute or relative ranges.
+
+![Time-based Filtering](../images/features/time-selection.png)
+
+### Storage & Performance
+- **Compressed Storage**: Efficient compression reduces storage costs significantly
+
+![Compressed Storage](../images/features/data-compression.png)
+
+- **Fast Retrieval**: Optimized indexing for quick log searches and aggregations
+
+![Indexing](../images/features/log-settings.png)
+
+Know more about [Streams](../user-guide/streams/streams-in-openobserve.md) and its [details](../user-guide/streams/stream-details.md#stream-details)
+
+- **Retention Policies**: [Configurable data retention](../user-guide/streams/extended-retention.md) to manage storage costs
+
+![Retention Policies](../images/features/data-retention.png)

docs/features/metrics.md

@@ -0,0 +1,70 @@
+# Metrics
+
+OpenObserve provides comprehensive metrics collection, storage, and visualization capabilities for monitoring your applications and infrastructure performance in real-time.
+
+## Overview
+
+Metrics in OpenObserve enable you to track key performance indicators, monitor system health, and gain insights into your application's behavior over time. Designed for high-throughput environments, OpenObserve efficiently handles metrics ingestion, storage, and querying at scale while maintaining cost-effectiveness.
+
+![Metrics Page](../images/features/metrics-page.png)
+*Metrics Page view*
+
+## Key Features
+
+### Metrics Ingestion
+- **Multiple Formats**: Support for multiple formats including Prometheus remote-write and structured JSON metrics via HTTP ingestion.
+- **Push & Pull Models**: Supports push-based ingestion and integration with systems like Prometheus for pull-based scraping.
+- **High Throughput**: Handle millions of metrics per second with minimal latency
+- **Optimized Processing**: Optimized ingestion pipelines for high-throughput environments.
+
+### Data Types & Structure
+- **Time Series Data**: Native support for time-series metrics with timestamp precision
+- **Multi-dimensional**: Handle metrics with multiple labels and dimensions for detailed analysis
+- **Aggregation Functions**: Built-in support for common aggregation functions (sum, avg, min, max, count)
+- **Custom Metrics**: Flexible schema for application-specific metrics and KPIs
+
+### Query & Analysis
+
+- **PromQL Support**: Full compatibility with Prometheus Query Language for familiar querying
+
+![PromQL Queries](../images/features/promql-queries.png)
+
+- **SQL Interface**: Use SQL syntax for complex metrics analysis and reporting
+
+- **Time Range Selection**: Flexible time range queries with support for relative and absolute time periods
+
+![Time Range Selection](../images/features/metrics-time-selection.png)
+
+- **Mathematical Operations**: Perform calculations and transformations on metrics data
+
+### Visualization & Dashboards
+
+- **Real-time Charts**: Interactive time-series visualizations with multiple chart types
+
+![Metrics Visualization](../images/features/metrics-charts.png)
+
+- **Custom Dashboards**: Create comprehensive dashboards with multiple metrics panels
+
+- **Alerting Integration**: Set up alerts based on metrics thresholds and conditions
+
+![Metrics Alerting](../images/features/metrics-alerts.png)
+
+### Storage & Performance
+
+- **Optimized Compression**: Advanced compression algorithms reduce storage costs.
+
+![Metrics Compression](../images/features/metrics-compression.png)
+
+- **Efficient Indexing**: High-performance indexing for fast query execution across large datasets
+
+- **Downsampling**: Automatic data [downsampling](../user-guide/metrics/downsampling-metrics.md) for long-term storage optimization
+
+- **Retention Policies**: [Configurable retention settings](../user-guide/streams/extended-retention.md) to balance storage costs and data availability
+
+![Metrics Retention](../images/features/metrics-retention.png)
+
+### Integration & Compatibility
+- **Prometheus Compatible**: Full compatibility with Prometheus ecosystem and exporters
+- **OpenTelemetry Ecosystem**: Full compatibility with OpenTelemetry collectors and instrumentation libraries
+- **API Access**: RESTful APIs for programmatic access to metrics data
+- **Standard Exporters**: Support for popular metrics exporters (Node Exporter, cAdvisor, etc.)

docs/features/upcoming.md

@@ -0,0 +1,9 @@
+# Product Roadmap
+
+Our vision is to build the most performant and cost-effective observability platform that scales from startup to enterprise. We're committed to delivering lightning-fast analytics across logs, metrics, traces, RUM, error tracking, and session replay while keeping your storage costs 140x lower than traditional solutions.
+
+Every feature we develop is driven by real user needs and our commitment to making observability simple, powerful, and accessible to teams everywhere.
+
+Want to help shape the future of OpenObserve? We're always evolving and welcome contributions, feedback, and new ideas from the community.
+
+Have a feature request or improvement in mind? Jump into our **[GitHub Discussions](https://github.com/openobserve/openobserve/discussions)** or explore the **[official repository](https://github.com/openobserve/openobserve)** to get involved. Whether it’s ideas, code, or just curiosity — we’d love to have you onboard 🚀