diff --git a/docs/sources/introduction/_index.md b/docs/sources/introduction/_index.md index e3597097630..2f8b314e17d 100644 --- a/docs/sources/introduction/_index.md +++ b/docs/sources/introduction/_index.md @@ -9,28 +9,106 @@ weight: 10 # Introduction to {{% param "FULL_PRODUCT_NAME" %}} {{< param "PRODUCT_NAME" >}} is a flexible, high performance, vendor-neutral distribution of the [OpenTelemetry][] Collector. -It's fully compatible with the most popular open source observability standards such as OpenTelemetry and Prometheus. +It combines the strengths of leading observability collectors into one unified solution. +Whether observing applications, infrastructure, or both, {{< param "PRODUCT_NAME" >}} can collect, process, and export telemetry signals to scale and strengthen your observability approach. -{{< param "PRODUCT_NAME" >}} focuses on ease-of-use and the ability to adapt to the needs of power users. +{{< param "PRODUCT_NAME" >}} is compatible with the most popular open source observability standards such as OpenTelemetry and Prometheus, while providing advanced features like programmable pipelines, automatic clustering, and enterprise-grade reliability that go beyond traditional collectors. + +## Why choose {{% param "PRODUCT_NAME" %}}? + +**Unify your telemetry collection strategy.** Many organizations struggle with managing multiple specialized collectors, each with different configurations, maintenance overhead, and operational complexity. +{{< param "PRODUCT_NAME" >}} eliminates this fragmentation by providing native support for all telemetry signals—metrics, logs, traces, and profiles—in a single, cohesive solution. + +**Scale effortlessly with built-in clustering.** Unlike traditional collectors that require complex external orchestration for high availability, {{< param "PRODUCT_NAME" >}} provides automatic workload distribution and clustering out of the box. +Scale horizontally with minimal operational overhead while maintaining enterprise-grade reliability. + +**Program powerful pipelines with confidence.** {{< param "PRODUCT_NAME" >}}'s rich expression-based syntax and component architecture make complex observability pipelines straightforward to build, understand, and maintain. +Create reusable components, share pipelines with your team, and adapt quickly to changing requirements. {{< docs/learning-journeys title="Send logs to Grafana Cloud using Alloy" url="/docs/learning-journeys/send-logs-alloy-loki/" >}} -## Key features +## Key capabilities + +{{< param "PRODUCT_NAME" >}} provides enterprise-grade observability collection that scales with your organization: + +### Unified telemetry collection + +* **All signals, one platform:** {{< param "PRODUCT_NAME" >}} provides native support for metrics, logs, traces, and profiles without having to learn, configure, and manage multiple collectors. + This unified approach simplifies your observability stack and reduces operational complexity. +* **Components covering popular technologies:** You can collect telemetry data from applications, databases, cloud services, and infrastructure using the built-in components. + These components cover popular technologies and services across your entire technology stack. +* **Multi-ecosystem support:** {{< param "PRODUCT_NAME" >}} works with the OpenTelemetry, Prometheus, Grafana Loki, and Grafana Pyroscope ecosystems. + This compatibility ensures you can integrate with your current observability tools and workflows. + +### Enterprise scalability and reliability + +* **Automatic clustering:** {{< param "PRODUCT_NAME" >}} provides built-in workload distribution and high availability without requiring external orchestration tools. + The clustering feature automatically manages load balancing and fault tolerance to ensure continuous operation. +* **Dynamic scaling:** You can add or remove instances as load changes with automatic target redistribution across the cluster. + This elasticity allows your observability infrastructure to adapt to changing demands without manual intervention. +* **Consistent hashing:** {{< param "PRODUCT_NAME" >}} uses efficient load distribution algorithms that minimize disruption when cluster topology changes. + This approach ensures stable performance during scaling operations and node replacements. + +### Developer productivity + +* **Programmable pipelines:** {{< param "PRODUCT_NAME" >}} offers a rich expression-based syntax for creating sophisticated data processing workflows. + This programming model makes complex observability pipelines straightforward to build, understand, and maintain. +* **Reusable components:** You can build components once and use them everywhere across your organization. + Create custom components and share them across teams to promote consistency and reduce development time. +* **GitOps compatibility:** {{< param "PRODUCT_NAME" >}} can pull configurations from Git repositories, S3 buckets, HTTP endpoints, and other sources for automated deployments. + This integration enables version-controlled, infrastructure-as-code approaches to observability configuration. + +### Operational excellence + +* **Built-in debugging:** {{< param "PRODUCT_NAME" >}} includes an embedded UI and troubleshooting tools that help you identify and resolve configuration issues quickly. + These diagnostic features reduce time-to-resolution for observability pipeline problems. +* **Security-first:** {{< param "PRODUCT_NAME" >}} provides integrated credential management with HashiCorp Vault and Kubernetes secret support. + This security integration ensures {{< param "PRODUCT_NAME" >}} handles sensitive information safely throughout your observability infrastructure. +* **Vendor neutrality:** {{< param "PRODUCT_NAME" >}} follows a "big tent" approach that ensures compatibility with any observability backend or open source database. + This flexibility protects your investment and prevents vendor lock-in. + +## Common use cases -Some of the key features of {{< param "PRODUCT_NAME" >}} include: +You can use {{< param "PRODUCT_NAME" >}} in many different ways, allowing you to modernize your monitoring, scale as your company grows, bridge your ecosystems, and even implement cloud-native observability. -* **Custom components:** You can use {{< param "PRODUCT_NAME" >}} to create and share custom components. - Custom components combine a pipeline of existing components into a single, easy-to-understand component that's just a few lines long. - You can use pre-built custom components from the community, ones packaged by Grafana, or create your own. -* **Reusable components:** You can use the output of a component as the input for multiple other components. -* **Chained components:** You can chain components together to form a pipeline. -* **Single task per component:** The scope of each component is limited to one specific task. -* **GitOps compatibility:** {{< param "PRODUCT_NAME" >}} uses frameworks to pull configurations from Git, S3, HTTP endpoints, and just about any other source. -* **Clustering support:** {{< param "PRODUCT_NAME" >}} has native clustering support. - Clustering helps distribute the workload and ensures you have high availability. - You can quickly create horizontally scalable deployments with minimal resource and operational overhead. -* **Security:** {{< param "PRODUCT_NAME" >}} helps you manage authentication credentials and connect to HashiCorp Vaults or Kubernetes clusters to retrieve secrets. -* **Debugging utilities:** {{< param "PRODUCT_NAME" >}} provides troubleshooting support and an embedded [user interface][UI] to help you identify and resolve configuration problems. +### Modernize legacy monitoring + +Replace multiple specialized agents and collectors with a unified solution that handles all telemetry types. +Reduce operational complexity while gaining modern features like clustering and programmable pipelines. + +### Scale observability infrastructure + +Start with a single instance and grow to enterprise-scale deployments without architectural changes. +{{< param "PRODUCT_NAME" >}} uses clustering to automatically distribute the workload as you add capacity. + +### Bridge observability ecosystems + +Connect OpenTelemetry applications with Prometheus infrastructure, or send Prometheus metrics to OpenTelemetry backends. +{{< param "PRODUCT_NAME" >}} natively supports both ecosystems without conversion overhead. + +### Implement cloud-native observability + +Deploy {{< param "PRODUCT_NAME" >}} on Kubernetes with native resource discovery, automatic configuration updates, and seamless integration with cloud providers. +{{< param "PRODUCT_NAME" >}} is built for containerized environments and provides dynamic service discovery that automatically adapts to changes in your infrastructure. +This cloud-native design eliminates manual configuration overhead and ensures comprehensive observability coverage as your services scale. + +## How {{% param "PRODUCT_NAME" %}} compares + +**vs. OpenTelemetry Collector:** {{< param "PRODUCT_NAME" >}} includes OpenTelemetry Collector capabilities while adding native Prometheus pipelines, advanced clustering, programmable configuration syntax, and enterprise features like centralized configuration management. +This combination provides the flexibility of OpenTelemetry with additional production-ready capabilities. + +**vs. Prometheus Agent:** While Prometheus Agent focuses solely on metrics collection, it lacks support for logs, traces, and profiles. +{{< param "PRODUCT_NAME" >}} provides unified collection for all telemetry signals with the same operational simplicity, eliminating the need for multiple specialized collectors. + +**vs. Traditional monitoring agents:** Legacy agents typically handle one signal type, require complex clustering solutions, and use static configuration files that are difficult to maintain and update. +{{< param "PRODUCT_NAME" >}} provides dynamic, programmable pipelines with built-in high availability and centralized configuration management. + +**vs. Vendor-specific agents:** Proprietary agents lock you into specific backends and ecosystems, creating vendor dependency and limiting your flexibility. +{{< param "PRODUCT_NAME" >}}'s vendor-neutral approach ensures flexibility to change backends without reconfiguring collection infrastructure, protecting your investment and preventing vendor lock-in. + +{{< admonition type="note" >}} +For a detailed comparison of {{< param "PRODUCT_NAME" >}} with other observability collectors and migration guidance, refer to [Why choose {{< param "PRODUCT_NAME" >}}](https://grafana.com/docs/alloy/latest/introduction/why-choose-alloy/). +{{< /admonition >}} ## How does {{% param "PRODUCT_NAME" %}} work as an OpenTelemetry collector? @@ -39,29 +117,37 @@ Some of the key features of {{< param "PRODUCT_NAME" >}} include: ### Collect {{< param "PRODUCT_NAME" >}} uses more than 120 components to collect telemetry data from applications, databases, and OpenTelemetry collectors. +These components provide comprehensive coverage across your technology stack, from application-level metrics to infrastructure monitoring. + {{< param "PRODUCT_NAME" >}} supports collection using multiple ecosystems, including OpenTelemetry and Prometheus. +This multi-ecosystem approach allows you to integrate with your current monitoring setup while providing a migration path to modern observability standards. -Telemetry data can be either pushed to {{< param "PRODUCT_NAME" >}}, or {{< param "PRODUCT_NAME" >}} can pull it from your data sources. +Telemetry data can be either pushed to {{< param "PRODUCT_NAME" >}} through various protocols and interfaces, or {{< param "PRODUCT_NAME" >}} can actively pull data from your sources using service discovery and scraping mechanisms. +This flexibility accommodates different application architectures and deployment patterns. ### Transform -{{< param "PRODUCT_NAME" >}} processes data and transforms it for sending. +{{< param "PRODUCT_NAME" >}} processes and transforms telemetry data before sending it to its destination. +The transformation capabilities allow you to modify, enrich, and filter data to meet your specific observability requirements. -You can use transformations to inject extra metadata into telemetry or filter out unwanted data. +You can use transformations to inject extra metadata into telemetry signals, filter out unwanted or sensitive data, aggregate metrics, and normalize data formats. +These transformations ensure that only relevant, properly formatted data reaches your observability backends. ### Write -{{< param "PRODUCT_NAME" >}} sends data to OpenTelemetry-compatible databases or collectors, the Grafana stack, or Grafana Cloud. +{{< param "PRODUCT_NAME" >}} sends processed telemetry data to OpenTelemetry-compatible databases or collectors, the Grafana stack, or Grafana Cloud. +The flexible output capabilities support multiple destinations simultaneously, allowing you to route different data types to appropriate storage systems. -{{< param "PRODUCT_NAME" >}} can also write alerting rules in compatible databases. +{{< param "PRODUCT_NAME" >}} can also write alerting rules to compatible databases, enabling you to define monitoring conditions directly within your collection pipeline. +This integration streamlines the process of setting up comprehensive observability and alerting. ## Next steps -* [Install][] {{< param "PRODUCT_NAME" >}}. -* Learn about the core [Concepts][] of {{< param "PRODUCT_NAME" >}}. -* Follow the [tutorials][] for hands-on learning about {{< param "PRODUCT_NAME" >}}. -* Learn how to [collect and forward data][Collect] with {{< param "PRODUCT_NAME" >}}. -* Check out the [reference][] documentation to find information about the {{< param "PRODUCT_NAME" >}} components, configuration blocks, and command line tools. +* [Install][] {{< param "PRODUCT_NAME" >}} on your preferred platform to get started with unified telemetry collection. +* Learn about the core [Concepts][] of {{< param "PRODUCT_NAME" >}} to understand its architecture and operational model. +* Follow the [tutorials][] for hands-on learning about {{< param "PRODUCT_NAME" >}} configuration and deployment scenarios. +* Learn how to [collect and forward data][Collect] with {{< param "PRODUCT_NAME" >}} to set up your observability pipelines. +* Check out the [reference][] documentation to find detailed information about {{< param "PRODUCT_NAME" >}} components, configuration blocks, and command line tools. [OpenTelemetry]: https://opentelemetry.io/ecosystem/distributions/ [Install]: ../set-up/install/ @@ -69,4 +155,3 @@ You can use transformations to inject extra metadata into telemetry or filter ou [Collect]: ../collect/ [tutorials]: ../tutorials/ [reference]: ../reference/ -[UI]: ../troubleshoot/debug/ diff --git a/docs/sources/introduction/why-choose-alloy.md b/docs/sources/introduction/why-choose-alloy.md new file mode 100644 index 00000000000..c107c87effc --- /dev/null +++ b/docs/sources/introduction/why-choose-alloy.md @@ -0,0 +1,142 @@ +--- +canonical: https://grafana.com/docs/alloy/latest/introduction/why-choose-alloy/ +description: Learn why organizations choose Grafana Alloy for their observability infrastructure +menuTitle: Why choose Alloy +title: Why choose Grafana Alloy +weight: 100 +--- + +# Why choose {{< param "FULL_PRODUCT_NAME" >}} + +Organizations worldwide adopt {{< param "PRODUCT_NAME" >}} to modernize their observability infrastructure, reduce operational complexity, and strengthen their telemetry collection strategy. + +## The observability collection challenge + +Modern organizations handle complex observability requirements that traditional tools struggle to address efficiently. + +As organizations scale their infrastructure, they encounter multiple telemetry collection challenges: + +- **Complex tool sprawl**: Managing separate agents for metrics, logs, traces, and profiles creates significant operational overhead. + Each tool requires different configurations, monitoring approaches, and expertise to maintain effectively. +- **Vendor lock-in**: Purpose-built collectors tie you to specific observability vendors, limiting your flexibility to change backends or adopt different technologies. + This dependency can restrict your ability to optimize costs and functionality. +- **Limited flexibility**: Static configuration files make it difficult to adapt collection strategies to changing requirements. + Dynamic environments need configuration approaches that can respond to runtime conditions and business logic. +- **Scaling challenges**: Traditional agents struggle with high-cardinality data and large-scale deployments. + They often lack built-in clustering capabilities. They also require complex external orchestration for high availability. +- **Operational complexity**: Different tools require different expertise, monitoring, and maintenance approaches. + This fragmentation increases the learning curve for teams and makes troubleshooting more difficult. + +{{< param "FULL_PRODUCT_NAME" >}} addresses these challenges by providing a unified, vendor-neutral collection platform that scales with your observability needs. + +## Key advantages over alternatives + +{{< param "PRODUCT_NAME" >}} offers significant advantages over traditional observability collection tools through its modern architecture and comprehensive feature set. + +### Unified collection platform + +{{< param "PRODUCT_NAME" >}} provides native support for all telemetry signals in a single binary with consistent operational patterns. +Instead of managing Prometheus for metrics, Fluent Bit for logs, and OpenTelemetry Collector for traces, you get one tool. +This unified approach means one configuration language, one operational model, and one set of skills for your team to master. + +### Built-in enterprise clustering + +{{< param "PRODUCT_NAME" >}} includes automatic workload distribution without requiring external dependencies or complex orchestration. +The peer-to-peer protocol in {{< param "PRODUCT_NAME" >}} enables automatic peer discovery and coordination. +Consistent hashing ensures even load distribution across cluster nodes. +The self-healing cluster topology automatically adapts to changes. + +### Programmable configuration + +{{< param "PRODUCT_NAME" >}} offers a rich expression language that enables dynamic configuration and data transformation capabilities. +Instead of static YAML configurations, you can express complex logic with built-in functions. +This approach supports runtime evaluation of dynamic values and enables reusable modular configurations that adapt to changing conditions. + +### Ecosystem compatibility + +{{< param "PRODUCT_NAME" >}} follows a "big tent" philosophy that provides native support for multiple observability ecosystems. +This approach eliminates the need for conversion or translation overhead. +{{< param "PRODUCT_NAME" >}} includes both OpenTelemetry and Prometheus pipelines in one tool. +It provides direct integration with Grafana Loki, Tempo, Mimir, and Pyroscope. +This ensures seamless connectivity across your observability stack. + +## When to choose {{< param "PRODUCT_NAME" >}} + +{{< param "PRODUCT_NAME" >}} addresses specific observability challenges across different organizational scenarios and deployment environments. + +### Legacy monitoring modernization + +Replace multiple specialized agents and collectors with a unified solution that handles all telemetry types. +This consolidation reduces operational complexity while providing access to modern features like clustering and programmable pipelines. +You can gradually migrate from legacy tools without disrupting your current monitoring capabilities. + +### Observability infrastructure scaling + +Start with a single instance and grow to enterprise-scale deployments without requiring architectural changes or redesign. +{{< param "PRODUCT_NAME" >}} clustering automatically distributes workload as you add capacity. +This elastic scaling approach ensures your observability infrastructure grows seamlessly with your business needs. + +### Observability ecosystem integration + +Connect OpenTelemetry applications with Prometheus infrastructure. +You can also send Prometheus metrics to OpenTelemetry backends without complex configuration. +{{< param "PRODUCT_NAME" >}} provides native support for both ecosystems. +This eliminates conversion overhead and simplifies your observability architecture. +This dual compatibility ensures you can work with best-of-breed tools from multiple ecosystems. + +### Cloud-native observability deployment + +Deploy {{< param "PRODUCT_NAME" >}} on Kubernetes with native resource discovery and automatic configuration updates. +It also provides seamless cloud provider integration. +{{< param "PRODUCT_NAME" >}} is purpose-built for containerized environments. +It provides service discovery and dynamic configuration management that automatically adapts to your cloud-native infrastructure changes. + +## Migration benefits + +{{< param "PRODUCT_NAME" >}} provides specific advantages depending on your current observability collection approach. + +### From OpenTelemetry Collector + +- You can add Prometheus support without deploying additional tools or learning different configuration formats, enabling unified metric collection across multiple ecosystems +- {{< param "PRODUCT_NAME" >}} provides clustering and high availability features that aren't available in the standard OpenTelemetry Collector, eliminating the need for external orchestration +- You gain access to advanced configuration capabilities through the {{< param "PRODUCT_NAME" >}} configuration language and component system, which offers more flexibility than standard YAML configurations +- You can use the built-in converter to translate current configurations automatically, reducing migration time and effort while ensuring compatibility + +### From Prometheus Agent + +- You can extend beyond metrics to collect logs, traces, and profiles using a single, unified tool that replaces multiple specialized agents +- {{< param "PRODUCT_NAME" >}} eliminates the need for separate log and trace collection tools, reducing your operational complexity and maintenance overhead +- You gain enterprise clustering and scalability features that enable high availability deployments without requiring external load balancers or service discovery +- You can use {{< param "PRODUCT_NAME" >}} as a direct replacement with enhanced capabilities while maintaining compatibility with your current Prometheus workflows + +### From vendor-specific agents + +- You can escape vendor lock-in and gain backend flexibility to choose the best observability tools for your needs, ensuring long-term strategic flexibility +- {{< param "PRODUCT_NAME" >}} reduces licensing costs by providing an open source solution with no vendor-imposed usage restrictions or per-node fees +- You gain access to a rapidly evolving feature set and vibrant community that drives continuous innovation and regular updates +- You can leverage an extensive component library that covers most proprietary agent capabilities while providing extensibility for custom requirements + +## Get started + +Ready to experience unified observability collection? + +- **[Install {{< param "PRODUCT_NAME" >}}][Install]** and try it with your current infrastructure to see the immediate benefits of unified telemetry collection +- **[Convert current configurations][convert]** from OpenTelemetry Collector, Prometheus, or other tools using built-in migration utilities that automate the transition process +- **[Explore tutorials][tutorials]** for hands-on experience with key features and common use cases that demonstrate real-world implementation scenarios +- **[Join the community][community]** to connect with other users and contributors who can share best practices and provide support for your specific deployment requirements + +## Next steps + +- [{{< param "PRODUCT_NAME" >}} architecture][architecture] provides technical implementation details and architectural concepts that explain how components work together +- [Configuration examples][examples] demonstrate common use cases and implementation patterns for typical observability scenarios +- [Component reference][components] lists all available integrations and their configuration options to help you build custom telemetry pipelines +- [Performance tuning][performance] guides optimization strategies for production deployments and scaling considerations + +[Install]: ../set-up/install/ +[convert]: ../set-up/migrate/ +[tutorials]: ../tutorials/ +[community]: https://grafana.com/community/ +[architecture]: ../introduction/#architecture +[examples]: ../configure/ +[components]: ../reference/components/ +[performance]: ../monitor/