private async Task <bool> HandleMessage(IKafkaMessage <string, InitiateKycResponseModel> message)
{
var serializedValue = JsonConvert.SerializeObject(message.Value);
_logger.LogDebug($"Consumed message in service \nkey: '{ message.Key }' \nvalue: '{ serializedValue }' at {DateTime.UtcNow}");
foreach (var header in message.Headers)
{
_logger.LogDebug($"Key: { header.Key }\tValue: { header.Value }");
}
try
{
var request = new CheckMrzStatusRequest {
UserId = message.Value.UserId, KycId = message.Value.KycId, TaskId = message.Value.MrzTaskId
};
var payload = JsonConvert.SerializeObject(request);
// Get token from Identity Server
var accessToken = await _identityServerClient.RequestClientCredentialsTokenAsync();
// Set token in http client
_httpClient.SetBearerToken(accessToken);
var response = await _httpClient.PostAsync("api/kyc/checkmrzstatus", new StringContent(payload, Encoding.UTF8, "application/json"));
return(response.IsSuccessStatusCode);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
}
return(false);
}
/// <inheritdoc />
public virtual Message <TKey, TValue> BuildMessage <TKey, TValue>([NotNull] IKafkaMessage <TKey, TValue> kafkaMessage)
{
if (kafkaMessage == null)
{
throw new ArgumentNullException(nameof(kafkaMessage));
}
kafkaMessage.Headers.AddOrUpdate(AbstractionConstants.MessageTypeHeaderName, kafkaMessage.MessageType);
kafkaMessage.Headers.AddOrUpdate(AbstractionConstants.MessageIdHeaderName, kafkaMessage.MessageId);
kafkaMessage.Headers.AddOrUpdate(AbstractionConstants.CorrelationIdHeaderName, Activity.Current.Id);
foreach (var baggageItem in _activityContextAccessor.Baggage)
{
kafkaMessage.Headers.AddOrUpdate(baggageItem.Key, baggageItem.Value);
}
return(new Message <TKey, TValue>
{
Key = kafkaMessage.Key,
Value = kafkaMessage.Value,
Timestamp = new Timestamp(_dateTimeProvider.Now),
Headers = kafkaMessage.Headers.ToKafkaHeaders()
});
}
public string SendMessageAsync(string topic, IKafkaMessage message)
{
using (var producer = new ProducerBuilder <Null, string>(Config).Build())
{
var response = producer.ProduceAsync(topic, new Message <Null, string> {
Value = message.Message()
});
return(response.Result.Offset.Value.ToString());
}
}
/// <inheritdoc />
public async Task ProduceAsync(IKafkaMessage <TKey, TValue> kafkaMessage)
{
var publishingActivity = new Activity(Constants.PublishActivityName);
publishingActivity.Start();
var message = _kafkaBuilderOptions.MessageFactory.BuildMessage(kafkaMessage);
await ProduceAsync(message, publishingActivity);
}
/// <inheritdoc />
public void Commit(IKafkaMessage <TKey, TValue> message)
{
var kafkaMessage = (KafkaMessage <TKey, TValue>)message;
var span = _tracer?.StartSpanFromActivity(Constants.SpanConsumeCommitOperationNamePrefix, Activity.Current, SpanKind.Consumer);
_consumer.Commit(new List <TopicPartitionOffset> {
kafkaMessage.Offset
});
span?.End();
}
private void ValidateMessage(IKafkaMessage <string, CreatePerson> consumedMessage)
{
if (consumedMessage.MessageType != nameof(CreatePerson))
{
throw new ValidationException("Message Type Incorrect");
}
if (string.IsNullOrEmpty(consumedMessage.Value.Id.ToString()))
{
throw new ValidationException("Incorrect Person Id");
}
}
public async Task ProduceAsync(IKafkaMessage <TKey, TValue> kafkaMessage)
{
kafkaMessage.Headers.AddOrUpdate(KafkaConstants.MessageTypeHeaderName, kafkaMessage.MessageType);
var message = new Message <TKey, TValue>
{
Key = kafkaMessage.Key,
Value = kafkaMessage.Value,
Timestamp = new Timestamp(DateTime.UtcNow),
Headers = kafkaMessage.Headers.ToKafkaHeaders()
};
await ProduceAsync(message);
}
private async Task HandleMessageAsync(IKafkaMessage <string, CreatePerson> message)
{
await _createPersonService.HandleMessageAsync(message);
}
public async Task ProduceAsync(string topic, IKafkaMessage message)
{
var serializedObject = JsonConvert.SerializeObject(message, Formatting.None);
await _producer.ProduceAsync(topic, null, serializedObject);
}
public void Produce(string topic, IKafkaMessage message)
{
#pragma warning disable 4014
ProduceAsync(topic, message);
#pragma warning restore 4014
}
protected void OnError(IKafkaMessage kafkaMessage, Exception ex)
{
Error?.Invoke(this, new ExtThreadExceptionEventArgs(kafkaMessage, ex));
}
protected Task OnSubscribe(IKafkaMessage kafkaMessage)
{
return(Subscribe?.Invoke(kafkaMessage));
}
public async Task HandleMessageAsync(IKafkaMessage <string, CreatePerson> consumedMessage)
{
var jitter = new Random();
try
{
// Validation
ValidateMessage(consumedMessage);
// Add Idempotentcy Check -It's important to verify for possible duplicates of the same message
// Process
var serializedValue = JsonSerializer.Serialize(consumedMessage.Value);
_logger.LogInformation("Consumed message in service [key: '{key} '] [value: '{serializedValue}']", consumedMessage.Key, serializedValue);
foreach (var(key, value) in consumedMessage.Headers)
{
_logger.LogInformation("Header: {key}\tValue: {value}", key, value);
}
var personCreated = new PersonCreated()
{
Id = consumedMessage.Value.Id,
Address = consumedMessage.Value.Address,
DateOfBirth = consumedMessage.Value.DateOfBirth,
Name = consumedMessage.Value.Name,
Surname = consumedMessage.Value.Surname
};
var messageId = Guid.NewGuid().ToString();
var personCreatedMessage = new KafkaMessage <string, PersonCreated>
{
Key = personCreated.Id.ToString(),
Value = personCreated,
MessageId = messageId,
MessageType = nameof(PersonCreated)
};
var count = 1;
// Retry forever
var retryPolicy = Policy
.Handle <KafkaProducerException>()
.WaitAndRetryForeverAsync( // exponential back-off plus some jitter
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt > 6 ? 6 : retryAttempt))
+ TimeSpan.FromMilliseconds(jitter.Next(0, 100)),
(exception, timespan) =>
{
Console.Write($"RetryCount: {count} - Timespan: {timespan} - Exception: {exception.Message}");
count++;
});
// PublishEvent
await retryPolicy.ExecuteAsync(() => PublishEventAsync(personCreatedMessage));
}
catch (ValidationException ex)
{
// Add Handle for Poison Message
_logger.LogError(ex, ex.Message);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
