Überwachung des Anwendungsstatus mit Java und Vonage Messages API

Einführung

Das Erstellen und Versenden von Zustandsberichten für Aktoren ist ein wichtiger Prozess, der den reibungslosen Betrieb einer Anwendung sicherstellen kann.

Spring Boot ist ein beliebtes Framework für die Erstellung von Java-Anwendungen, das eine Reihe von Tools für die Überwachung und Verwaltung einer Anwendung bietet. Eine Funktion ist der Actuator, der eine Reihe von Endpunkten zur Überwachung des Zustands einer Anwendung bereitstellt. Diese Endpunkte können verwendet werden, um Informationen über die Leistung der Anwendung abzurufen, z. B. Speichernutzung, CPU-Nutzung und Antwortzeiten.

Durch die Verwendung der Vonage Messages API können wir Zustandsberichte über die Anwendung per Text senden und im Falle kritischer Probleme können wir alternative Nachrichten als zusätzlichen Alarm an eine bestimmte Telefonnummer senden. In diesem Artikel wird besprochen, wie Spring Boot eingerichtet und konfiguriert wird, um Zustandsberichte für eine Applikation und die Voice-, SMS- und Messages-APIs von Vonage zu generieren, um diese zu liefern.

Spring Boot

Spring Boot ist ein Java-basiertes Framework, mit dem eigenständige, produktionsreife Anwendungen erstellt werden können, die einfach zu erstellen und auszuführen sind. Es baut auf dem Spring Framework auf und nutzt dessen Module, um Entwicklern eine breite Palette von Funktionen zur Verfügung zu stellen. Folgen Sie diesem Artikel, um ein Projekt in Spring Boot einzurichten.

Um Actuator in Ihrer Spring Boot-Anwendung zu aktivieren, müssen Sie die Spring Boot Actuator-Starter-Abhängigkeit zu Ihrem Projekt hinzufügen und sie in der application.properties Datei Ihres Projekts konfigurieren, wie unten gezeigt.

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

Fügen Sie außerdem die folgenden Eigenschaften in Ihre Datei application.properties ein:

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

Weitere Abhängigkeiten sind lombok und web. Actuator bietet eine umfassende Reihe von Funktionen, die Sie bei der Überwachung und Verwaltung Ihrer Spring Boot-Anwendung unterstützen, und ist ein unverzichtbares Werkzeug für jede produktionsbereite Spring Boot-Anwendung.

Spring Boot Aktuator

Der Aktuator bietet eine Reihe nützlicher Funktionen wie z. B.:

• Gesundheitsprüfung: Actuator bietet einen Endpunkt für die Zustandsprüfung. Dieser Endpunkt gibt ein JSON-Objekt zurück, das Informationen über den Zustand der Anwendung enthält, z. B. ob sie derzeit ausgeführt wird oder nicht verfügbar ist und ob alle ihre Abhängigkeiten verfügbar sind.

• Metriken: Actuator bietet einen Endpunkt zum Abrufen von Metriken, wie z. B. die Anzahl der Anfragen, die Anzahl der Fehler und die Antwortzeit.

• Protokollierung: Actuator bietet einen Endpunkt zum Abrufen von Protokolldateien, die bei der Fehlersuche nützlich sein können.

• Konfiguration: Actuator bietet einen Endpunkt, um zu verstehen, wie die Anwendung konfiguriert ist und um Probleme zu beheben.

• Thread-Dump: Actuator bietet einen Endpunkt für die Fehlersuche bei Problemen im Zusammenhang mit Threading.

• Überprüfungen: Actuator bietet einen Endpunkt, um die Aktionen der Benutzer zu verfolgen, z. B. die Anzahl der Anfragen, die sie gestellt haben.

• HTTP-Verfolgung: Actuator bietet einen Endpunkt zum Abrufen eines Trace aller HTTP-Anfragen und -Antworten, was bei der Fehlersuche im Zusammenhang mit der HTTP-Schicht der Anwendung hilfreich sein kann.

Vonage Messages API

Die Vonage Messages API ist eine Reihe von RESTful-Webdiensten, die es Entwicklern ermöglichen, Nachrichten wie SMS und MMS zu senden und zu empfangen, sowie Rich-Messages-Dienste wie WhatsApp, Viber und Facebook Messenger. Die API ist so konzipiert, dass sie einfach zu bedienen ist und sich leicht in andere Systeme und Dienste integrieren lässt.

Erste Schritte mit Vonage

Um mit den Vonage APIs arbeiten zu können, müssen Sie sich für einen Vonage Account anmelden und dann eine Anwendung innerhalb dieses Accounts erstellen. Der Anwendung werden ein API-Schlüssel und ein Geheimnis zugewiesen, die Sie zur Authentifizierung Ihrer Anfragen an die API verwenden.

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Erstellung und Versand von Anwendungszustandsberichten - Die Implementierung

Der Einfachheit halber werden wir unsere Anwendung auf Zustände überprüfen, bei denen die Serverseite einen 5xx-Fehlercode für an sie gesendete Anfragen erzeugt. Nach dem HTTP-Codes-Standard bedeutet 5XX eine Internal Server Error. Dies bedeutet im Wesentlichen, dass unsere Anwendung möglicherweise einige Probleme hat, die Aufmerksamkeit erfordern. Sie können dies erweitern, um verschiedene Antwortcodes und diverse Antwortcodes zu behandeln, die von Ihrer Anwendung als Antwort auf Anfragen an sie generiert werden.

Wenn Sie die Antworten von Actuator speichern möchten, müssen Sie dazu ein Modell und ein Repository erstellen. Das Modell wird Felder enthalten, die den Schlüssel-Wert-Paaren der JSON-Ausgabe von Actuator entsprechen. Dies wird in diesem Artikel nicht behandelt.

Die Umsetzung derHttpTraceRepository

Erstellen Sie eine Klasse RemoteRepository die die Schnittstelle "HttpTraceRepository" implementiert. Die Klasse verwendet die "Getter"- und "Setter"-Anmerkungen aus der "lombok"-Bibliothek, die Getter- und Setter-Methoden für die Felder der Klasse bereitstellen, ohne dass der Entwickler sie explizit schreiben muss.

Die Klasse hat zwei Methoden, die von der HttpTraceRepository-Schnittstelle implementiert werden müssen: findAll() und add(HttpTrace trace). Die Methode findAll() gibt eine leere Liste von HttpTrace-Objekten zurück, und die Methode add(HttpTrace trace) nimmt ein Objekt vom Typ HttpTrace an. Hier kommt Ihre Logik ins Spiel. In diesem Fall wird der Antwortstatuscode des Trace-Objekts, das von actuator kommt, und wenn er gleich 500 ist, ruft sie Dienste auf, um SMS-Nachrichten über die Vonage API zu senden. Sie können es auch anweisen, WhatsApp-Nachrichten zu senden.

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
       }
   }
}

Der AktuatorConfiguration Klasse

Als nächstes erstellen Sie eine Konfigurationsklasse für actuator. Diese Konfigurationsklasse, ActuatorConfigkonfiguriert bestimmte Aspekte der Aktuator-Funktion von Spring.

• @Configuration: Zeigt an, dass diese Klasse eine oder mehrere @Bean-Definitionen für den Anwendungskontext von Spring enthält.

• @ConditionalOnWebApplication: Diese Annotation ist ein Spring Boot-Feature und zeigt an, dass diese Konfiguration nur angewendet werden soll, wenn die Anwendung eine Webanwendung ist.

• @ConditionalOnProperty(prefix = "management.trace.http", name = "enabled", matchIfMissing = true): Diese Anmerkung prüft das Vorhandensein einer bestimmten Konfigurationseigenschaft, in diesem Fall management.trace.http.enabled in der Konfiguration der Anwendung. Ist die Eigenschaft nicht vorhanden, wird sie standardmäßig auf true gesetzt.

• @EnableConfigurationProperties(HttpTraceProperties.class): Diese Annotation weist Spring an, die Unterstützung für die automatische Injektion von Konfigurationseigenschaften aus den Konfigurationsdateien der Anwendung in Instanzen der angegebenen Klasse (HttpTraceProperties) zu aktivieren.

• @AutoConfigureBefore(HttpTraceAutoConfiguration.class): Diese Anmerkung zeigt an, dass die ActuatorConfig-Klasse vor HttpTraceAutoConfiguration verarbeitet werden sollte.

Die Klasse definiert auch eine Methode traceRepository() kommentiert mit @Bean und @ConditionalOnMissingBean(HttpTraceRepository.class)annotiert ist, was bedeutet, dass sie nur ausgeführt wird, wenn im Anwendungskontext keine andere Bean vom Typ HttpTraceRepository definiert ist. Die Methode gibt eine neue Instanz von RemoteRepository zurück, von der erwartet wird, dass sie als eine 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();
	}
}

DienstprogrammService Klassen für Vonage API-Dienste

Für jeden der Vonage-Dienste, mit dem gearbeitet werden soll, wird eine service Klasse erstellt werden. Im Wesentlichen eine Serviceklasse für jeden unserer Nachrichtendienste (SMS, WhatsApp, Viber) und einen Voice-Dienst.

VoiceService Klasse

Um die Vonage Voice API zum Versenden von Sprachnachrichten zu nutzen, müssen Sie das Java SDK von Vonage verwenden. Sie können Sprachnachrichten an eine Telefonnummer senden, indem Sie Text-to-Speech (TTS) verwenden oder eine zuvor aufgezeichnete Audiodatei abspielen. Hier sehen Sie eine Demonstration, wie Sie mit dem Vonage Java SDK eine Sprachnachricht versenden können:

Zunächst müssen Sie das Vonage Java SDK als Abhängigkeit in Ihr Projekt aufnehmen. Sie können dies tun, indem Sie den folgenden Code zu Ihrer pom.xml-Datei hinzufügen, wenn Sie Maven verwenden:

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

Als Nächstes müssen Sie eine neue Klasse erstellen, die das Senden der Sprachnachricht übernimmt. In dieser Klasse müssen Sie die Klassen com.vonage.client.voice.Call und com.vonage.client.VonageClient importieren. In dieser Klasse müssen Sie Ihre Application ID und Ihren privaten Schlüssel übergeben, um Ihre Anwendung bei Anrufen zu authentifizieren.

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

Als nächstes erstellen Sie eine neue Instanz der VonageClient Klasse und geben Sie Ihre Anwendungs-ID und den Pfad zu Ihrem privaten Schlüssel an.

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

Nun können Sie eine neue Instanz der Klasse Call erstellen und die Eigenschaften from, to und answer_url festlegen. Die Eigenschaft from Eigenschaft ist die Telefonnummer oder virtuelle Nummer, von der Sie die Nachricht senden, die to Eigenschaft ist die Nummer, an die Sie die Nachricht senden, und die answer_url ist die URL, die angefordert wird, wenn der Anruf beantwortet wird.

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

Der Einfachheit halber erstellen Sie eine Klasse VonageClientProvider in der Sie eine Instanz Ihres Vonage-Clients erstellen - mit Ihren Anmeldedaten. Dies ist wichtig, damit Sie den Code in anderen Klassen nicht wiederholen müssen.

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 Klasse

Hier ist eine Klasse in Java, die zeigt, wie man eine SMS, eine WhatsApp-Nachricht und eine Viber-Nachricht mit der Vonage Messages API sendet:

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() Methode

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());
    }

Verbesserung vonRemoteRepository Klasse

Alle Dienste, die für den Versand von Nachrichten über die Vonage-API erforderlich sind, wurden nun erstellt. Gehen Sie in die RemoteRepository Klasse und verdrahten Sie jeden dieser Dienste automatisch, so dass bei einem "500 - Internal Server Error" jeder dieser Dienste in der von Ihnen gewünschten Reihenfolge und dem gewünschten Format aufgerufen und ausgeführt wird. Die vollständige Struktur der RemoteRepository Klasse ist unten dargestellt:

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);

        }
    }
}

Nun können Sie Ihre Controller erstellen und bei jedem Aufruf Ihrer Anwendung, der zu einem Antwortcode von 500 führt, werden die Dienste einer nach dem anderen aufgerufen. Sie haben die Freiheit zu kontrollieren, wie dies funktioniert, aber dies sollte Sie auf den Weg zu großen Dingen bringen.

Schlussfolgerung

In diesem Artikel haben wir uns angesehen, wie man Nachrichten generiert und an die entsprechenden Adressen oder Standorte sendet, wenn ein HTTP-Fehlercode 500 von unserem Server erzeugt wird. Damit können Sie den Inhalt des Trace-Objekts von Actuator überprüfen und sehen, welche anderen Dinge Sie damit tun können. Sie können auch viel mehr mit der Vonage API machen. Sehen Sie sich die Dokumentation hier an. Den Code für diesen Artikel finden Sie hier auch.

Beteiligen Sie sich an der Diskussion auf Vonage Gemeinschaft Slack oder senden Sie eine Nachricht auf Twitter.