Refactor HelperGatusToMona to conditionally execute heartbeat and update performance message logic; update project dependencies and configuration models

.vscode/tasks.json

@@ -50,9 +50,7 @@
                 "build",
                 "-r",
                 "win-x64",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
             ],
             "problemMatcher": "$msCompile"
         },
@@ -64,9 +62,7 @@
                 "build",
                 "-r",
                 "linux-x64",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
             ],
             "problemMatcher": "$msCompile"
         },
@@ -91,9 +87,7 @@
                 "-c",
                 "Release",
                 "-p:PublishAot=true",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
             ],
             "problemMatcher": "$msCompile"
         },
@@ -108,9 +102,7 @@
                 "-c",
                 "Release",
                 "-p:PublishAot=true",
-                "${workspaceFolder}/Gatus-to-MonA.csproj",
+                "${workspaceFolder}/Gatus-to-MonA.csproj"
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
             ],
             "problemMatcher": "$msCompile"
         },

Gatus-to-MonA.csproj

@@ -16,7 +16,7 @@
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.EventLog" Version="8.0.1" />
-    <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.15" />
+    <PackageReference Include="runtime.win-x64.Microsoft.DotNet.ILCompiler" Version="8.0.21" />
     <PackageReference Include="System.Text.Json" Version="9.0.2" />
   </ItemGroup>
 </Project>

Helpers/HelperGatusToMona.cs

@@ -1,17 +1,44 @@
 using System.Collections.ObjectModel;
 using System.Net.Http.Headers;
 
+using Gatus.To.MonA.Infineon.Monitoring.MonA;
 using Gatus.To.MonA.Models;
 
 namespace Gatus.To.MonA.Helpers;
 
 internal static partial class HelperGatusToMona {
 
+    private static IMonIn? _MonIn;
     private static HttpClient? _HttpClient;
 
     private static string GetFile(AppSettings appSettings) =>
         Path.Combine(appSettings.GatusToMonaConfiguration.Directory, appSettings.GatusConfiguration.FileName);
 
+    internal static void Heartbeat(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, State state, CancellationToken cancellationToken) {
+        CreateEmptyFile(appSettings);
+        if (appSettings.MonAConfiguration.Use) {
+            _MonIn ??= MonIn.GetInstance(httpClientFactory);
+            Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendStatus(appSettings.MonAConfiguration.Site,
+                                                                              appSettings.MonAConfiguration.Resource,
+                                                                              appSettings.MonAConfiguration.StateName,
+                                                                              state);
+            httpResponseMessage.Wait(cancellationToken);
+            logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {StateName} ; {state}",
+                                  27,
+                                  httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
+                                  appSettings.MonAConfiguration.Resource,
+                                  appSettings.MonAConfiguration.StateName,
+                                  state);
+            if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+                throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+            Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
+            body.Wait(cancellationToken);
+            logger.LogInformation("Line {line}: {Result}",
+                                  37,
+                                  body.Result);
+        }
+    }
+
     private static void CreateEmptyFile(AppSettings appSettings) {
         if (!Directory.Exists(appSettings.GatusToMonaConfiguration.Directory))
             _ = Directory.CreateDirectory(appSettings.GatusToMonaConfiguration.Directory);
@@ -21,18 +48,58 @@ internal static partial class HelperGatusToMona {
 
     internal static bool UpdateCount(AppSettings appSettings, IHttpClientFactory httpClientFactory, ILogger<Worker> logger, CancellationToken cancellationToken) {
         _HttpClient ??= httpClientFactory.CreateClient();
-        ReadOnlyCollection<string> successMatches = GetSuccessMatches(appSettings, logger, cancellationToken);
+        if (appSettings.MonAConfiguration.Use) {
-        decimal value = GetValue(appSettings, successMatches);
+            _MonIn ??= MonIn.GetInstance(httpClientFactory);
+            Heartbeat(appSettings, httpClientFactory, logger, State.Up, cancellationToken);
+        }
+        ReadOnlyCollection<string> lines = DownloadThenReadAllLinesMaybeSync(appSettings, logger, cancellationToken);
+        ReadOnlyCollection<string> successMatches = GetSuccessMatches(appSettings, logger, lines);
+        double value = (double)GetValue(appSettings, successMatches);
+        if (appSettings.MonAConfiguration.Use) {
+            SendPerformanceMessage(appSettings, logger, value, cancellationToken);
+        }
         SendPerformanceMessage(appSettings, logger, _HttpClient, value, cancellationToken);
         return true;
     }
 
-    private static ReadOnlyCollection<string> GetSuccessMatches(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken) {
+    private static ReadOnlyCollection<string> DownloadThenReadAllLinesMaybeSync(AppSettings appSettings, ILogger<Worker> logger, CancellationToken cancellationToken) {
+        string[] results;
+        string file = GetFile(appSettings);
+        DownloadLines(appSettings, file, cancellationToken);
+        results = File.ReadAllLines(file);
+        if (!string.IsNullOrEmpty(appSettings.GatusToMonaConfiguration.SyncDirectory)) {
+            string text = string.Join(Environment.NewLine, results);
+            string path = Path.Combine(appSettings.GatusToMonaConfiguration.SyncDirectory, appSettings.GatusConfiguration.FileName);
+            try {
+                if (!Directory.Exists(appSettings.GatusToMonaConfiguration.SyncDirectory))
+                    _ = Directory.CreateDirectory(appSettings.GatusToMonaConfiguration.SyncDirectory);
+                File.WriteAllText(path, text);
+                Directory.SetLastWriteTime(appSettings.GatusToMonaConfiguration.SyncDirectory, DateTime.Now);
+            } catch (Exception ex) {
+                logger.LogInformation("Exception {ex}: {ex}",
+                                      80,
+                                      $"{ex.Message}{Environment.NewLine}{ex.StackTrace}");
+            }
+        }
+        return results.AsReadOnly();
+    }
+
+    private static void DownloadLines(AppSettings appSettings, string file, CancellationToken cancellationToken) {
+        FileStream fileStream = new(file, FileMode.Truncate);
+        HttpClient httpClient = new();
+        Task<Stream> streamTask = httpClient.GetStreamAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/metrics", cancellationToken);
+        streamTask.Wait(cancellationToken);
+        Task task = streamTask.Result.CopyToAsync(fileStream, cancellationToken);
+        task.Wait(cancellationToken);
+        fileStream.Dispose();
+        streamTask.Dispose();
+        httpClient.Dispose();
+    }
+
+    private static ReadOnlyCollection<string> GetSuccessMatches(AppSettings appSettings, ILogger<Worker> logger, ReadOnlyCollection<string> lines) {
         List<string> results = [];
         string value;
         string[] segments;
-        string file = GetFile(appSettings);
-        ReadOnlyCollection<string> lines = GetLines(appSettings, file, cancellationToken);
         foreach (string line in lines) {
             if (!line.StartsWith(appSettings.GatusConfiguration.Metric))
                 continue;
@@ -45,32 +112,17 @@ internal static partial class HelperGatusToMona {
             if (value[^1] is not '0' and not '1')
                 continue;
             logger.LogInformation("Line {line}: {value}",
-                                  76,
+                                  115,
                                   value);
             if (line.EndsWith('1'))
                 results.Add(string.Concat('{', value));
         }
         logger.LogInformation("Line {line}: {results}",
-                              82,
+                              121,
                               string.Join(Environment.NewLine, results));
         return results.AsReadOnly();
     }
 
-    private static ReadOnlyCollection<string> GetLines(AppSettings appSettings, string file, CancellationToken cancellationToken) {
-        string[] results;
-        FileStream fileStream = new(file, FileMode.Truncate);
-        HttpClient httpClient = new();
-        Task<Stream> streamTask = httpClient.GetStreamAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/metrics", cancellationToken);
-        streamTask.Wait(cancellationToken);
-        Task task = streamTask.Result.CopyToAsync(fileStream, cancellationToken);
-        task.Wait(cancellationToken);
-        fileStream.Dispose();
-        streamTask.Dispose();
-        httpClient.Dispose();
-        results = File.ReadAllLines(file);
-        return results.AsReadOnly();
-    }
-
     private static decimal GetValue(AppSettings appSettings, ReadOnlyCollection<string> successMatches) {
         decimal result;
         decimal v = successMatches.Count / appSettings.MonAConfiguration.Expected;
@@ -78,34 +130,59 @@ internal static partial class HelperGatusToMona {
         return result;
     }
 
-    private static void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, HttpClient httpClient, decimal value, CancellationToken cancellationToken) {
+    private static void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, double value, CancellationToken cancellationToken) {
-        string success = value == 100 ? "true" : "false";
+        string performanceName = string.Concat(appSettings.MonAConfiguration.Resource, appSettings.MonAConfiguration.Suffix);
-        string error = value == 100 ? string.Empty : $"value: {value}%;";
+        Task<HttpResponseMessage> httpResponseMessage = _MonIn.SendPerformanceMessage(appSettings.MonAConfiguration.Site,
-        // httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusConfiguration.Token);
+                                                                                      appSettings.MonAConfiguration.Resource,
-        // httpResponseMessage = httpClient.PostAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusConfiguration.Key}/external?success={success}&error={error}", null, cancellationToken);
+                                                                                      performanceName,
-        // httpResponseMessage.Wait(cancellationToken);
+                                                                                      value,
-        // logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {Key} ; {value}",
+                                                                                      description: string.Empty);
-        //                       140,
-        //                       httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
-        //                       appSettings.MonAConfiguration.Resource,
-        //                       appSettings.GatusConfiguration.Key,
-        //                       value);
-        // if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
-        //     throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
-        // if (!string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.BaseUniformResourceLocator)
-        //     && !string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.Key)
-        //     && !string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.Token)) { }
-        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusToGatusConfiguration.Token);
-        Task<HttpResponseMessage> httpResponseMessage = httpClient.PostAsync($"{appSettings.GatusToGatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusToGatusConfiguration.Key}/external?success={success}&error={error}", null, cancellationToken);
         httpResponseMessage.Wait(cancellationToken);
-        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {Key} ; {value}",
+        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {performanceName} ; {value}",
-                              154,
+                              142,
                               httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
                               appSettings.MonAConfiguration.Resource,
-                              appSettings.GatusToGatusConfiguration.Key,
+                              performanceName,
                               value);
         if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
             throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+        Task<string> body = httpResponseMessage.Result.Content.ReadAsStringAsync(cancellationToken);
+        body.Wait(cancellationToken);
+        logger.LogInformation("Line {line}: {Result}",
+                              152,
+                              body.Result);
+    }
+
+    private static void SendPerformanceMessage(AppSettings appSettings, ILogger<Worker> logger, HttpClient httpClient, double value, CancellationToken cancellationToken) {
+        Task<HttpResponseMessage> httpResponseMessage;
+        string success = value == 100 ? "true" : "false";
+        string error = value == 100 ? string.Empty : $"value: {value}%;";
+        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusConfiguration.Token);
+        httpResponseMessage = httpClient.PostAsync($"{appSettings.GatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusConfiguration.Key}/external?success={success}&error={error}", null, cancellationToken);
+        httpResponseMessage.Wait(cancellationToken);
+        logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {Key} ; {value}",
+                              164,
+                              httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
+                              appSettings.MonAConfiguration.Resource,
+                              appSettings.GatusConfiguration.Key,
+                              value);
+        if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+            throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+        if (!string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.BaseUniformResourceLocator)
+            && !string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.Key)
+            && !string.IsNullOrEmpty(appSettings.GatusToGatusConfiguration.Token)) {
+            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", appSettings.GatusToGatusConfiguration.Token);
+            httpResponseMessage = httpClient.PostAsync($"{appSettings.GatusToGatusConfiguration.BaseUniformResourceLocator}/api/v1/endpoints/{appSettings.GatusToGatusConfiguration.Key}/external?success={success}&error={error}", null, cancellationToken);
+            httpResponseMessage.Wait(cancellationToken);
+            logger.LogInformation("Line {line}: {OriginalString} => {Resource} : {Key} ; {value}",
+                                  178,
+                                  httpResponseMessage.Result.RequestMessage.RequestUri.OriginalString,
+                                  appSettings.MonAConfiguration.Resource,
+                                  appSettings.GatusToGatusConfiguration.Key,
+                                  value);
+            if (httpResponseMessage.Result.StatusCode != System.Net.HttpStatusCode.OK)
+                throw new Exception(httpResponseMessage.Result.StatusCode.ToString());
+        }
     }
 
 }

Infineon/Monitoring/MonA/IMonIn.cs

@@ -0,0 +1,144 @@
+namespace Gatus.To.MonA.Infineon.Monitoring.MonA;
+
+public interface IMonIn {
+    Task<HttpResponseMessage> SendStatus(string site, string resource, string stateName, State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime timeStamp,
+                                         string resource,
+                                         string stateName,
+                                         State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         string resource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime timeStamp,
+                                         string resource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime timeStamp,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendStatus(string site,
+                                         DateTime? timeStamp,
+                                         string resource,
+                                         string subResource,
+                                         string stateName,
+                                         State state,
+                                         string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     int? interval);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     DateTime? timeStamp,
+                                                     string performanceName,
+                                                     double value,
+                                                     string unit);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string unit,
+                                                     int? interval);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     int? interval);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string unit);
+
+    Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                     DateTime? timeStamp,
+                                                     string resource,
+                                                     string subResource,
+                                                     string performanceName,
+                                                     double value,
+                                                     string description,
+                                                     string unit,
+                                                     int? interval);
+}

Infineon/Monitoring/MonA/MonIn.cs

@@ -0,0 +1,250 @@
+using System.Globalization;
+using System.Text;
+
+namespace Gatus.To.MonA.Infineon.Monitoring.MonA;
+
+public class MonIn : IMonIn {
+    private readonly string _MonInUrl;
+    private readonly HttpClient _HttpClient;
+    private static CultureInfo? _CultureInfo;
+    private static readonly Dictionary<string, MonIn> _Instances = [];
+    public const string MonInUrl = "http://moninhttp.{0}.infineon.com/input/text";
+    private static readonly DateTime _Utc1970DateTime = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+    public Task<HttpResponseMessage> SendStatus(string site, string resource, string stateName, State state) =>
+        SendStatus(site, new DateTime?(), resource, string.Empty, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                DateTime timeStamp,
+                                                string resource,
+                                                string stateName,
+                                                State state) =>
+        SendStatus(site, new DateTime?(timeStamp), resource, string.Empty, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                string resource,
+                                                string stateName,
+                                                State state,
+                                                string description) =>
+        SendStatus(site, new DateTime?(), resource, string.Empty, stateName, state, description);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                DateTime timeStamp,
+                                                string resource,
+                                                string stateName,
+                                                State state,
+                                                string description) =>
+        SendStatus(site, new DateTime?(timeStamp), resource, string.Empty, stateName, state, description);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                string resource,
+                                                string subResource,
+                                                string stateName,
+                                                State state) =>
+        SendStatus(site, new DateTime?(), resource, subResource, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                DateTime timeStamp,
+                                                string resource,
+                                                string subResource,
+                                                string stateName,
+                                                State state) =>
+        SendStatus(site, new DateTime?(timeStamp), resource, subResource, stateName, state, string.Empty);
+
+    public Task<HttpResponseMessage> SendStatus(string site,
+                                                string resource,
+                                                string subResource,
+                                                string stateName,
+                                                State state,
+                                                string description) =>
+        SendStatus(site, new DateTime?(), resource, subResource, stateName, state, description);
+
+    public Task<HttpResponseMessage> SendStatus(
+      string site,
+      DateTime? timeStamp,
+      string resource,
+      string subResource,
+      string stateName,
+      State state,
+      string description) {
+        string statusMessage = CreateStatusMessage(site, timeStamp, resource, subResource, stateName, state.ToString(), description);
+        StringContent stringContent = new(statusMessage, Encoding.UTF8, "application/text");
+        lock (_HttpClient)
+            return _HttpClient.PostAsync(string.Format(_MonInUrl, site), stringContent);
+    }
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, string.Empty, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, string.Empty, performanceName, value, description, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, description, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            int? interval) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, string.Empty, interval);
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            DateTime? timeStamp,
+                                                            string performanceName,
+                                                            double value,
+                                                            string unit) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, unit, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string unit,
+                                                            int? interval) =>
+        SendPerformanceMessage(site, timeStamp, resource, string.Empty, performanceName, value, string.Empty, unit, interval);
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, subResource, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value) =>
+        SendPerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, string.Empty, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description) =>
+        SendPerformanceMessage(site, new DateTime?(), resource, subResource, performanceName, value, description, string.Empty, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            int? interval) =>
+        SendPerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, string.Empty, string.Empty, interval);
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string unit) =>
+        SendPerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, string.Empty, unit, new int?());
+
+    public Task<HttpResponseMessage> SendPerformanceMessage(string site,
+                                                            DateTime? timeStamp,
+                                                            string resource,
+                                                            string subResource,
+                                                            string performanceName,
+                                                            double value,
+                                                            string description,
+                                                            string unit,
+                                                            int? interval) {
+        string performanceMessage = CreatePerformanceMessage(site, timeStamp, resource, subResource, performanceName, value, description, unit, interval);
+        StringContent stringContent = new(performanceMessage, Encoding.UTF8, "application/text");
+        lock (_HttpClient)
+            return _HttpClient.PostAsync(string.Format(_MonInUrl, site), stringContent);
+    }
+
+    private static string CreateStatusMessage(string site,
+                                              DateTime? timeStamp,
+                                              string resource,
+                                              string subResource,
+                                              string stateName,
+                                              string state,
+                                              string description) {
+        StringBuilder stringBuilder = new();
+        if (string.IsNullOrEmpty(subResource))
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" {4} \n{5}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), stateName.Trim(), state.Trim(), description.Trim());
+        else
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" \"{4}\" {5} \n{6}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), subResource.Trim(), stateName.Trim(), state.Trim(), description.Trim());
+        return stringBuilder.ToString();
+    }
+
+    private static string CreatePerformanceMessage(string site,
+                                                   DateTime? timeStamp,
+                                                   string resource,
+                                                   string subResource,
+                                                   string performanceName,
+                                                   double value,
+                                                   string description,
+                                                   string unit,
+                                                   int? interval) {
+        StringBuilder stringBuilder = new();
+        if (string.IsNullOrEmpty(subResource)) {
+            if (unit.Equals(string.Empty) && !interval.HasValue)
+                _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" {4} \n{5}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), performanceName.Trim(), value, description.Trim());
+            else
+                _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" {4} {5} {{interval={6}, unit={7}}}\n", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), performanceName.Trim(), value, description.Trim(), interval.HasValue ? interval.Value.ToString() : (object)string.Empty, unit.Trim());
+        } else if (unit.Equals(string.Empty) && !interval.HasValue)
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" \"{4}\" {5} \n{6}", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), subResource.Trim(), performanceName.Trim(), value, description.Trim());
+        else
+            _ = stringBuilder.AppendFormat(_CultureInfo, "> {0} {1} \"{2}\" \"{3}\" \"{4}\" {5} {6} {{interval={7}, unit={8}}}\n", site.Trim(), timeStamp.HasValue ? GetDateTimeNowAsPosix(timeStamp.Value) : (object)"now", resource.Trim(), subResource.Trim(), performanceName.Trim(), value, description.Trim(), interval.HasValue ? interval.Value.ToString() : (object)string.Empty, unit.Trim());
+        return stringBuilder.ToString();
+    }
+
+    public static MonIn GetInstance(IHttpClientFactory httpClientFactory, string url = MonInUrl) {
+        MonIn instance;
+        if (_Instances.ContainsKey(url)) {
+            instance = _Instances[url];
+        } else {
+            lock (_Instances) {
+                if (!_Instances.ContainsKey(url)) {
+                    instance = new MonIn(httpClientFactory, url);
+                    _Instances.Add(url, instance);
+                } else
+                    instance = _Instances[url];
+            }
+        }
+        return instance;
+    }
+
+    private MonIn(IHttpClientFactory httpClientFactory, string url) {
+        _MonInUrl = url;
+        _CultureInfo = new CultureInfo("en-US");
+        _HttpClient = httpClientFactory.CreateClient();
+    }
+
+    private static string GetDateTimeNowAsPosix(DateTime timeStamp) {
+        if (timeStamp > DateTime.Now)
+            timeStamp = DateTime.Now;
+        return ((int)timeStamp.ToUniversalTime().Subtract(_Utc1970DateTime).TotalSeconds).ToString(CultureInfo.InvariantCulture);
+    }
+
+}

Infineon/Monitoring/MonA/State.cs

@@ -0,0 +1,10 @@
+namespace Gatus.To.MonA.Infineon.Monitoring.MonA;
+
+public enum State {
+    Up,
+    Ok,
+    Warning,
+    Critical,
+    Down,
+    Unknown,
+}

Models/GatusConfiguration.cs

@@ -5,7 +5,9 @@ namespace Gatus.To.MonA.Models;
 
 public record GatusConfiguration(string BaseUniformResourceLocator,
                                  string FileName,
-                                 string Metric) {
+                                 string Key,
+                                 string Metric,
+                                 string Token) {
 
     public override string ToString() {
         string result = JsonSerializer.Serialize(this, GatusConfigurationSourceGenerationContext.Default.GatusConfiguration);

Models/GatusToMonaConfiguration.cs

@@ -6,7 +6,8 @@ namespace Gatus.To.MonA.Models;
 public record GatusToMonaConfiguration(string Company,
                                        string Directory,
                                        string Helper,
-                                       int MillisecondsDelay) {
+                                       int MillisecondsDelay,
+                                       string? SyncDirectory) {
 
     public override string ToString() {
         string result = JsonSerializer.Serialize(this, GatusToMonaConfigurationSourceGenerationContext.Default.GatusToMonaConfiguration);

Models/MonAConfiguration.cs

@@ -8,7 +8,8 @@ public record MonAConfiguration(decimal Expected,
                                 string Resource,
                                 string Site,
                                 string StateName,
-                                string Suffix) {
+                                string Suffix,
+                                bool Use) {
 
     public override string ToString() {
         string result = JsonSerializer.Serialize(this, MonAConfigurationSourceGenerationContext.Default.MonAConfiguration);

Worker.cs

@@ -22,8 +22,11 @@ public partial class Worker : BackgroundService {
         _IsWindowsService = collection.Contains(nameof(WindowsServiceLifetime));
     }
 
-    public override Task StopAsync(CancellationToken cancellationToken) =>
+    public override Task StopAsync(CancellationToken cancellationToken) {
-        base.StopAsync(cancellationToken);
+        if (_AppSettings.GatusToMonaConfiguration.Helper is nameof(Helpers.HelperGatusToMona))
+            Helpers.HelperGatusToMona.Heartbeat(_AppSettings, _HttpClientFactory, _Logger, Infineon.Monitoring.MonA.State.Down, cancellationToken);
+        return base.StopAsync(cancellationToken);
+    }
 
     private async Task Body(CancellationToken cancellationToken) {
         if (!_IsWindowsService) {