Configure Visibility Timeout

// A per-request visibility override is not exposed in the Go SDK — the server
// default (DefaultVisibilitySeconds) applies. Ack before it expires.
resp, err := client.PollQueue(ctx, &kubemq.PollRequest{
    Channel:            "orders",
    MaxItems:           1,
    WaitTimeoutSeconds: 5,
})
if err != nil {
    log.Fatal(err)
}
for _, dsMsg := range resp.Messages {
    fmt.Printf("Processing: %s\n", string(dsMsg.Message.Body))
}
resp.AckAll()

# A per-request visibility override is not exposed in the Python SDK — the server
# default (DefaultVisibilitySeconds) applies. Ack before it expires.
response = client.receive_queue_messages(
    channel="orders",
    max_messages=1,
    wait_timeout_in_seconds=5,
)
for msg in response.messages:
    print(f"Processing: {msg.body.decode('utf-8')}")
    msg.ack()

// A per-request visibility override is not exposed in the Node.js SDK — the server
// default (DefaultVisibilitySeconds) applies. Ack before it expires.
const messages = await client.receiveQueueMessages({
  channel: 'orders',
  maxMessages: 1,
  waitTimeoutSeconds: 5,
});
for (const msg of messages) {
  console.log('Processing:', new TextDecoder().decode(msg.body));
  await msg.ack();
}

// visibilitySeconds is a client-side timer: if the message is not acked or
// rejected within 120s, the SDK auto-rejects it and the server redelivers.
QueuesPollRequest pollRequest = QueuesPollRequest.builder()
        .channel("orders")
        .pollMaxMessages(1)
        .pollWaitTimeoutInSeconds(5)
        .autoAckMessages(false)
        .visibilitySeconds(120)
        .build();

QueuesPollResponse response = client.receiveQueueMessages(pollRequest);

for (QueueMessageReceived msg : response.getMessages()) {
    System.out.println("Processing (120s visibility): " + new String(msg.getBody()));
    msg.ack();
}

// A per-request visibility override is not exposed in the C# SDK — the server
// default (DefaultVisibilitySeconds) applies. Ack before it expires.
var response = await client.ReceiveQueueMessagesAsync(new QueuePollRequest
{
    Channel = "orders",
    MaxMessages = 1,
    WaitTimeoutSeconds = 5,
    AutoAck = false,
});
foreach (var msg in response.Messages)
{
    Console.WriteLine($"Processing: {Encoding.UTF8.GetString(msg.Body.Span)}");
    await msg.AckAsync();
}

// A per-request visibility override is not exposed in the Kotlin SDK — the server
// default (DefaultVisibilitySeconds) applies. Ack before it expires.
val response = client.receiveQueuesMessages {
    channel = "orders"
    maxItems = 1
    waitTimeoutMs = 5000
    autoAck = false
}
for (msg in response.messages) {
    println("Processing: ${String(msg.body)}")
    msg.ack()
}

// A per-request visibility override is not exposed in the C++ SDK — the server
// default (DefaultVisibilitySeconds) applies. Ack before it expires.
kubemq::PollRequest poll_req;
poll_req.channel = "orders";
poll_req.max_items = 1;
poll_req.wait_timeout_seconds = 5;

auto poll_result = client->PollQueue(poll_req);
for (const auto& dm : poll_result->messages()) {
    std::cout << "Processing: " << dm.message().body() << std::endl;
    dm.Ack();
}

// A per-request visibility override is not exposed in the Rust SDK — the server
// default (DefaultVisibilitySeconds) applies. Ack before it expires.
let mut receiver = client.new_queue_downstream_receiver().await?;
let poll = PollRequest {
    channel: "orders".to_string(),
    max_items: 1,
    wait_timeout_seconds: 5,
    auto_ack: false,
};
let response = receiver.poll(poll).await?;
for msg in &response.messages {
    println!("Processing: {}", String::from_utf8_lossy(&msg.message.body));
}
response.ack_all().await?;

# A per-request visibility override is not exposed in the Ruby SDK — the server
# default (DefaultVisibilitySeconds) applies. Ack before it expires.
# Per-message ack requires the streaming receiver, not the unary receive call.
receiver = client.create_downstream_receiver
request = KubeMQ::Queues::QueuePollRequest.new(
  channel: 'orders',
  max_items: 1,
  wait_timeout: 5
)
response = receiver.poll(request)
response.messages.each do |m|
  puts "Processing: #{m.body}"
  m.ack
end
receiver.close

# A per-request visibility override is not exposed in the Elixir SDK — the server
# default (DefaultVisibilitySeconds) applies. Ack before it expires.
{:ok, poll} =
  KubeMQ.Client.poll_queue(client,
    channel: "orders",
    max_items: 1,
    wait_timeout: 5_000
  )

Enum.each(poll.messages, fn msg ->
  IO.puts("Processing: #{msg.body}")
end)

{:ok, _} = KubeMQ.PollResponse.ack_all(poll)