Getting Started with Prometheus and Grafana in Java

Monitoring is a crucial aspect of application performance management. As applications scale, ensuring that they run smoothly and that system health is continually tracked becomes imperative. In microservices, distributed systems, and cloud-native applications, monitoring tools are not just an add-on but a critical part of your infrastructure.

Two of the most popular tools for monitoring modern systems are Prometheus and Grafana. These tools are often used to collect, store, and visualize metrics, helping developers and operations teams detect issues, analyze performance, and keep systems running efficiently.

Why Do We Need Monitoring?

Monitoring is essential for identifying problems before they affect users. Whether you're working with a Java-based backend, a complex microservices environment, or any other system, continuous monitoring provides insights into:

• Application performance:
  Track key performance metrics such as response times, requests, and error rates.

• System health:
  Monitor server health, CPU usage, memory usage, and disk space to ensure the infrastructure operates optimally.

• Alerting:
  Set up thresholds and alerts for critical metrics that notify you when something goes wrong.

• Capacity planning:
  Collecting and analyzing historical data can help you plan for scaling your application.

Prometheus and Grafana offer robust solutions to monitor, visualize, and analyze data from your systems and applications.

Introducing Grafana and Prometheus

Prometheus
Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It focuses on gathering time-series data and supports multidimensional data collection, allowing for powerful queries and analysis. Prometheus collects metrics from targets via HTTP endpoints and stores them in a time-series database. These metrics can then be queried using Prometheus's query language, PromQL.

Grafana
Grafana is an open-source platform for monitoring and observability. It allows users to visualize time-series data from multiple sources, including Prometheus. Grafana's ability to create dashboards, set up alerts, and integrate with a wide range of data sources makes it one of the most popular tools for visualizing metrics.

Together, Prometheus collects the metrics, while Grafana displays them in an interactive and visually appealing way.

Running Prometheus in Docker

Running Prometheus and Grafana in Docker is a simple and effective way to set up a monitoring environment quickly. Let's start with running Prometheus in Docker.

Step 1: Running Prometheus in Docker
You can run Prometheus as a container using the following command:

docker run --name prometheus -d -p 127.0.0.1:9090:9090 prom/prometheus

This command will:

• Start a Prometheus container.
• Map the local port 9090 to the container’s port 9090.
• Use the official Prometheus Docker image from Docker Hub. You can verify that Prometheus is running by opening your browser and navigating to http://localhost:9090/.

Step 2: Configuring Prometheus
You must adjust the Prometheus configuration file if you need to configure Prometheus to scrape metrics from specific endpoints (e.g., a Java application). By mounting it into the container, you can run Prometheus with a custom prometheus.yml file. Here’s an example:

docker run \
    -p 9090:9090 \
    -v /prometheus.yml:/etc/prometheus/prometheus.yml \
    prom/prometheus

This mounts your local prometheus.yml file into the container. After starting Prometheus, you can go to http://localhost:9090/ to access the Prometheus dashboard.

Running Grafana in Docker

Now that Prometheus is running adding Grafana to visualize the data is time.

Step 3: Running Grafana in Docker
Grafana is simple to deploy via Docker. Run the following command to start the Grafana container:

Running Grafana in docker

docker run -d -p 3000:3000 grafana/grafana-enterprise

Once Grafana is running, you can access the web UI at http://localhost:3000/login. The default login credentials are:

• Username: admin
• Password: admin

Step 4: Connecting Prometheus and Grafana
Now that both Prometheus and Grafana are running, the next step is to connect them. Grafana needs to know where to get the metrics from. Here's how you can add Prometheus as a data source in Grafana:

1. Log in to Grafana.
2. click the gear icon on the left sidebar to open the Configuration menu.
3. Select Data Sources.
4. Click Add data source.
5. Choose Prometheus as the data source type.
6. In the HTTP section, set the URL to your Prometheus instance (e.g., http://172.0.0.1:9090).
7. Click Save & Test to ensure Grafana can successfully connect to Prometheus.

---

Creating a Sample Java Project

Let's create a simple Java-based project that exposes metrics to Prometheus. We will use Micrometer, a metrics collection facade for JVM-based applications, which integrates easily with Prometheus.

Step 5: Create a Java Application

Add the necessary dependencies to your pom.xml file:
Connecting everything.

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Then, in your Java application, expose an endpoint that Prometheus can scrape. For example:

import io.micrometer.core.instrument.Metrics;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import io.micrometer.prometheus.PrometheusMeterRegistry;

@SpringBootApplication
public class MonitoringApp {

    public static void main(String[] args) {
        SpringApplication.run(MonitoringApp.class, args);
    }
}

@RestController
class MetricsController {

    private final PrometheusMeterRegistry registry;

    public MetricsController(PrometheusMeterRegistry registry) {
        this.registry = registry;
    }

    @GetMapping("/metrics")
    public String getMetrics() {
        return registry.scrape();
    }
}

This setup creates an endpoint /metrics that Prometheus can scrape. It exposes metrics collected by Micrometer and is available in the Prometheus format.

Step 6: Expose Metrics to Prometheus
Now that the Java application is collecting metrics, we need to tell Prometheus to scrape the /metrics endpoint from your application. Update your prometheus.yml configuration file to include the target:

scrape_configs:
  - job_name: 'java_application'
    static_configs:
      - targets: ['<your-app-ip>:8080']

Replace with the IP address or localhost if running on the same machine. Prometheus will now collect metrics from your Java application.

Connecting Everything

At this point, you have:

• Prometheus scraping metrics from your Java application.
• Grafana is set up as the visualization tool.

Step 7: Creating Dashboards in Grafana
To visualize the data in Grafana:

1. Go to the Dashboard tab in Grafana.
2. Click + New Dashboard.
3. Add a Panel and select Prometheus as the data source.
4. Write a PromQL query to retrieve the metrics, for example, http_requests_total.

You can now build a dashboard with various panels that show metrics like request counts, response times, and error rates.

Monitoring is crucial for maintaining high availability and performance. With tools like Prometheus and Grafana, you can easily set up an efficient monitoring solution for your Java applications.

Comments

[hem sagar Patel]

How a normal log statements will be collected in prometheus instead of this registery.scrap

[Gokul G.K]

Prometheus does not collect raw logs directly but can gather metrics derived from logs. This can be done by instrumenting your application to expose metrics based on log events or using log aggregation tools like Loki, Fluentd, or Logstash to parse logs and extract metrics. Additionally, tools like Loki allow querying logs as metrics, which Prometheus can then scrape.

[Gokul G.K]

Git Repo