Updated Features and Overview Section

.devcontainer/devcontainer.json.tpl

@@ -8,9 +8,9 @@
 		// Use ubuntu-22.04 or ubuntu-18.04 on local arm64/Apple Silicon.
 		"args": { "VARIANT": "ubuntu-22.04" }
 	},
-	"mounts": [
-		"source=/Users/prabhatsharma/.aws,target=/home/vscode/.aws,type=bind,consistency=cached"
-	],
+	// "mounts": [
+	//	"source=/Users/prabhatsharma/.aws,target=/home/vscode/.aws,type=bind,consistency=cached"
+	// ],
 
 	// Set *default* container specific settings.json values on container create.
 	"settings": {},

docs/.pages

@@ -1,12 +1,12 @@
 nav:
-- Introduction: index.md
+- Overview: overview
+- Features: features
 - Getting started: getting-started.md
 - Quickstart: quickstart.md
 - Enterprise Edition Installation Guide: openobserve-enterprise-edition-installation-guide.md
 - Releases: releases.md
 - Example Queries: example-queries.md
 - SQL reference: sql_reference.md
-- Architecture: architecture.md
 - HA Deployment: ha_deployment.md
 - Environment Variables: environment-variables.md
 - Storage: storage.md

docs/features/.pages

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

docs/features/distributed-tracing.md

@@ -0,0 +1,73 @@
+# 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/tracing-page.png)
+*Distributed Tracing overview page*
+
+## Key Features
+
+### Trace Ingestion
+- **OpenTelemetry Native**: Full support for OpenTelemetry protocol with automatic trace collection
+- **Multiple Protocols**: Compatible with Jaeger, Zipkin, and custom tracing formats
+- **High Throughput**: Process millions of spans per second with sub-millisecond latency
+- **Sampling Strategies**: Intelligent sampling to balance observability with performance impact
+- **Batch Processing**: Optimized batch ingestion for maximum efficiency
+
+### Trace Structure & Data
+- **Hierarchical Spans**: Complete trace trees showing parent-child relationships between operations
+- **Rich Metadata**: Capture detailed span attributes, tags, and contextual information
+- **Error Tracking**: Automatic error detection and classification within traces
+- **Service Mapping**: Dynamic service topology discovery and visualization
+- **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)
+
+- **Dependency Analysis**: Visualize service dependencies and communication patterns
+
+- **Performance Profiling**: Identify slow operations and bottlenecks across your distributed system
+
+- **Error Investigation**: Quickly locate and analyze failed requests and exceptions
+
+### Visualization & Insights
+
+- **Gantt Chart Views**: Interactive timeline visualization showing span relationships and durations
+
+- **Service Map**: Real-time service topology with performance metrics and error rates
+
+- **Flame Graphs**: Detailed performance analysis with hierarchical span breakdown
+
+- **Trace Comparison**: Side-by-side comparison of traces for performance analysis
+
+### Correlation & Context
+
+- **Metrics Correlation**: Link traces to related metrics and logs for complete observability
+
+- **Log Integration**: Automatic correlation between trace spans and application logs
+
+- **Alert Integration**: Trigger alerts based on trace patterns, error rates, and performance thresholds
+
+### Storage & Performance
+
+- **Efficient Compression**: Advanced compression techniques reduce storage overhead by up to 85%
+
+- **Smart Indexing**: High-performance indexing optimized for trace queries and span searches
+
+- **Tail-based Sampling**: Intelligent sampling decisions based on complete trace context
+
+- **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 Integration**: Seamless migration from Jaeger with native protocol support
+- **Zipkin Compatibility**: Support for Zipkin trace format and existing instrumentation
+- **Cloud Native**: Native Kubernetes integration with automatic service discovery
+- **API Access**: Comprehensive REST APIs for programmatic trace access and analysis

docs/features/enterprise.md

@@ -0,0 +1,21 @@
+# 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 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
+- **Sensitive Data Redaction** - Automatically mask sensitive information
+- **Cipher Keys** - Encryption and compliance support for HIPAA and PCI
+
+### Operations
+- **Query Management** - 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,111 @@
+# Frontend Observability
+
+OpenObserve provides comprehensive frontend observability capabilities that enable you to monitor user experiences, track performance metrics, and diagnose issues in web applications and mobile apps. Gain complete visibility into how users interact with your frontend applications and ensure optimal user experience across all devices and browsers.
+
+## Overview
+
+Frontend Observability in OpenObserve allows you to monitor real user experiences, track Core Web Vitals, capture JavaScript errors, and analyze user journeys across your web and mobile applications. Built for modern frontend architectures, OpenObserve efficiently collects, processes, and analyzes frontend telemetry data while maintaining minimal impact on application performance.
+
+## Key Features
+
+### Real User Monitoring (RUM)
+- **User Session Tracking**: Complete user session recording with interaction timelines
+- **Page Performance**: Detailed page load times, rendering metrics, and resource loading analysis
+- **Core Web Vitals**: Automatic tracking of LCP, FID, CLS, and other Google Core Web Vitals
+- **Geographic Insights**: User experience analysis by geographic location and network conditions
+- **Device & Browser Analytics**: Performance breakdowns by device type, browser, and OS
+
+### [Error Tracking & Debugging](../user-guide/rum.md#error-tracking)
+
+- **JavaScript Error Capture**: Automatic collection of JavaScript errors, exceptions, and promise rejections
+
+- **Source Map Integration**: Detailed stack traces with original source code for minified applications
+
+- **Error Context**: Rich error context including user actions, browser state, and session information
+
+- **Error Grouping**: Intelligent error grouping and deduplication for efficient issue management
+
+### [Performance Monitoring](../user-guide/rum.md#performance-monitoring)
+
+- **Page Load Analytics**: Comprehensive page load performance with waterfall charts and timing breakdowns
+
+- **Resource Monitoring**: Track loading times for images, scripts, stylesheets, and API calls
+
+- **Runtime Performance**: Monitor JavaScript execution times, memory usage, and CPU utilization
+
+- **Custom Performance Metrics**: Track application-specific performance indicators and business metrics
+
+### User Experience Analytics
+
+- **User Journey Mapping**: Visualize complete user paths through your application
+
+- **Interaction Tracking**: Monitor clicks, scrolls, form submissions, and custom user interactions
+
+- **Rage Click Detection**: Identify user frustration points with automatic rage click detection
+
+- **Conversion Funnel Analysis**: Track user conversion rates and identify drop-off points
+
+### Network & API Monitoring
+
+- **AJAX/Fetch Tracking**: Monitor all HTTP requests with response times, status codes, and payload sizes
+
+- **API Performance**: Detailed API call analysis with success rates and error patterns
+
+- **Network Conditions**: Track user network speed and connection quality impact on performance
+
+- **Third-Party Service Monitoring**: Monitor external service dependencies and their impact on user experience
+
+### Browser & Device Insights
+
+- **Browser Compatibility**: Identify browser-specific issues and compatibility problems
+
+- **Device Performance**: Analyze performance across different device capabilities and screen sizes
+
+- **Viewport Analytics**: Understanding of how users interact with different screen resolutions
+
+### [Session Replay & Recording](../user-guide/rum.md#session-replay)
+
+- **Session Recordings**: Visual playback of user sessions for detailed investigation
+
+- **Privacy Controls**: Configurable data masking and privacy protection for sensitive information
+
+- **Event Timeline**: Synchronized timeline of user actions, network requests, and application state
+
+- **Issue Correlation**: Link session recordings to specific errors and performance issues
+
+
+### Mobile App Observability
+
+- **Crash Reporting**: Comprehensive crash reporting for iOS and Android applications
+
+- **App Performance**: Monitor app launch times, screen rendering, and memory usage
+
+- **User Engagement**: Track app usage patterns, feature adoption, and user retention
+
+- **Network Performance**: Monitor API calls and network conditions in mobile environments
+
+### Data Collection & Privacy
+
+- **Lightweight SDKs**: Minimal impact JavaScript and mobile SDKs with optimized performance
+
+- **Sampling Strategies**: Intelligent sampling to balance data quality with performance impact
+
+- **GDPR Compliance**: Built-in privacy controls and data anonymization features
+
+- **Custom Data Collection**: Flexible APIs for collecting custom frontend metrics and events
+
+## Integration
+
+### Web Applications
+- **JavaScript SDK**: Easy integration with vanilla JavaScript, React, Vue, Angular, and other frameworks
+- **NPM Package**: Simple installation via package managers with TypeScript support
+- **CDN Integration**: Quick setup with CDN-hosted SDK for immediate implementation
+- **Framework Plugins**: Native plugins for popular frameworks and build tools
+
+### CI/CD Integration
+- **Build Integration**: Integrate observability setup into your build and deployment pipelines
+- **Source Map Upload**: Automatic source map upload for enhanced error debugging
+- **Performance Budgets**: Set performance budgets and fail builds on regression
+- **Release Tracking**: Correlate frontend performance with deployments and releases
+
+

docs/features/logs.md

@@ -0,0 +1,53 @@
+# 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 various log shipping protocols including HTTP, syslog, and popular log shippers
+- **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 parsing and extraction of log fields. 
+
+![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/full-text-search.png)
+
+- **SQL Queries**: Use familiar SQL syntax for complex log analysis
+
+![SQL Queries](../images/features/sql-based-log-search.png)
+
+- **Time-based Filtering**: Efficient time range queries for targeted log exploration
+
+![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/index.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 various metrics formats including Prometheus, InfluxDB, and JSON
+- **Push & Pull Models**: Flexible ingestion supporting both push-based and pull-based collection methods
+- **High Throughput**: Handle millions of metrics per second with minimal latency
+- **Batch Processing**: Efficient batch ingestion for optimal performance
+
+### 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 by up to 90%
+
+![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
+- **Grafana Integration**: Native support for Grafana dashboards and visualization
+- **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.
+
+Explore our current roadmap and upcoming features **[here](https://github.com/openobserve/openobserve/milestones)**
+
+Have ideas that could make OpenObserve even better? We'd love to hear from you! Share your thoughts and feature requests in our **[GitHub Discussions](https://github.com/openobserve/openobserve/discussions)** - your input directly shapes what we build next 🚀