ratelimit Module

This is a trivial algorithm that imposes some risks when used in conjunction with long timer intervals. At the start of each interval an internal counter is reset and incremented for each incoming message. Once the counter hits the configured limit rl_check returns an error.

The downside of this algorithm is that it can lead to SIP client synchronization. During a relatively long interval only the first requests (i.e. REGISTERs) would make it through. Following messages (i.e. RE-REGISTERs) will all hit the SIP proxy at the same time when a common Expire timer expired. Other requests will be retransmissed after given time, the same on all devices with the same firmware/by the same vendor.

Random Early Detection tries to circumvent the synchronization problem imposed by the tail drop algorithm by measuring the average load and adapting the drop rate dynamically. When running with the RED algorithm OpenSIPS will return errors to the OpenSIPS routing engine every n'th packet trying to evenly spread the measured load of the last timer interval onto the current interval. As a negative side effect OpenSIPS might drop messages although the limit might not be reached within the interval. Decrease the timer interval if you encounter this.

SBT holds a window consisting of one or more slots. You can set the window_size parameter(seconds) which means for how long we should look back to count the calls and slot_period parameter(miliseconds) which tells how granular the algorithm should be. The number of slots will be window_size/slot_period. If, for example, you have window_size= slot_period=1 second, then after each second you shall lose the call count, but if you set the slot_period to 100 milliseconds, then when your call will be outside the window, the calls in the first 100 milliseconds shall be dropped, and the rest in the next 900 shall be kept.

This algorithm relies on information provided by network interfaces. The total amount of bytes waiting to be consumed on all the network interfaces is retrieved once every timer_interval seconds. If the returned amount exceeds the limit specified in the modparam, rl_check returns an error.

Using the PID Controller model (see Wikipedia page), the drop rate is adjusted dynamically based on the load factor so that the load factor always drifts towards the specified limit (or setpoint, in PID terms).

As reading the cpu load average is relatively expensive (opening /proc/stat, parsing it, etc), this only happens once every timer_interval seconds and consequently the FEEDBACK value is only at these intervals recomputed. This in turn makes it difficult for the drop rate to adjust quickly. Worst case scenarios are request rates going up/down instantly by thousands - it takes up to 20 seconds for the controller to adapt to the new request rate.

Generally though, as real life request rates drift by less, adapting should happen much faster.

IMPORTANT NOTE: as this algorithm is diven by the load factor, the values for the limits must be between 0 and 100 (as percentages) and the limits for all the checks and pipes must be the same (only one value). Again, this limitation are specific to this algorithm and not to the implementation.

The following modules must be loaded before this module:

The following libraries or applications must be installed before running OpenSIPS with this module loaded:

The timer interval in seconds when the Network and Feedback algorithms run their queries, and the other algorithms reset their counters.

IMPORTANT: A too small value may lead to performance penalties due to timer process overloading.

Default value is 10.

...
modparam("ratelimit", "timer_interval", 5)
...

This parameter configures the way that a pipe's limit is specified in the rl_check function and only affects the Taildrop and RED algorithms. A value of 1 means that the limit is set per-timer_interval while a value of 0 means per-second.

Default value is 0(limit per-second).

...
modparam("ratelimit", "limit_per_interval", 1)
...

This parameter specifies how long a pipe should be kept in memory after it becomes idle (no more operations are performed on the pipe) until deleted.

Default value is 3600.

...
modparam("ratelimit", "expire_time", 1800)
...

The size of the hash table internally used to keep the pipes. A larger table is much faster but consumes more memory. The hash size must be a power of 2 number.

Default value is 1024.

...
modparam("ratelimit", "hash_size", 512)
...

Specifies which algorithm should be assumed in case it isn't explicitly specified in the rl_check function.

Default value is "TAILDROP".

...
modparam("ratelimit", "default_algorithm", "RED")
...

Enables distributed rate limiting and specifies the backend that should be used by the CacheDB interface.

Default value is "disabled".

...
modparam("ratelimit", "cachedb_url", "redis://root:root@127.0.0.1/")
...

Specifies what prefix should be added to the pipe name. This is only used when distributed rate limiting is enabled.

Default value is "rl_pipe_".

...
modparam("ratelimit", "db_prefix", "ratelimit_")
...

Used to specify the length of the buffer used by the binary replication, in bytes. Usually this should be big enough to hold as much data as possible, but small enough to avoid UDP fragmentation. The recommended value is the smallest MTU between all the replication instances.

Default value is 1400 bytes.

...
modparam("ratelimit", "repl_buffer_threshold", 500)
...

Timer in milliseconds, used to specify how often the module should replicate its counters to the other instances.

Default value is 10 ms.

...
modparam("ratelimit", "repl_timer_interval", 100)
...

Timer in seconds, used to specify when the counter received from a different instance should no longer be taken into account. This is used to prevent obsolete values, in case an instance stops replicating its counters.

Default value is 10 s.

...
modparam("ratelimit", "repl_timer_expire", 10)
...

Specifies the cluster ID where pipes will be replicated to and received from.

Default value is 0. (no replication)

...
modparam("ratelimit", "pipe_replication_cluster", 1)
...

How long the history in SBT should be in seconds.

Default value is “10”.

...
modparam("ratelimit", "window_size", 5)
...

Value of one slot in milliseconds. This parameter determines how granular the algorithm should be. The number of slots will be determined by window_size/slot_period.

Default value is “200”.

...
modparam("ratelimit", "window_size", 5)
#we will have 50 slots of 100 milliseconds
modparam("ratelimit", "slot_period", 100)
...

Check the current request against the pipe identified by name and changes/updates the limit. If no pipe is found, then a new one is created with the specified limit and algorithm, if specified. If the algorithm parameter doesn't exist, the default one is used.

NOTE: A pipe's algorithm cannot be dynamically changed. Only the one specified when the pipe was created will be considered.

NOTE: This function increments the pipe's counter every time it is called, even if the call should be declined. Therefore If you are using ratelimit to limit only successful traffic, you need to explicitely decrease the counter for the declined calls using the rl_dec_count() function.

The method will return an error code if the limit for the matched pipe is reached.

Meaning of the parameters is as follows:

This function can be used from REQUEST_ROUTE, FAILURE_ROUTE, ONREPLY_ROUTE, BRANCH_ROUTE, ERROR_ROUTE, LOCAL_ROUTE, TIMER_ROUTE and EVENT_ROUTE.

...
	# perform a pipe match for all INVITE methods using RED algorithm
	if (is_method("INVITE")) {
		if (!rl_check("pipe_INVITE", 100, "RED")) {
			sl_send_reply(503, "Server Unavailable");
			exit;
		};
	};
...
	# use default algorithm for each different gateway
	$var(limit) = 10;
	if (!rl_check("gw_$ru", $var(limit))) {
		sl_send_reply(503, "Server Unavailable");
		exit;
	};
...
	# count only successful calls
	if (!rl_check("gw_$ru", 100)) {
		rl_dec_count("gw_$ru");
		sl_send_reply(503, "Server Unavailable");
		exit;
	};
...

This function decreases a counter that could have been previously increased by rl_check function.

Meaning of the parameters is as follows:

This function can be used from REQUEST_ROUTE, FAILURE_ROUTE, ONREPLY_ROUTE, BRANCH_ROUTE, ERROR_ROUTE, LOCAL_ROUTE, TIMER_ROUTE and EVENT_ROUTE.

...
	if (!rl_check("gw_$ru", 100, "TAILDROP")) {
		exit;
	} else {
		rl_dec_count("gw_$ru");
	};
...

This function resets a counter that could have been previously increased by rl_check function.

Meaning of the parameters is as follows:

This function can be used from REQUEST_ROUTE, FAILURE_ROUTE, ONREPLY_ROUTE, BRANCH_ROUTE, ERROR_ROUTE, LOCAL_ROUTE, TIMER_ROUTE and EVENT_ROUTE.

...
	if (!rl_check("gw_$ru", 100, "TAILDROP")) {
		exit;
	} else {
		rl_reset_count("gw_$ru");
	};
...

Lists the parameters and variabiles in the ratelimit module.

Name: rl_list

Parameters:

MI FIFO Command Format:

		opensips-cli -x mi rl_list gw_10.0.0.1
		

Resets the counter of a specified pipe.

Name: rl_reset_pipe

Parameters:

MI FIFO Command Format:

		opensips-cli -x mi rl_reset_pipe gw_10.0.0.1
		

Sets the PID Controller parameters for the Feedback Algorithm.

Name: rl_set_pid

Parameters:

MI FIFO Command Format:

		opensips-cli -x mi rl_set_pid 0.5 0.5 0.5
		

Gets the list of in use PID Controller parameters.

Name: rl_get_pid

Parameters: none

MI FIFO Command Format:

		opensips-cli -x mi rl_get_pid
		

Dumps each destination used for replication, as well as the timestamp of the last message received from them.

Name: rl_bin_status

Parameters: none

MI FIFO Command Format:

		opensips-cli -x mi rl_bin_status
		

Returns the counter of a pipe. The variable is read-only.

NULL will be returned if the pipe does not exist.