Merge pull request #139 from datalust/dev

2024.3.0 Release

Author: KodrAus

example/SeqEnableAAD/Program.cs

@@ -60,7 +60,7 @@ static async Task Run(string server, string? username, string? tenantId, string?
     var tid = await connection.Settings.FindNamedAsync(SettingName.EntraIDTenantId);
 
     user.Username = username;
-    provider.Value = "Azure Active Directory";
+    provider.Value = "Microsoft Entra ID";
     cid.Value = clientId;
     ckey.Value = clientKey;
     tid.Value = tenantId;
@@ -77,4 +77,4 @@ static async Task Run(string server, string? username, string? tenantId, string?
     var iae = await connection.Settings.FindNamedAsync(SettingName.IsAuthenticationEnabled);
     iae.Value = true;
     await connection.Settings.UpdateAsync(iae); // this update needs to happen last, as enabling auth will lock this connection out
-}
+}

src/Seq.Api/Model/Diagnostics/ServerMetricsEntity.cs renamed to src/Seq.Api/Model/Diagnostics/ServerMetricsPart.cs

@@ -13,19 +13,19 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
 
 namespace Seq.Api.Model.Diagnostics
 {
     /// <summary>
     /// Metrics describing the state and performance of the Seq server.
     /// </summary>
-    public class ServerMetricsEntity : Entity
+    /// <remarks>This information is not preserved across server restarts or fail-over.</remarks>
+    public class ServerMetricsPart
     {
         /// <summary>
-        /// Construct a <see cref="ServerMetricsEntity"/>.
+        /// Construct a <see cref="ServerMetricsPart"/>.
         /// </summary>
-        public ServerMetricsEntity()
+        public ServerMetricsPart()
         {
         }
 
@@ -34,6 +34,16 @@ public ServerMetricsEntity()
         /// </summary>
         public long? EventStoreDiskRemainingBytes { get; set; }
 
+        /// <summary>
+        /// The total time spent indexing the event store in the last 24 hours.
+        /// </summary>
+        public TimeSpan EventStoreIndexingTimeLastDay { get; set; }
+
+        /// <summary>
+        /// The total time spent writing events to disk in the last minute.
+        /// </summary>
+        public TimeSpan EventStoreWriteTimeLastMinute { get; set; }
+
         /// <summary>
         /// The number of events that arrived at the ingestion endpoint in the past minute.
         /// </summary>

src/Seq.Api/Model/Indexes/IndexEntity.cs

@@ -0,0 +1,33 @@
+namespace Seq.Api.Model.Indexes
+{
+    /// <summary>
+    /// An index over the event stream. May be one of several types discriminated by <see cref="IndexedEntityType"/>.
+    /// </summary>
+    public class IndexEntity: Entity
+    {
+        /// <summary>
+        /// The `Id` of the associated entity (Signal, Alert or Expression index).
+        /// </summary>
+        public string IndexedEntityId { get; set; }
+        
+        /// <summary>
+        /// The type of this index.
+        /// </summary>
+        public IndexedEntityType IndexedEntityType { get; set; }
+
+        /// <summary>
+        /// The owner / creator of this index.
+        /// </summary>
+        public string OwnerUsername { get; set; }
+
+        /// <summary>
+        /// The name of this index. May not be applicable to all index types.
+        /// </summary>
+        public string Label { get; set; }
+
+        /// <summary>
+        /// The storage used by this index.
+        /// </summary>
+        public ulong StorageBytes { get; set; }
+    }
+}

src/Seq.Api/Model/Indexes/IndexedEntityType.cs

@@ -0,0 +1,23 @@
+namespace Seq.Api.Model.Indexes
+{
+    /// <summary>
+    /// The type of the index.
+    /// </summary>
+    public enum IndexedEntityType
+    {
+        /// <summary>
+        /// A predicate index for a signal expression.
+        /// </summary>
+        Signal,
+        
+        /// <summary>
+        /// An expression index.
+        /// </summary>
+        ExpressionIndex,
+        
+        /// <summary>
+        /// A predicate index for an alert filter.
+        /// </summary>
+        Alert,
+    }
+}

src/Seq.Api/Model/Indexing/ExpressionIndexEntity.cs

@@ -0,0 +1,18 @@
+namespace Seq.Api.Model.Indexing
+{
+    /// <summary>
+    /// An index based on an expression.
+    /// </summary>
+    public class ExpressionIndexEntity: Entity
+    {
+        /// <summary>
+        /// The expression to be indexed.
+        /// </summary>
+        public string Expression { get; set; }
+        
+        /// <summary>
+        /// A user-provided description of the index.
+        /// </summary>
+        public string Description { get; set; }
+    }
+}

src/Seq.Api/Model/Settings/SettingName.cs

@@ -15,6 +15,7 @@
 using System;
 using Seq.Api.Model.Apps;
 using Seq.Api.Model.Updates;
+using Seq.Api.Model.Users;
 using Seq.Api.ResourceGroups;
 
 namespace Seq.Api.Model.Settings
@@ -124,6 +125,16 @@ public enum SettingName
         /// Seq will stop accepting new events.
         /// </summary>
         MinimumFreeStorageSpace,
+        
+        /// <summary>
+        /// A dictionary of `(string, string)` pairs that will be used to initialize the
+        /// <see cref="UserEntity.Preferences"/> property when preparing new user entities
+        /// with <see cref="UsersResourceGroup.TemplateAsync"/>, and with automatically
+        /// provisioning SSO users (when enabled).
+        /// </summary>
+        /// <remarks>User preference keys are unconstrained; the Seq UI uses a number of these, but
+        /// alternative interfaces and integrations may add additional items to this collection.</remarks>
+        NewUserPreferences,
 
         /// <summary>
         /// A comma-separated list of role ids that will be assigned to new users by default.

src/Seq.Api/Model/Signals/SignalEntity.cs

@@ -67,6 +67,11 @@ public SignalEntity()
         /// If <c>true</c>, the signal can only be modified by users with the <see cref="Permission.Project"/> permission.
         /// </summary>
         public bool IsProtected { get; set; }
+        
+        /// <summary>
+        /// If <c>true</c>, the signal has no backing index.
+        /// </summary>
+        public bool IsIndexSuppressed { get; set; }
 
         /// <summary>
         /// How the signal is grouped in the Seq UI.

src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs

@@ -38,9 +38,9 @@ internal DiagnosticsResourceGroup(ILoadResourceGroup connection)
         /// </summary>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
         /// <returns>Current server metrics.</returns>
-        public async Task<ServerMetricsEntity> GetServerMetricsAsync(CancellationToken cancellationToken = default)
+        public async Task<ServerMetricsPart> GetServerMetricsAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<ServerMetricsEntity>("ServerMetrics", cancellationToken: cancellationToken).ConfigureAwait(false);
+            return await GroupGetAsync<ServerMetricsPart>("ServerMetrics", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>

src/Seq.Api/ResourceGroups/ExpressionIndexesResourceGroup.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Seq.Api.Model;
+using Seq.Api.Model.Indexing;
+
+namespace Seq.Api.ResourceGroups
+{
+    /// <summary>
+    /// Perform operations on expression indexes.
+    /// </summary>
+    public class ExpressionIndexesResourceGroup: ApiResourceGroup
+    {
+        internal ExpressionIndexesResourceGroup(ILoadResourceGroup connection) : base("ExpressionIndexes", connection)
+        {
+        }
+        
+        /// <summary>
+        /// Retrieve expression indexes.
+        /// </summary>
+        /// <param name="cancellationToken"><see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>A list containing matching expression indexes.</returns>
+        public async Task<List<ExpressionIndexEntity>> ListAsync(CancellationToken cancellationToken = default)
+        {
+            return await GroupListAsync<ExpressionIndexEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+        
+        /// <summary>
+        /// Retrieve the expression index with the given id; throws if the entity does not exist.
+        /// </summary>
+        /// <param name="id">The id of the expression index.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>The expression index.</returns>
+        public async Task<ExpressionIndexEntity> FindAsync(string id, CancellationToken cancellationToken = default)
+        {
+            if (id == null) throw new ArgumentNullException(nameof(id));
+            return await GroupGetAsync<ExpressionIndexEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Construct an expression index with server defaults pre-initialized.
+        /// </summary>
+        /// <param name="cancellationToken"><see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>The unsaved expression index.</returns>
+        public async Task<ExpressionIndexEntity> TemplateAsync(CancellationToken cancellationToken = default)
+        {
+            return await GroupGetAsync<ExpressionIndexEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Add a new expression index.
+        /// </summary>
+        /// <param name="entity">The expression index to add.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>The expression index, with server-allocated properties such as <see cref="Entity.Id"/> initialized.</returns>
+        public async Task<ExpressionIndexEntity> AddAsync(ExpressionIndexEntity entity, CancellationToken cancellationToken = default)
+        {
+            return await GroupCreateAsync<ExpressionIndexEntity, ExpressionIndexEntity>(entity, cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Remove an existing expression index.
+        /// </summary>
+        /// <param name="entity">The expression index to remove.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>A task indicating completion.</returns>
+        public async Task RemoveAsync(ExpressionIndexEntity entity, CancellationToken cancellationToken = default)
+        {
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+    }
+}

src/Seq.Api/ResourceGroups/IndexesResourceGroup.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Seq.Api.Model.Alerting;
+using Seq.Api.Model.Indexes;
+using Seq.Api.Model.Indexing;
+using Seq.Api.Model.Signals;
+
+namespace Seq.Api.ResourceGroups
+{
+    /// <summary>
+    /// Statistics about indexes.
+    /// </summary>
+    public class IndexesResourceGroup : ApiResourceGroup
+    {
+        internal IndexesResourceGroup(ILoadResourceGroup connection)
+            : base("Indexes", connection)
+        {
+        }
+        
+        /// <summary>
+        /// Retrieve the index with the given id; throws if the entity does not exist.
+        /// </summary>
+        /// <param name="id">The id of the index.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>The index.</returns>
+        public async Task<IndexEntity> FindAsync(string id, CancellationToken cancellationToken = default)
+        {
+            if (id == null) throw new ArgumentNullException(nameof(id));
+            return await GroupGetAsync<IndexEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
+        }
+        
+        /// <summary>
+        /// Retrieve statistics on all indexes.
+        /// </summary>
+        /// <param name="cancellationToken"><see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>A list containing matching expression indexes.</returns>
+        public async Task<List<IndexEntity>> ListAsync(CancellationToken cancellationToken = default)
+        {
+            return await GroupListAsync<IndexEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+        
+        /// <summary>
+        /// Suppress an index. Not all index types can be suppressed: signal indexes do support suppression, in the case
+        /// of which the <see cref="SignalEntity.IsIndexSuppressed"/> flag will be set to <c langword="false"/>.
+        /// Expression indexes can only be suppressed by deleting the associated <see cref="ExpressionIndexEntity"/>
+        /// and alert indexes can only be suppressed by deleting the corresponding <see cref="AlertEntity"/>.
+        /// </summary>
+        /// <param name="entity">The index to suppress.</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
+        /// <returns>A task indicating completion.</returns>
+        public async Task SuppressAsync(IndexEntity entity, CancellationToken cancellationToken = default)
+        {
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+    }
+}