Karl Nilsson kjnilsson

sequenceDiagram
    participant ra-server
    participant wal
    participant segment-writer

    loop until wal full
        ra-server->>+wal: write(Index=1..N, Term=T)
        wal->>wal: write-batch([1]
 wal-&gt;&gt;-ra-server: written event: Term=T, Range=(1, N)

Name of RabbitMQ header	App	Type	Purpose
`x-received-from`	Federation	internal	record hop information for cycle detection
`x-death`	Dead lettering	internal	record dead lettering information (somewhat compacted)
`x-stream-offset`	Streams	outgoing annotation	include the offset for a given message consumed using AMQP
`x-delivery-count`	Quorum	outgoing annotation	include the number of delivery attemps for messages consumed from a quorum queue
`x-stream-filter`	Streams	incoming annotation	include a message filter string used for stream filtering feature
`CC`, `BCC`	Routing	incoming annotation	used for including additional routes, not evaluated beyond routing, really ought to be x- headers
`x-first-death-reason`	DLX	outgoing annotation	dead lettering info
`x-first-death-queue`	DLX	outgoing annotation	dead lettering queue name

10 RabbitMQ tips you didn't know

Don't retry publishes to Quorum Queues or Streams if the channel is still live.

Normally we recommend to retry a publish operation if a publisher confirm isn't received within some timeframe. This isn't actually necessary if you know you are only publishing to quorum queues and/or streams and the channel used for publishing is still live. These queue types have their own reliability/resend protocol between the channel and the queue and will ensure publish operations get there once the situation that caused the delay resolves itself (e.g. a temporary unavailability

Introduction

There are two types of consumer processing failures:

Poison messages. Messages that are badly formatted and either cause the consuming application to crash or otherwise fail to process the message.
Downstream dependency failures. I.e. when a message is valid but a downstream dependency such as a database isn't available. This category can further be subdived into:

a. All messages on the queue are destined to the same unavailable downstream.

b. The downstream dependencies may be different depending on the message. (e.g. different databases or integration endpoints).

	add two fields to append_entries_rpc:

	read_index :: non_neg_integer()
	echo :: boolean()

	and one field to append_entries_reply:

	read_index :: non_neg_integer()

	module type GenServerType =
	type State
	val init : ErlangTerm list -> State
	...



	module MyGenServer : GenServerType =
	type State = {Name : string}
	let init args =

	Checking whether the PLT /Users/knilsson/code/rabbitmq/rabbitmq-public-umbrella-master/deps/rabbit_common/.rabbit_common.plt is up-to-date... yes
	Proceeding with analysis...
	app_utils.erl:44: The created fun only terminates with explicit exception
	app_utils.erl:50: The created fun only terminates with explicit exception
	file_handle_cache.erl:1015: The pattern {MemUse, MemLimit} can never match since previous clauses completely covered the type {non_neg_integer(),'infinity'}
	file_handle_cache.erl:1016: The pattern {MemUse, MemLimit} can never match since previous clauses completely covered the type {non_neg_integer(),'infinity'}
	file_handle_cache.erl:1021: Function reduce_read_cache/2 will never be called
	file_handle_cache.erl:1029: Guard test Freed::any() >= MemToFree::none() can never succeed
	file_handle_cache_stats.erl:33: Expression produces a value of type atom() \| ets:tid(), but this value is unmatched
	file_handle_cache_stats.erl:44: Expression produces a value of type [integer()] \| integer(), but th

	module xmas

	open Fez.Core

	let greet who =
	sprintf "Hi %s" who

	type Tid = Tid

	// this is simply to create an atom

	-module(ra_thw).

	-export([
	% new/1, % size,
	new/2, % size, distance
	append/3,
	to_list/1,
	get/2, % kv lookup
	truncate/2 % state, first entry to keep
	]).

	-module(keyval_benchmark).
	-compile(export_all).

	%% Runs all benchmarks with Reps number of elements.
	bench(Reps) ->
	io:format("Base Case:~n"),
	io:format("Operation\tTotal (Âµs)\tAverage (Âµs)~n"),
	print(base_case(Reps)),
	io:format("~nNaive Orddict:~n"),
	io:format("Operation\tTotal (Âµs)\tAverage (Âµs)~n"),