Integrate Prometheus with Infobip WhatsApp API

View as Markdown

This guide is a walk-through for creating a simple monitoring and alerting system using Prometheus and Infobip's WhatsApp API. You can use this example if you already have a Prometheus server running, and want to receive alerts on your phone via WhatsApp.

To simulate the existing monitoring system, we will create a local setup with a Prometheus server configured to scrape its own metrics and evaluate alerting rules based on them. Alerts will be sent to Alertmanager. A basic Spring Boot application will receive these alerts from Alertmanager and forward them to a mobile phone via Infobip's WhatsApp API.

Products and channels [#products-channels]

This guide uses the WhatsApp channel, but it can be adapted for other channels.

Prerequisites [#prerequisites]

Docker
Infobip account (if you do not have one, you can create it here)
Infobip API key with scope: whatsapp:message:send

Technical overview [#technical-specifications-diagram]

The system consists of three main components:

Prometheus - A monitoring system that collects metrics from various sources.
Alertmanager - A component that handles alerts sent by Prometheus.
Spring Boot application - Service that listens for alerts from Alertmanager and sends them to your phone over Infobip's WhatsApp API.

The diagram below provides a high-level overview of the system we will build.

Implementation [#implementation-steps]

Step 1: Starting the project [#starting-the-project-implementation-steps]

The code used in this guide is available on GitHub(opens in new tab). You can clone it by running the following command:

shell

git clone [email protected]:infobip/prometheus-whatsapp-tutorial.git

To get the project up and running, you need to populate the .env file(opens in new tab) with your personal:

Infobip API key (with scope whatsapp:message:send)
Infobip base URL
Infobip sender phone number
Recipient phone number

Then, run the following command from the project's root directory:

shell

docker compose up --build -d

This setup will launch instances of Prometheus and Alertmanager, accessible at http://localhost:9090 and http://localhost:9093 respectively.

Additionally, a convenience UI will be available at http://localhost:8080/index.html for troubleshooting purposes. Within a few minutes, you should receive an alert on your phone.

To shut down the example, run the following command:

shell

docker compose down

Step 2: Understanding monitoring setup [#understanding-monitoring-setup-implementation-steps]

The Prometheus instance is configured to scrape its own metrics(opens in new tab) and evaluate an alerting rule(opens in new tab) that will trigger an alert after one minute.

The Alertmanager allows configuring a generic receiver of the alerts(opens in new tab). In our case, it will be an endpoint exposed(opens in new tab) by the Spring boot application.

One minute after Prometheus starts, the alert should become active. You can check it by visiting http://localhost:9090 and selecting the Alerts tab.

The same alert will also be triggered in Alertmanager. You can access it on http://localhost:9093

Step 3: Understanding Spring boot application [#understanding-spring-boot-application-implementation-steps]

The Spring boot application uses Infobip specific properties(opens in new tab) to define the API endpoint, API key, sender and receiver phone numbers.

properties

1infobip.whatsapp.base-url=https://${INFOBIP_BASE_URL}.api.infobip.com/whatsapp/1/message/text

2infobip.whatsapp.api-key=App ${INFOBIP_API_KEY}

3infobip.whatsapp.sender=${SENDER_NUMBER}

4infobip.whatsapp.receiver=${RECEIVER_NUMBER}

These properties are loaded in the properties class(opens in new tab).

java

1@Component

2@ConfigurationProperties("infobip.whatsapp")

3class InfobipProperties {

5 private String baseUrl;

6 private String apiKey;

7 private String sender;

8 private String receiver;

9 /// ...

10}

They are used in a WhatsApp client(opens in new tab) to send the message over Infobip's WhatsApp API.

java

1@Component

2class InfobipWhatsAppClient {

4 private final Logger log = LoggerFactory.getLogger(InfobipWhatsAppClient.class);

5 private final HttpClient client = HttpClient.newHttpClient();

7 private final String baseUrl;

8 private final String apiKey;

9 private final String sender;

10 private final String receiver;

12 InfobipWhatsAppClient(InfobipProperties properties) {

13 this.baseUrl = properties.getBaseUrl();

14 this.apiKey = properties.getApiKey();

15 this.sender = properties.getSender();

16 this.receiver = properties.getReceiver();

17 }

19 void sendMessage(String message) {

20 var request = HttpRequest.newBuilder()

21 .uri(URI.create(baseUrl))

22 .header("Authorization", apiKey)

23 .header("Content-Type", "application/json")

24 .header("Accept", "application/json")

25 .POST(HttpRequest.BodyPublishers.ofString(createPayload(message)))

26 .build();

28 try {

29 var response = client.send(request, HttpResponse.BodyHandlers.ofString());

30 log.info("Response: {}", response.body());

31 } catch (IOException | InterruptedException e) {

32 log.error("Failed to send message", e);

33 }

34 }

36 private String createPayload(String message) {

37 return """

38 {

39 "from": "%s",

40 "to": "%s",

41 "content": {

42 "text" : "%s"

43 }

44 }""".formatted(sender, receiver, message);

45 }

46}

The endpoint that receives alerts is defined in a listener(opens in new tab).

java

1@RestController

2class AlertsListener {

4 private final InfobipWhatsAppClient whatsAppClient;

6 AlertsListener(InfobipWhatsAppClient whatsAppClient) {

7 this.whatsAppClient = whatsAppClient;

8 }

10 @PostMapping("/send-alert")

11 void sendWhatsAppMessage(@RequestBody Alerts alerts) {

12 alerts.alerts()

13 .forEach(alert -> whatsAppClient.sendMessage(alert.text()));

14 }

16}

This endpoint uses the Alerts record(opens in new tab) to extract the subset of information from the alert sent from Alertmanager.

java

1record Alerts(List<Alert> alerts) {

3 record Alert(String status, Map<String, Object> labels, Map<String, Object> annotations) {

5 String text() {

6 var severity = (String) labels.get("severity");

7 var instance = (String) labels.get("instance");

8 var summary = (String) annotations.get("summary");

9 return """

10 %s!

11 The alert for instance running on '%s' is %s

12 %s

13 """.formatted(severity, instance, status, summary).replace("\n", "\\n");

14 }

16 }

18}

The format of the alert sent by Alertmanager can be seen here(opens in new tab).

After the application receives the alert, it will send it over Infobip's WhatsApp API. The response from Infobip API will be automatically rendered on the http://localhost:8080/index.html page.

Shortly after the alert is sent, you should receive a message on your phone.

Troubleshooting

In case the message is not delivered, you can inspect the message status by logging in to your Infobip account and navigate to Analyze → Logs where you can use the messageId from the response to check the delivery status.

Next steps [#next-steps]

This example can be extended by looking into various options Infobip offers for sending WhatsApp messages and expanded by integrating other communication channels.

Was this page helpful?