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); } }