Client SDKs

Python

Full-featured client with async support and Pydantic models.

pip install quicksearch-python-sdk
.NET / C#

Serilog sink for seamless .NET application integration.

dotnet add package QuickSearch.Serilog
TypeScript

Pino transport for Node.js with worker thread architecture.

npm install quicksearch-pino-transport
Feature Comparison
Feature Python .NET TypeScript
Batching Yes Yes (1000/2s) Yes (100/2s)
Retry/Backoff Yes Yes Yes
Non-blocking Yes (async) Yes Yes (worker thread)
Structured Logging Yes Yes Yes
OpenTelemetry Planned Planned Yes
Python SDK
Installation
Terminal
pip install quicksearch-python-sdk
Basic Usage
app.py
from quicksearch import QuickSearchClient, EventData

# Initialize client
client = QuickSearchClient(
    base_url="http://localhost:3000",
    api_key="your-api-key"
)

# Ingest event
event = EventData(
    type="user_login",
    application="web_app",
    data={"user_id": "12345", "ip_address": "192.168.1.100"}
)
response = client.ingest_event(event)
print(response)
Search Events
search.py
# Search events
result = client.search_events(query="login", limit=10)
for event in result.events:
    print(f"{event['timestamp_iso']}: {event['message']}")
Async Client
async_app.py
import asyncio
from quicksearch import AsyncQuickSearchClient

async def main():
    async with AsyncQuickSearchClient(api_key="your-api-key") as client:
        response = await client.ingest_event(EventData(type="test"))
        result = await client.search_events(query="test")

asyncio.run(main())
Context Manager
context.py
# Using context manager for automatic cleanup
with QuickSearchClient(api_key="your-api-key") as client:
    response = client.ingest_event(EventData(type="test_event"))
.NET SDK (Serilog Sink)
Installation
Terminal
dotnet add package QuickSearch.Serilog
Basic Configuration
Program.cs
using Serilog;
using QuickSearch.Serilog;

// Basic configuration
Log.Logger = new LoggerConfiguration()
    .WriteTo.QuickSearch(
        serverUrl: "http://localhost:3000",
        apiKey: "your-api-key",
        application: "MyWebApp")
    .CreateLogger();

// Log events
Log.Information("User {UserId} logged in from {IpAddress}", userId, ipAddress);
Log.Warning("High memory usage: {MemoryUsage}%", memoryUsage);
Log.Error(ex, "Failed to process order {OrderId}", orderId);
Advanced Configuration
Program.cs
Log.Logger = new LoggerConfiguration()
    .WriteTo.QuickSearch(
        serverUrl: "http://localhost:3000",
        apiKey: "your-api-key",
        application: "MyWebApp",
        restrictedToMinimumLevel: LogEventLevel.Information,
        batchPostingLimit: 500,
        period: TimeSpan.FromSeconds(5),
        queueSizeLimit: 50000)
    .CreateLogger();
ASP.NET Core Integration
Program.cs
// ASP.NET Core integration
builder.Host.UseSerilog((context, configuration) =>
{
    configuration
        .ReadFrom.Configuration(context.Configuration)
        .WriteTo.QuickSearch(
            serverUrl: context.Configuration["QuickSearch:ServerUrl"],
            apiKey: context.Configuration["QuickSearch:ApiKey"],
            application: context.Configuration["QuickSearch:Application"]);
});
The Serilog sink provides periodic batched sending (default: 1000 events or 2 seconds), non-blocking async operation, and automatic retry with exponential backoff.
TypeScript SDK (Pino Transport)
Installation
Terminal
npm install quicksearch-pino-transport pino
Basic Configuration
app.ts
import pino from 'pino';

const logger = pino({
  transport: {
    target: 'quicksearch-pino-transport',
    options: {
      serverUrl: 'http://localhost:3000',
      apiKey: 'your-api-key',
      application: 'my-app'
    }
  }
});

// Log events
logger.info({ userId: '123' }, 'User logged in');
logger.error({ err }, 'An error occurred');
logger.warn({ cpu: 95 }, 'High CPU usage');
Multi-Transport (Console + QuickSearch)
app.ts
const logger = pino({
  transport: {
    targets: [
      {
        target: 'pino-pretty',
        options: { colorize: true },
        level: 'trace'
      },
      {
        target: 'quicksearch-pino-transport',
        options: {
          serverUrl: 'http://localhost:3000',
          apiKey: 'your-api-key',
          application: 'my-app',
          batchSize: 100,
          flushInterval: 2000
        },
        level: 'info'
      }
    ]
  }
});
Graceful Shutdown
app.ts
// Graceful shutdown
process.on('SIGTERM', async () => {
  logger.flush();
  await new Promise(resolve => setTimeout(resolve, 1000));
  process.exit(0);
});
The Pino transport uses a worker thread architecture for non-blocking async operation, with batched event sending (default: 100 events or 2 seconds) and OpenTelemetry trace context support.
Direct API Usage

If you prefer not to use an SDK, you can make HTTP requests directly to the QuickSearch API.

cURL Example
# Send an event via HTTP
curl -X POST http://localhost:3000/api/events \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "type": "custom_event",
    "application": "my_app",
    "data": {"key": "value"}
  }'
Next Steps