Looking for a way to proactively troubleshoot complex application performance issues? Look no further than Tanzu Observability by Wavefront, which provides easy data ingestion and preconfigured dashboards and can be set up with Spring Boot and Spring Cloud Data Flow (SCDF) integrations.
Spring Boot developers and SREs can use familiar solutions Micrometer, Sleuth, or Open Tracing for code instrumentation: Micrometer for out-of-the-box and custom metrics and histograms, and Sleuth or Open Tracing for traces and span logs. With data in Tanzu Observability it’s easy to follow requests all the way down to the application code to find bottlenecks and detect issues.
Faster resolution of code issues with out-of-the-box Spring Boot dashboards
After you configure a new or existing application with Wavefront for Spring Boot starter or using Spring Boot integration tiles, Spring Boot emits a raft of out-of-the-box metrics. Those metrics are automatically displayed on Tanzu Observability’s Spring Boot inventory and application dashboards, which include conditional sections and troubleshooting tips. Out-of-the box metrics include process overview metrics, http RED (rate, errors, duration) metrics, JVM threads, memory pools and garbage collection metrics, as well as any metrics triggered by auto-configuration, such as connection metrics for databases. If there is a spike in HTTP requests, a troubleshooting tip might suggest scaling up application instances so that response times are reduced.
Tanzu Observability dashboard for Spring Boot application
If application tracing is enabled, Tanzu Observability detects it and includes a link to the trace browser in the tracing section of the dashboard. In the browser, you can see request flows, service dependencies, and critical RED metrics for any service. You can also dive deeply into individual traces to pinpoint performance bottlenecks.
To get valuable information about an error, there’s no need to go to an external tool; simply use the available span logs. You can also drill down to investigate the performance of downstream services. With Tanzu Observability infrastructure integrations, you can identify whether the issue is caused by the application, by Kubernetes, or by Tanzu Application Service (TAS).
Instant insights into SCDF linear and multi-IO pipelines via streams, applications, and task dashboards
SCDF enables developers to design, develop, and continuously deliver data pipelines—either event streaming (real-time, long-running) or task/batch (short-lived)—locally, on TAS or on Kubernetes. Developers and SREs want to know how SCDF applications are behaving in both development and production environments. They want to know about data throughput, send and receive rates, potential security issues, and any other problems. To provide them with that information, Tanzu Observability offers:
- Full Spring Boot application observability with metrics, histograms, traces, and span logs as part of a free tier
Comprehensive observability and monitoring of data-intensive SCDF applications that process large volumes of data
Tanzu Observability for SCDF streams and task data pipelines
With the Micrometer Wavefront registry, Tanzu Observability can now collect, ingest, and visualize critical metrics from the stream and task pipelines managed by the SCDF servers. Real-time metrics such as message rates, throughput, latency, and error stats provide instant insights into deployed event streaming and batch data pipelines. Tanzu Observability displays the metrics in out-of-the-box dashboards that enable developers to drill down into them. For example, they can find the root cause of bottlenecks for event-streaming data (linear or multi-IO pipelines) and for increased latencies for batch data pipelines.
With the SCDF stream summary dashboard you can compare performance by stream, CPU, memory, message throughput, or latency. Upon noticing an anomaly, you can dive deeper into the detailed real-time performance of stream applications. You can find bottlenecks of deployed pipelines by filtering metrics by stream, application, instance, or channel. With the powerful Tanzu Observability query language, you can discover if the root cause is in TAS or Kubernetes. And by creating an alert for the query, you can dramatically reduce future mean time to repair. Finally, for task applications with detailed real-time performance, you can optimize the tasks to meet your service-level objectives.
To explore what’s possible when you start observing the behavior patterns of Spring Boot, event streaming, and batch applications at scale, sign up for the Tanzu Observability free trial.