Feature/658 log entries (#672)

* Add service layer and repository layer for trace log

* Add tracelogservice tests

* Add log entry to storage controller endpoint

* Make GetTestClient generic

* Add transfer object for webhook postback log entry

* Fix tests

* Add activity endpoints to trace log service

* Fix comments

* Add traceLogService injections for tests

* Fix LogEntryDto

* Update traceLogService to reflect log entry dto

* Add controller tests

* Add tracelog tests

* Fix usings order and format

* Add parameters to log error

* Add better documentation to CreateWebhookResponseEntry method

* Add invalid GUID test

* Create explicit dto parameter checks

* Create explicit dto parameter checks

* Add tests for good coverage

* Add EventsClient test for post log

* Add separate validation check for log entry dto

* Add invalid subscription activity to enum

* Do cleanup

* Add constants class

* Add eventsClient dependency to WebhookService

* Add cloudEventType check for logging correct activity

* Fix warnings

* Fix issues

* Fix condition coverage traceLogService

* Fix warnings

* Add changes based on feedback

* Remove try catch from logs action

* Add try catch to logWebhookHttpStatusCode in function project

* Add changes based on feedback

* Move logs to its own controller

* Add schema filter example for log entry

* Add changes based on feedback

* Add changes based on feedback

---------

Co-authored-by: Espen Gulbrandsen <espen.gulbrandsen@digdir.no>

Author: eskebab

src/Events.Functions/Clients/EventsClient.cs

@@ -3,12 +3,14 @@
 using System.Net.Http;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
+using System.Text.Json;
 using System.Threading.Tasks;
 
 using Altinn.Common.AccessTokenClient.Services;
 using Altinn.Platform.Events.Functions.Clients.Interfaces;
 using Altinn.Platform.Events.Functions.Configuration;
 using Altinn.Platform.Events.Functions.Extensions;
+using Altinn.Platform.Events.Functions.Models;
 using Altinn.Platform.Events.Functions.Services.Interfaces;
 
 using CloudNative.CloudEvents;
@@ -116,19 +118,48 @@ public async Task ValidateSubscription(int subscriptionId)
 
             if (response.StatusCode == HttpStatusCode.NotFound)
             {
-                _logger.LogError("Attempting to validate non existing subscription {subscriptionId}", subscriptionId);
+                _logger.LogError("Attempting to validate non existing subscription {SubscriptionId}", subscriptionId);
                 return;
             }
-            
+
             if (!response.IsSuccessStatusCode)
             {
                 _logger.LogError(
-                    $"// Validate subscription with id {subscriptionId} failed with status code {response.StatusCode}");
+                    "Validate subscription with id {SubscriptionId} failed with status code {StatusCode}", subscriptionId, response.StatusCode);
                 throw new HttpRequestException(
                     $"// Validate subscription with id {subscriptionId} failed with status code {response.StatusCode}");
             }
         }
 
+        /// <inheritdoc/>
+        public async Task LogWebhookHttpStatusCode(CloudEventEnvelope cloudEventEnvelope, HttpStatusCode statusCode)
+        {
+            try
+            {
+                var endpoint = "storage/events/logs";
+
+                var logEntryData = new LogEntryDto
+                {
+                    CloudEventId = cloudEventEnvelope.CloudEvent.Id,
+                    CloudEventType = cloudEventEnvelope.CloudEvent.Type,
+                    CloudEventResource = cloudEventEnvelope.CloudEvent["resource"]?.ToString(),
+                    Consumer = cloudEventEnvelope.Consumer,
+                    Endpoint = cloudEventEnvelope.Endpoint,
+                    SubscriptionId = cloudEventEnvelope.SubscriptionId,
+                    StatusCode = statusCode,
+                };
+
+                StringContent httpContent = new(JsonSerializer.Serialize(logEntryData), Encoding.UTF8, "application/json");
+                var accessToken = await GenerateAccessToken();
+
+                await _client.PostAsync(endpoint, httpContent, accessToken);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Failed to log trace log webhook status code for cloud event id {CloudEventId}", cloudEventEnvelope.CloudEvent.Id);
+            }
+        }
+
         private async Task<(bool Success, HttpStatusCode StatusCode)> PostCloudEventToEndpoint(CloudEvent cloudEvent, string endpoint)
         {
             StringContent httpContent = new(cloudEvent.Serialize(), Encoding.UTF8, "application/cloudevents+json");

src/Events.Functions/Clients/Interfaces/IEventsClient.cs

@@ -1,4 +1,7 @@
 using System.Threading.Tasks;
+
+using Altinn.Platform.Events.Functions.Models;
+
 using CloudNative.CloudEvents;
 
 namespace Altinn.Platform.Events.Functions.Clients.Interfaces
@@ -15,6 +18,12 @@ public interface IEventsClient
         /// <returns>CloudEvent as stored in the database</returns>
         Task SaveCloudEvent(CloudEvent cloudEvent);
 
+        /// <summary>
+        /// Posts an event with the given statusCode
+        /// </summary>
+        /// <returns></returns>
+        Task LogWebhookHttpStatusCode(CloudEventEnvelope cloudEventEnvelope, System.Net.HttpStatusCode statusCode);
+
         /// <summary>
         /// Send cloudEvent for outbound processing.
         /// </summary>

src/Events.Functions/Constants/EventConstants.cs

@@ -0,0 +1,12 @@
+namespace Altinn.Platform.Events.Functions.Constants;
+
+/// <summary>
+/// Shared constants for Events.Functions project
+/// </summary>
+public static class EventConstants
+{
+    /// <summary>
+    /// The cloud event type for subscription validation
+    /// </summary>
+    public const string ValidationType = "platform.events.validatesubscription";
+}

src/Events.Functions/Models/LogEntryDto.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Net;
+
+namespace Altinn.Platform.Events.Functions.Models
+{
+    /// <summary>
+    /// Data transfer object for posting a log event after receiving a webhook response.
+    /// </summary>
+    public record LogEntryDto
+    {
+        /// <summary>
+        /// The cloud event id associated with the logged event
+        /// </summary>
+        public string CloudEventId { get; set; }
+
+        /// <summary>
+        /// The resource associated with the cloud event 
+        /// </summary>
+        public string CloudEventResource { get; set; }
+
+        /// <summary>
+        /// The type associated with the logged event 
+        /// </summary>
+        public string CloudEventType { get; set; }
+
+        /// <summary>
+        /// The subscription id associated with the post action.
+        /// </summary>
+        public int SubscriptionId { get; set; }
+
+        /// <summary>
+        /// The consumer of the event 
+        /// </summary>
+        public string Consumer { get; set; }
+
+        /// <summary>
+        /// The consumers webhook endpoint
+        /// </summary>
+        public Uri Endpoint { get; set; }
+
+        /// <summary>
+        /// The staus code returned from the subscriber endpoint
+        /// </summary>
+        public HttpStatusCode StatusCode { get; set; }
+    }
+}

src/Events.Functions/Services/Interfaces/IWebhookService.cs

@@ -1,17 +1,17 @@
 using System.Threading.Tasks;
+
 using Altinn.Platform.Events.Functions.Models;
 
-namespace Altinn.Platform.Events.Functions.Services.Interfaces
+namespace Altinn.Platform.Events.Functions.Services.Interfaces;
+
+/// <summary>
+/// Interface to send content to webhooks
+/// </summary>
+public interface IWebhookService
 {
     /// <summary>
-    /// Interface to send content to webhooks
+    /// Send cloudevent to webhook
     /// </summary>
-    public interface IWebhookService
-    {
-        /// <summary>
-        /// Send cloudevent to webhook
-        /// </summary>
-        /// <param name="envelope">CloudEventEnvelope, includes content and uri</param>
-        Task Send(CloudEventEnvelope envelope);
-    }
+    /// <param name="envelope">CloudEventEnvelope, includes content and uri</param>
+    Task Send(CloudEventEnvelope envelope);
 }

src/Events.Functions/Services/WebhookService.cs

@@ -3,12 +3,12 @@
 using System.Text;
 using System.Threading.Tasks;
 
+using Altinn.Platform.Events.Functions.Clients.Interfaces;
 using Altinn.Platform.Events.Functions.Configuration;
 using Altinn.Platform.Events.Functions.Extensions;
 using Altinn.Platform.Events.Functions.Models;
 using Altinn.Platform.Events.Functions.Models.Payloads;
 using Altinn.Platform.Events.Functions.Services.Interfaces;
-
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
@@ -20,18 +20,19 @@ namespace Altinn.Platform.Events.Functions.Services
     public class WebhookService : IWebhookService
     {
         private readonly HttpClient _client;
+        private readonly IEventsClient _eventsClient;
         private readonly ILogger _logger;
         private readonly string _slackUri = "hooks.slack.com";
 
         /// <summary>
         /// Initializes a new instance of the <see cref="WebhookService"/> class.
         /// </summary>
         public WebhookService(
-            HttpClient client, IOptions<EventsOutboundSettings> eventOutboundSettings, ILogger<WebhookService> logger)
+            HttpClient client, IEventsClient eventsClient, IOptions<EventsOutboundSettings> eventOutboundSettings, ILogger<WebhookService> logger)
         {
             _client = client;
+            _eventsClient = eventsClient;
             _logger = logger;
-
             _client.Timeout = TimeSpan.FromSeconds(eventOutboundSettings.Value.RequestTimeout);
         }
 
@@ -44,17 +45,21 @@ public async Task Send(CloudEventEnvelope envelope)
             try
             {
                 HttpResponseMessage response = await _client.PostAsync(envelope.Endpoint, httpContent);
+
+                // log response from webhook to Events
+                await _eventsClient.LogWebhookHttpStatusCode(envelope, response.StatusCode);
+
                 if (!response.IsSuccessStatusCode)
                 {
                     string reason = await response.Content.ReadAsStringAsync();
-                    _logger.LogError($"// WebhookService // Send // Failed to send cloud event id {envelope.CloudEvent.Id}, subscriptionId: {envelope.SubscriptionId}. \nReason: {reason} \nResponse: {response}");
+                    _logger.LogError("WebhookService send failed to send cloud event id {CloudEventId} {SubscriptionId} {Reason} {Response}", envelope.CloudEvent.Id, envelope.SubscriptionId, reason, response);
 
                     throw new HttpRequestException(reason);
                 }
             }
             catch (Exception e)
             {
-                _logger.LogError(e, $"// Send to webhook with subscriptionId: {envelope.SubscriptionId} failed with error message {e.Message}");
+                _logger.LogError(e, "Send to webhook with {SubscriptionId} failed with error message {Message}", envelope.SubscriptionId, e.Message);
                 throw;
             }
         }

src/Events.Functions/SubscriptionValidation.cs

@@ -63,7 +63,7 @@ internal CloudEventEnvelope CreateValidateEvent(Subscription subscription)
                 {
                     Id = Guid.NewGuid().ToString(),
                     Source = new Uri(_platformSettings.ApiEventsEndpoint + "subscriptions/" + subscription.Id),
-                    Type = "platform.events.validatesubscription",
+                    Type = Constants.EventConstants.ValidationType,
                 }
             };
 

src/Events/Controllers/LogsController.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading.Tasks;
+using Altinn.Platform.Events.Configuration;
+using Altinn.Platform.Events.Models;
+using Altinn.Platform.Events.Services.Interfaces;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Swashbuckle.AspNetCore.Annotations;
+
+namespace Altinn.Platform.Events.Controllers
+{
+    /// <summary>
+    /// Controller for logging event operations to persistence
+    /// </summary>
+    /// <param name="traceLogService">Service for logging event operations to persistence</param>
+    [Route("events/api/v1/storage/events/logs")]
+    [ApiController]
+    [SwaggerTag("Private API")]
+    public class LogsController(ITraceLogService traceLogService) : ControllerBase
+    {
+        private readonly ITraceLogService _traceLogService = traceLogService;
+
+        /// <summary>
+        /// Create a new trace log for cloud event with a status code.
+        /// </summary>
+        /// <param name="logEntry">The event wrapper associated with the event for logging <see cref="CloudEventEnvelope"/></param>
+        /// <returns></returns>
+        [Authorize(Policy = AuthorizationConstants.POLICY_PLATFORM_ACCESS)]
+        [HttpPost]
+        [Consumes("application/json")]
+        [SwaggerResponse(201, Type = typeof(Guid))]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        public async Task<IActionResult> Logs([FromBody] LogEntryDto logEntry)
+        {
+            var result = await _traceLogService.CreateWebhookResponseEntry(logEntry);
+
+            if (string.IsNullOrEmpty(result))
+            {
+                return BadRequest();
+            }
+
+            return Created();
+        }
+    }
+}

src/Events/Controllers/StorageController.cs

@@ -9,7 +9,6 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
-
 using Swashbuckle.AspNetCore.Annotations;
 
 namespace Altinn.Platform.Events.Controllers

src/Events/Models/LogEntryDto.cs

@@ -1,7 +1,7 @@
 #nullable enable
-
 using System;
 using System.Net;
+
 using CloudNative.CloudEvents;
 
 namespace Altinn.Platform.Events.Models