datalust/seqcli/building-seq-plug-in-apps

src/
  Seq.App.{Name}/
    Seq.App.{Name}.csproj          # Main library
    {Name}App.cs                   # SeqApp subclass (entry point)
    ...                            # Supporting types
    Resources/                     # Embedded resources (default templates, etc.)
  Seq.App.{Name}.SmokeTest/        # Optional console app for manual testing
    Program.cs
test/
  Seq.App.{Name}.Tests/
    {Name}AppTests.cs              # App-level integration tests
    ...Tests.cs                    # Unit tests for components
    Support/
      Test{Gateway}.cs             # Test doubles
      Some.cs                      # LogEvent factory helpers

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <Nullable>enable</Nullable>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Seq.Apps" Version="..." />
    <!-- Add Seq.Syntax (project or package reference) if using the Seq template language -->
  </ItemGroup>
  <ItemGroup>
    <!-- Package dependencies into primary NUPKG file, except those shipped in the app host itself -->
    <None Include="./obj/publish/**/*" Exclude="./obj/publish/$(MSBuildProjectName).dll;./obj/publish/Seq.Apps.dll;./obj/publish/Serilog.dll" Pack="true" PackagePath="lib/$(TargetFramework)" />
  </ItemGroup>
</Project>

<ItemGroup>
  <EmbeddedResource Include="./Resources/DefaultHtmlTemplate.txt" LogicalName="DefaultHtmlTemplate" />
</ItemGroup>

public static LogEventPropertyValue? MyAppHost(global::Seq.Apps.Host host) { ... }
public static LogEventPropertyValue? MyAppInstance(global::Seq.Apps.App app) { ... }

using Seq.Apps;
using Serilog.Events;
 
[SeqApp("App Name",
    Description = "A short sentence describing what the app does.")]
public class MyApp : SeqApp, ISubscribeToAsync<LogEvent>, IDisposable
{
    readonly IMyGateway _gateway;
    MyMessageFactory? _messageFactory;
 
    // Public parameterless constructor for production use
    public MyApp() : this(new MyHttpGateway()) { }
 
    // Internal constructor for testing (dependency injection)
    internal MyApp(IMyGateway gateway) { _gateway = gateway; }
 
    // Settings (see "App settings" section below)
 
    protected override void OnAttached()
    {
        // Validate required settings, resolve defaults, create factories
    }
 
    public async Task OnAsync(Event<LogEvent> evt)
    {
        // Process the event: render message, send via gateway
    }
 
    public void Dispose()
    {
        (_gateway as IDisposable)?.Dispose();
    }
}

[SeqApp("App Name",
    Description = "A short sentence describing what the app does.")]
public class MyApp : SeqApp, ISubscribeToJsonAsync, IAsyncDisposable
{
    public async Task OnAsync(string json)
    {
        // Parse and process the raw CLEF JSON
    }
 
    public async ValueTask DisposeAsync() { }
}

[SeqApp("My Input",
    Description = "Periodically does X and publishes metrics to Seq.")]
public class MyInput : SeqApp, IPublishJson, IDisposable
{
    public void Start(TextWriter inputWriter)
    {
        // Begin producing events; write CLEF JSON lines to inputWriter
        // Return immediately; use background tasks for ongoing work
    }
 
    public void Stop()
    {
        // Block until publishing has stopped
    }
}

[SeqAppSetting(
    DisplayName = "Time zone",
    IsOptional = true,
    HelpText = "The IANA time zone name used when formatting dates and times " +
               "(e.g. Australia/Brisbane). The default is Etc/UTC.")]
public string? TimeZoneName { get; set; }
 
[SeqAppSetting(
    DisplayName = "Bot token",
    InputType = SettingInputType.Password,
    HelpText = "The bot's API token, in the format 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11. " +
               "You can create a bot and obtain a token via @BotFather on Telegram.")]
public string? BotToken { get; set; }

using System.ComponentModel;
 
public enum OtlpExportProtocol
{
    [Description("HTTP/Protobuf")]
    HttpProtobuf,
    [Description("gRPC")]
    Grpc
}
 
[SeqAppSetting(
    DisplayName = "Protocol",
    HelpText = "The OTLP export protocol. The default is `HTTP/Protobuf`.",
    IsOptional = true)]
public OtlpExportProtocol Protocol { get; set; } = OtlpExportProtocol.HttpProtobuf;

protected override void OnAttached()
{
    var botToken = NormalizeOption(BotToken)
        ?? throw new ArgumentException("A `Bot token` must be supplied.");
    var chatId = NormalizeOption(ChatId)
        ?? throw new ArgumentException("A `Chat ID` must be supplied.");
    // ...
}
 
// Treat empty strings as null for optional settings
static string? NormalizeOption(string? s) => s == "" ? null : s;

// Interface
interface IMyGateway
{
    Task<MyResponse> SendAsync(string param1, string param2, CancellationToken cancel);
}
 
// Production implementation
class MyHttpGateway : IMyGateway, IDisposable
{
    readonly HttpClient _httpClient = new();
 
    public async Task<MyResponse> SendAsync(...)
    {
        // HTTP calls, JSON serialization, response parsing
    }
 
    public void Dispose() => _httpClient.Dispose();
}
 
// Test double
class TestMyGateway : IMyGateway
{
    public List<(string Param1, string Param2)> Sent { get; } = [];
    public MyResponse NextResponse { get; set; } = new() { Ok = true };
 
    public Task<MyResponse> SendAsync(string param1, string param2, CancellationToken cancel)
    {
        Sent.Add((param1, param2));
        return Task.FromResult(NextResponse);
    }
}

public MyApp() : this(new MyHttpGateway()) { }       // Production
internal MyApp(IMyGateway gateway) { _gateway = gateway; }  // Testing