Surveillance de la santé des applications avec Java et Vonage Messages API

Introduction

La génération et l'envoi de rapports sur l'état des actionneurs est un processus important qui peut contribuer à assurer le bon fonctionnement d'une application.

Spring Boot est un cadre populaire pour la construction d'applications Java qui fournit un ensemble d'outils pour la surveillance et la gestion d'une application. L'une des fonctionnalités est l'Actuator, qui fournit un ensemble de points d'extrémité pour surveiller la santé d'une application. Ces points de terminaison peuvent être utilisés pour récupérer des informations sur les performances de l'application, telles que l'utilisation de la mémoire, l'utilisation du processeur et les temps de réponse.

En utilisant l'API Messages de Vonage, nous pouvons envoyer des rapports de santé de l'application via des textes, et en cas de problème de santé critique, nous pouvons envoyer des messages alternatifs en tant qu'alerte supplémentaire à un numéro de téléphone désigné. Dans cet article, nous verrons comment mettre en place et configurer Spring Boot pour générer des rapports de santé pour une application et les API Voice, SMS et Messages de Vonage pour les délivrer.

Spring Boot

Spring Boot est un framework basé sur Java qui est utilisé pour créer des applications autonomes de niveau production qui sont faciles à construire et à exécuter. Il est construit sur le Spring Framework et utilise ses modules pour fournir un large éventail de fonctionnalités aux développeurs. Suivre cet pour configurer un projet dans Spring Boot.

Pour activer Actuator dans votre application Spring Boot, vous devez ajouter la dépendance Spring Boot Actuator starter à votre projet et la configurer dans le fichier application.properties de votre projet, comme indiqué ci-dessous.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Ajoutez également les propriétés suivantes dans votre fichier application.properties :

management.endpoints.web.exposure.include=*
management.endpoints.web.base-path=/actuator

Les autres dépendances sont lombok et web. Actuator fournit un ensemble complet d'Applications pour vous aider à surveiller et à gérer votre application Spring Boot, et c'est un outil essentiel pour toute application Spring Boot prête pour la production.

Actionneur Spring Boot

L'actionneur offre un certain nombre de fonctions utiles telles que :

• Contrôle de santé : Actuator fournit un point de contrôle de l'état de santé. Ce point de terminaison renvoie un objet JSON qui contient des informations sur la santé de l'application, par exemple si elle est en cours d'exécution ou indisponible, et si toutes ses dépendances sont disponibles.

• Mesures : Actuator fournit un point de terminaison pour récupérer des mesures, telles que le nombre de demandes, le nombre d'erreurs et le temps de réponse.

• Journalisation : Actuator fournit un point de terminaison pour récupérer les fichiers journaux, ce qui peut être utile pour résoudre les problèmes.

• Configuration : Actuator fournit un point final pour comprendre comment l'application est configurée et pour résoudre les problèmes.

• Vidage de fil : Actuator fournit un point final pour résoudre les problèmes liés à l'utilisation de fils.

• Audit : Actuator fournit un point d'extrémité pour suivre les actions des utilisateurs, comme le nombre de demandes qu'ils ont effectuées.

• Trace HTTP : Actuator fournit un point d'extrémité pour récupérer une trace de toutes les demandes et réponses HTTP, ce qui peut être utile pour résoudre les problèmes liés à la couche HTTP de l'application.

API Messages Vonage

L'API Messages de Vonage est un ensemble de services web RESTful qui permettent aux développeurs d'envoyer et de recevoir des messages, tels que des SMS et des MMS, ainsi que des services de messages enrichis tels que WhatsApp, Viber et Facebook Messenger. L'API est conçue pour être simple à utiliser et facile à intégrer à d'autres systèmes et services.

Démarrer avec Vonage

Pour commencer à travailler avec les API de Vonage, vous devrez vous inscrire à un compte Vonage, puis créer une application dans ce compte. L'application se verra attribuer une clé et un secret API, que vous utiliserez pour authentifier vos demandes à l'API.

Vonage API Account

To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

Génération et envoi de rapports sur l'état de santé des applications - La mise en œuvre

Par souci de simplicité, nous allons suivre notre application pour les statuts où le côté serveur génère un code d'erreur 5xx pour les requêtes qui lui sont envoyées. Selon la norme des codes HTTP, 5XX implique un code d'erreur Internal Server Error. Cela signifie essentiellement que notre application peut rencontrer des difficultés nécessitant une attention particulière. Vous pouvez étendre ce principe pour gérer différents codes de réponse et divers codes de réponse, générés par votre application en réponse aux requêtes qui lui sont adressées.

Si vous souhaitez enregistrer les réponses d'Actuator, vous devez créer un modèle et un référentiel pour ce faire. Le modèle contiendra des champs qui correspondent aux paires clé-valeur de la sortie JSON de l'actionneur. Cet aspect n'est pas abordé dans cet article.

Mise en œuvre de laHttpTraceRepository

Créer une classe RemoteRepository qui implémente l'interface "HttpTraceRepository". La classe utilise les annotations "Getter" et "Setter" de la bibliothèque "lombok", qui fournissent des méthodes "getter" et "setter" pour les champs de la classe sans que le développeur ait à les écrire explicitement.

La classe possède deux méthodes qui doivent être implémentées par l'interface HttpTraceRepository : findAll() et add(HttpTrace trace). La méthode findAll() renvoie une liste vide d'objets HttpTrace et la méthode add(HttpTrace trace) prend un objet de type HttpTrace. C'est ici que votre logique entre en jeu. Dans ce cas, elle vérifie le code d'état de la réponse de cet objet trace provenant de actuator et s'il est égal à 500, il appelle les services pour envoyer des SMS via l'API Vonage. Vous pouvez également lui demander d'envoyer des messages WhatsApp.

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.actuate.trace.http.HttpTrace;
import org.springframework.boot.actuate.trace.http.HttpTraceRepository;
import java.util.Collections;
import java.util.List;

@Getter
@Setter
public class RemoteRepository implements HttpTraceRepository {

   @Override
   public List<HttpTrace> findAll() {
       return Collections.emptyList();
   }

   @Override
   public void add(HttpTrace trace) {

       int responseStatusCode = trace.getResponse().getStatus();

       if (responseStatusCode == 500) {
           // call the services to send SMS and Messages via Vonage API
       }
   }
}

L'actionneurConfiguration classe

Ensuite, créez une classe de configuration pour actuator. Cette classe de configuration, ActuatorConfigconfigure certains aspects de la fonctionnalité Actuator de Spring.

• @Configuration: Indique que cette classe contient une ou plusieurs définitions de @Bean pour le contexte d'application de Spring.

• @ConditionalOnWebApplication: Cette annotation est une fonctionnalité de Spring Boot, elle indique que cette configuration ne doit être appliquée que si l'application est une application web.

• @ConditionalOnProperty(prefix = "management.trace.http", name = "enabled", matchIfMissing = true): Cette annotation vérifie la présence d'une propriété de configuration spécifique, en l'occurrence management.trace.http.enabled dans la configuration de l'application. Si la propriété n'est pas présente, la valeur par défaut est true.

• @EnableConfigurationProperties(HttpTraceProperties.class): Cette annotation indique à Spring d'activer la prise en charge de l'injection automatique des propriétés de configuration des fichiers de configuration de l'application dans les instances de la classe spécifiée (HttpTraceProperties).

• @AutoConfigureBefore(HttpTraceAutoConfiguration.class): Cette annotation indique que la classe ActuatorConfig doit être traitée avant HttpTraceAutoConfiguration.

La classe définit également une méthode traceRepository() annotée par @Bean et @ConditionalOnMissingBean(HttpTraceRepository.class)ce qui signifie qu'elle ne sera exécutée que si aucun autre bean de type HttpTraceRepository n'a été défini dans le contexte de l'application. La méthode renvoie une nouvelle instance de RemoteRepository qui est censée être utilisée en tant qu'instance de HttpTraceRepository.

import org.springframework.boot.actuate.trace.http.HttpTraceRepository;
import org.springframework.boot.actuate.autoconfigure.trace.http.HttpTraceProperties;
import org.springframework.boot.actuate.autoconfigure.trace.http.HttpTraceAutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnWebApplication
@ConditionalOnProperty(prefix = "management.trace.http", name = "enabled", matchIfMissing = true)
@EnableConfigurationProperties(HttpTraceProperties.class)
@AutoConfigureBefore(HttpTraceAutoConfiguration.class)
public class ActuatorConfig {

	@Bean
	@ConditionalOnMissingBean(HttpTraceRepository.class)
	public RemoteRepository traceRepository() {
    	return new RemoteRepository();
	}
}

UtilitéService Classes pour les services API de Vonage

Pour chacun des services Vonage à utiliser, une classe sera créée. service sera créée. Essentiellement, une classe de service pour chacun de nos services de messagerie (SMS, WhatsApp, Viber) et un service Voice.

VoiceService classe

Pour utiliser la Voice API de Vonage afin d'envoyer un message vocal, vous devez utiliser le SDK Java de Vonage. Vous pouvez envoyer des messages vocaux à un numéro de téléphone en utilisant la synthèse vocale (TTS) ou en diffusant un fichier audio préenregistré. Voici une démonstration de l'utilisation du SDK Java de Vonage pour envoyer un message vocal :

Tout d'abord, vous devez ajouter le SDK Java de Vonage en tant que dépendance dans votre projet. Vous pouvez le faire en ajoutant le code suivant à votre fichier pom.xml si vous utilisez Maven :

<dependency>
 	<groupId>com.vonage</groupId>
    	<artifactId>client</artifactId>
    	<version>7.1.1</version>
</dependency>

Ensuite, vous devez créer une nouvelle classe qui s'occupera de l'envoi du message vocal. Dans cette classe, vous devrez importer les classes com.vonage.client.voice.Call et com.vonage.client.VonageClient. Dans cette classe, vous devrez transmettre votre identifiant d'application et votre clé privée, afin d'authentifier votre application lors des appels.

String applicationId = "your-application-id";
String privateKeyPath = "path/to/private.key";

Ensuite, créez une nouvelle instance de la classe VonageClient et indiquez votre ID d'application et le chemin d'accès à votre clé privée.

VonageClient client = VonageClient
.builder()
.applicationId(applicationId)
.privateKeyPath(privateKey)
.build();

Vous pouvez maintenant créer une nouvelle instance de la classe Call et définir les propriétés from, to et answer_url. La propriété from est le numéro de téléphone ou le numéro virtuel à partir duquel vous envoyez le message, la propriété to est le numéro auquel vous envoyez le message, et la propriété answer_url est l'URL qui sera demandée lorsque l'appel sera pris.

Call call = new Call();
call.setFrom(FROM_NUMBER);
call.setTo(TO_NUMBER);
call.setAnswerUrl(ANSWER_URL);

Pour simplifier, créez une classe VonageClientProvider dans laquelle vous créez une instance de votre client Vonage - avec vos informations d'identification. C'est essentiel pour ne pas avoir à répéter le code dans d'autres classes.

import com.vonage.client.VonageClient;

public class VonageClientProvider {

    private static final String APPLICATION_ID = "VONAGE_APPLICATION_ID";
    private static final String PRIVATE_KEY = "VONAGE_PRIVATE_KEY_PATH";
    private static VonageClient instance;

    private VonageClientProvider() {}

    public static VonageClient getInstance() {
        if (instance == null) {
            instance = VonageClient.builder()
                    .applicationId(APPLICATION_ID)
                    .privateKeyPath(PRIVATE_KEY)
                    .build();
        }

        return instance;
    }
}

messagesService classe

Voici une classe en Java qui montre comment envoyer un SMS, un message WhatsApp et un message Viber à l'aide de l'API Messages de Vonage :

import com.vonage.client.VonageClient;
import com.vonage.client.messages.MessageResponse;
import com.vonage.client.messages.MessagesClient;
import com.vonage.client.messages.sms.SmsTextRequest;
import com.vonage.client.messages.viber.Category;
import com.vonage.client.messages.viber.ViberTextRequest;
import com.vonage.client.messages.whatsapp.WhatsappTextRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class MessagingService {

    private static final String VONAGE_NUMBER = "YOUR_VONAGE_NUMBER_HERE";

    public static void sendSms(String toNumber, String text) {

        VonageClient client = VonageClientProvider.getInstance();

        MessagesClient smsClient = client.getMessagesClient();

        var message = SmsTextRequest.builder()
                .from(VONAGE_NUMBER).to(toNumber)
                .text(text)
                .build();


            MessageResponse response = smsClient.sendMessage(message);
            log.info("Message sent successfully. ID: "+response.getMessageUuid());

    }

    public static void sendWhatsApp(String toNumber, String text) {

        VonageClient client = VonageClientProvider.getInstance();

        MessagesClient whatsAppClient = client.getMessagesClient();

        var message = WhatsappTextRequest.builder()
                .from(VONAGE_NUMBER).to(toNumber)
                .text(text)
                .build();

            MessageResponse response = whatsAppClient.sendMessage(message);
            log.info("Message sent successfully. ID: "+response.getMessageUuid());
    }

sendViber() méthode

public static void sendViber(String toNumber, String text) {

        VonageClient client = VonageClientProvider.getInstance();

        MessagesClient viberClient = client.getMessagesClient();

        var message = ViberTextRequest.builder()
                .from(VONAGE_NUMBER).to(toNumber)
                .text(text)
                .category(Category.TRANSACTION)
                .build();

            MessageResponse response = viberClient.sendMessage(message);
            log.info("Message sent successfully. ID: " + response.getMessageUuid());
    }

AméliorationRemoteRepository classe

Tous les services nécessaires à l'envoi de messages via l'API Vonage ont été créés. Allez dans la classe RemoteRepository et branchez chacun de ces services de façon à ce que, lorsqu'un message "500 - Internal Server Error" est généré, chacun de ces services soit appelé et exécuté dans l'ordre et dans le format que vous souhaitez. La structure complète de la classe RemoteRepository est présentée ci-dessous :

import com.vonage.tracer.service.MessagingService;
import com.vonage.tracer.service.VoiceService;
import lombok.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.trace.http.HttpTrace;
import org.springframework.boot.actuate.trace.http.HttpTraceRepository;

import java.util.Collections;
import java.util.List;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class RemoteRepository implements HttpTraceRepository {
    @Autowired
    private MessagingService messagingService;

    @Autowired
    private VoiceService voiceService;

    @Override
    public List<HttpTrace> findAll() {
        return Collections.emptyList();
    }

    @SneakyThrows
    @Override
    public void add(HttpTrace trace) {

        int responseStatusCode = trace.getResponse().getStatus();
        String errorMessage = "Check Server - 500 generated. Kindly check the server for an Internal Server Error";

        if (responseStatusCode == 500) {

            // call the services to send SMS, Messaging and Voice Messages via Vonage API

            MessagingService.sendSms(
                    "<sender-number-here",
                    "<recipient-number-here"
            );

            MessagingService.sendWhatsApp(
                    "<recipient-number-here", errorMessage
                    );

            MessagingService.sendViber(
                    "<recipient-number-here", errorMessage);

            voiceService.sendVoiceMessage(
                    "<recipient-here", errorMessage);

        }
    }
}

Vous pouvez maintenant créer vos contrôleurs et chaque fois qu'un appel est fait à votre application et qu'il résulte en un code de réponse de 500, les services seront appelés l'un après l'autre. Vous avez la liberté de contrôler la façon dont cela fonctionne, mais cela devrait vous mettre sur la voie de grandes choses.

Conclusion

Dans cet article, nous avons vu comment générer et envoyer des messages à des adresses ou emplacements respectifs lorsqu'un code d'erreur HTTP 500 est créé par notre serveur. Avec ceci, vous pouvez vérifier le contenu de l'objet trace d'Actuator et voir quelles autres choses vous pouvez faire avec. Vous pouvez également faire beaucoup plus avec l'API de Vonage. Consultez la documentation ici. Le code de cet article se trouve ici également.

Venez rejoindre la conversation sur Slack de la communauté Vonage ou envoyez un message sur Twitter.