TAF.Kibana.SDK 1.5.0

TAF Kibana SDK

Official .NET SDK for TAF Kibana logging and analytics platform. Provides a fluent API for log management, searching, metrics, and real-time monitoring.

Installation

dotnet add package TAF.Kibana.SDK

Quick Start

Configuration

Add to your appsettings.json:

{
  "KibanaClient": {
    "BaseUrl": "https://your-kibana-instance.com/api",
    "ApiKey": "your-api-key",
    "TimeoutSeconds": 30,
    "MaxRetryAttempts": 3,
    "BulkBatchSize": 1000
  }
}

Dependency Injection

using TAF.Kibana.SDK.Extensions;

// In Program.cs or Startup.cs
services.AddTafKibanaClient(Configuration);

// Or with inline configuration
services.AddTafKibanaClient(options =>
{
    options.BaseUrl = "https://your-kibana-instance.com/api";
    options.ApiKey = "your-api-key";
});

Usage Examples

Basic Usage

public class LoggingService
{
    private readonly ITafKibanaClient _kibanaClient;

    public LoggingService(ITafKibanaClient kibanaClient)
    {
        _kibanaClient = kibanaClient;
    }

    public async Task LogEventAsync()
    {
        // Write a log entry
        await _kibanaClient.Logs.WriteAsync(new LogEntry
        {
            Level = "Information",
            Message = "User logged in",
            TenantId = tenantId,
            ApplicationId = appId
        });
    }
}

Fluent Search API

// Search for error logs in the last 24 hours
var results = await _kibanaClient.Query()
    .ForTenant(tenantId)
    .InLastHours(24)
    .WithLogLevel("Error", "Critical")
    .ContainingText("database connection")
    .OrderBy(x => x.Timestamp, SortDirection.Descending)
    .Take(100)
    .ExecuteAsync<LogEntry>();

// Stream large result sets
await foreach (var log in _kibanaClient.Query()
    .ForTenant(tenantId)
    .InDateRange(startDate, endDate)
    .StreamAsync<LogEntry>())
{
    ProcessLog(log);
}

Aggregations and Analytics

// Get log statistics with aggregations
var stats = await _kibanaClient.Query()
    .ForTenant(tenantId)
    .InLastDays(7)
    .WithAggregation(agg => agg
        .Terms("by_level", "level", size: 10)
        .DateHistogram("over_time", "timestamp", "1h")
        .Average("avg_response", "responseTime"))
    .ExecuteAsync<LogEntry>();

// Get metrics
var metrics = await _kibanaClient.Metrics.GetTimeSeriesAsync(
    metric: "response_time",
    from: DateTime.UtcNow.AddDays(-7),
    to: DateTime.UtcNow,
    interval: "1h");

Bulk Operations

// Bulk indexing with fluent API
var result = await _kibanaClient.Bulk()
    .IndexMany(logEntries)
    .WithBatchSize(500)
    .ContinueOnError(true)
    .WithRefresh(RefreshPolicy.WaitFor)
    .ExecuteAsync();

Console.WriteLine($"Indexed {result.SuccessfulOperations} of {result.TotalOperations} documents");

Real-time Monitoring

// Subscribe to real-time log stream
var subscription = await _kibanaClient.Realtime.SubscribeToLogsAsync(
    filter: query => query
        .ForTenant(tenantId)
        .WithLogLevel("Error"),
    onEvent: logEvent =>
    {
        Console.WriteLine($"New error: {logEvent.Message}");
    });

// Tail logs
await foreach (var log in _kibanaClient.Realtime.TailLogsAsync(
    filter: q => q.ForTenant(tenantId),
    initialLines: 100))
{
    Console.WriteLine($"[{log.Timestamp}] {log.Level}: {log.Message}");
}

Alert Management

// Create alert rule
var rule = await _kibanaClient.Alerts.CreateRuleAsync(new AlertRuleDefinition
{
    Name = "High Error Rate",
    Description = "Alert when error rate exceeds threshold",
    TenantId = tenantId,
    Severity = AlertSeverity.High,
    CheckInterval = TimeSpan.FromMinutes(5),
    Condition = new AlertCondition
    {
        Type = AlertConditionType.Query,
        Query = q => q.WithLogLevel("Error"),
        Operator = ComparisonOperator.GreaterThan,
        Threshold = 100,
        TimeWindow = TimeSpan.FromMinutes(5)
    },
    NotificationChannels = new[] { "email", "slack" }
});

// Get alert history
var alerts = await _kibanaClient.Alerts.GetAlertHistoryAsync(
    ruleId: rule.Id,
    from: DateTime.UtcNow.AddDays(-7));

Advanced Queries

// Complex field queries with expressions
var results = await _kibanaClient.Query()
    .ForTenant(tenantId)
    .Where<LogEntry>(x => x.Level == "Error" && x.ResponseTime > 1000)
    .WhereField("environment", SearchOperator.In, new[] { "production", "staging" })
    .WhereField("statusCode", SearchOperator.Between, new { from = 400, to = 599 })
    .WithHighlighting("message", "stackTrace")
    .WithCaching(TimeSpan.FromMinutes(5))
    .ExecuteAsync<LogEntry>();

// Export search results
var export = await _kibanaClient.Search.ExportAsync(
    request: queryBuilder.Build(),
    format: ExportFormat.Csv);

File.WriteAllBytes("logs.csv", export.Data);

Features

• Fluent API: Intuitive query building with IntelliSense support
• Resilience: Built-in retry policies and circuit breaker patterns
• Streaming: IAsyncEnumerable support for processing large datasets
• Real-time: WebSocket-based real-time log streaming and monitoring
• Bulk Operations: Efficient bulk indexing with progress tracking
• Caching: Query result caching for improved performance
• Type Safety: Strongly-typed API with generic support
• Compression: Automatic request/response compression
• Health Checks: Built-in health check support

Configuration Options

Advanced Configuration

Custom HTTP Client

services.AddTafKibanaClientWithCustomHttp(
    options => options.BaseUrl = "https://api.example.com",
    httpBuilder => httpBuilder
        .AddHttpMessageHandler<CustomAuthHandler>()
        .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
        {
            Proxy = new WebProxy("http://proxy:8080")
        }));

With Health Checks

services.AddTafKibanaClientWithHealthChecks(Configuration);

// In health check endpoint
app.MapHealthChecks("/health", new HealthCheckOptions
{
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

License

MIT

Support

For issues and feature requests, please contact the TechAppForce development team.