Axum.MasunoIntegrationsLibrary 1.0.2

MasunoIntegrationsLibrary

A .NET Core 3.1 library that provides event stream forwarding capabilities for integrating Axum/DPlus systems with Masuno integrations. This library acts as an event forwarder, processing various business events and forwarding them to external Masuno integration endpoints.

Overview

The MasunoIntegrationsLibrary is designed to handle real-time event streaming between different business systems (Chess, Orders360, Planning Web, and Productivity) and forward these events to Masuno integrations for further processing. It uses an event-driven architecture with stream consumers that filter, validate, and forward relevant events.

Architecture

The library follows a Event Forwarder pattern where each consumer:

1. Filters Events: Determines which events should be processed based on business rules
2. Validates Context: Ensures the organization and settings are appropriate for processing
3. Forwards Events: Sends filtered events to the Masuno integrations API
4. Handles Failures: Manages retry logic and failure scenarios

Configuration

Required Settings

{
  "MasunoIntegrationsEndpoint": "https://your-masuno-endpoint.com",
  "MasunoIntegrationsToken": "your-authorization-token",
  "AxumCentralMasunoTenantsCodes": "tenant1,tenant2,tenant3"
}

Dependency Injection Setup

//Use the extension method
MasunoIntegrationsLibrary.StartupServicesConfig.ConfigureServices(services, configuration, false);

Event Flow

1. Event Generation: Business systems generate events (orders, invoices, CICO, etc.)
2. Stream Processing: Consumers receive events in batches
3. Filtering: Each consumer applies business rules to determine relevance
4. Validation: Organization settings and permissions are checked
5. Forwarding: Valid events are forwarded to Masuno integrations
6. Retry Logic: Failed events are retried according to consumer configuration
7. Error Handling: Events that fail all retries are handled appropriately

Error Handling

The library implements robust error handling:

• Retry Mechanism: Configurable retry attempts per consumer
• Failure Behaviors:
  • Continue: Process next events despite failures
  • Stop: Halt processing on persistent failures
• Logging: Comprehensive logging for troubleshooting
• Circuit Breaker: Prevents cascade failures

Monitoring

Key Metrics

• Event processing rates per consumer
• Retry counts and failure rates
• API response times to Masuno endpoints
• Organization-specific processing volumes

Logging

The library provides structured logging for:

• Event processing steps
• API call results
• Error conditions
• Performance metrics

Dependencies

• .NET Core 3.1
• Axum.Common (v1.1.15): Core Axum functionality
• AxumConnectorCommon (v1.1.21): Connector utilities and models
• Refit: HTTP API client
• Newtonsoft.Json: JSON serialization
• LazyCache: Caching infrastructure

Usage Example

// Configure services
public void ConfigureServices(IServiceCollection services)
{
    MasunoIntegrationsLibrary.StartupServicesConfig.ConfigureServices(
        services, Configuration, false);
    
    // Register consumers
    services.AddScoped<ChessOrdersConsumerForwarder>();
    services.AddScoped<Orders360PedidosConsumer>();
    // ... other consumers
}

// Use in stream processing
var consumer = serviceProvider.GetService<Orders360PedidosConsumer>();
var events = GetEventsFromStream();
consumer.Consume(events);

Contributing

When adding new consumers:

1. Extend EventHookSenderConsumer
2. Implement required abstract methods
3. Add appropriate filtering in ShouldHandle()
4. Use IMasunoIntegrationsStreamingApi for forwarding
5. Add consumer to MasunoIntegrationsConsumers enum
6. Configure appropriate retry and timing settings

License

This project is part of the Greencode LLC ecosystem and follows the same licensing terms.