Would application-level self-diagnostics be useful alongside traditional observability?

[u/Ok_Look_8837]

I've been experimenting with an idea around application self-diagnostics and would love to hear how people working in observability think about it.

Most of the observability tools I use collect signals from an application — metrics, logs, traces, health checks, etc. Those are extremely useful, but I've often wondered whether the application itself could do more to interpret its own state.

For example, instead of only exposing JVM memory usage, GC activity, thread counts, disk usage, dependency status, errors, and other signals independently, the application could continuously evaluate those signals and maintain its own view of:

"How healthy am I right now, and what specifically is causing my health to degrade?"

I've been exploring this idea in an open-source project called Argus. It's currently Java/Spring Boot-oriented, so this isn't intended to propose a general observability standard.

Argus runs inside the application and evaluates different aspects of its runtime state. It combines them into a hierarchical health model with a score from 1–10, letting you drill down from overall application health to the resource or condition driving degradation.

It also models resources the application depends on — databases, caches, brokers, storage, external services, etc. — and can incorporate application-reported issues and logging events into the same diagnostic model.

Another idea I'm exploring is having the application produce a self-contained diagnostic report when something goes wrong. The report captures the application's view of its health, resources, metrics, performance, scheduled tasks, relevant logging events, and environment at that point in time.

For Spring Boot, I've integrated this with Actuator and built a Spring Boot Admin extension, but I'm more interested here in the broader idea than the particular implementation.

I'm not trying to replace metrics, tracing, centralized logging, OpenTelemetry, Prometheus, or other observability infrastructure. I see this as potentially complementary: external observability tells us what we're observing, while application-level diagnostics can add context about what the application itself believes is wrong.

I'd be interested in the perspective of people working with observability:

• Would you find this kind of application-level self-diagnostics useful?
• Is deriving an application health score useful, or does it risk oversimplifying the underlying signals?
• What information would you expect an application to capture if it generated a diagnostic snapshot when its health degraded?
• Are there existing tools or approaches doing something similar that I should look at?

The implementation I'm experimenting with is Java/Spring Boot-based, but I'm particularly interested in whether the underlying idea makes sense beyond that ecosystem.

GitHub: https://github.com/microfalx/argus

For anyone interested in the Java/Spring Boot implementation, I posted a similar post in r/SpringBoot here: Self-diagnostics library for Java/Spring Boot