---
title: "Tracer Module"
description: "Offer a possibility to store incoming/outgoing SIP messages in database. Since version 2.2, proto_hep module needs to be loaded in order to duplicate with hep. All hep parameters moved inside proto_hep."
---

## Admin Guide


### Overview


Offer a possibility to store incoming/outgoing SIP messages in database.
		Since version 2.2, proto_hep module needs to be loaded in order to duplicate
		with hep. All hep parameters moved inside proto_hep.


The 2.2 version of OpenSIPS came with a major improvement in tracer module.
		Now all you have to do is call *trace()* function
		with the proper parameters and it will do the job for you. Now you can trace
		messages, transactions and dialogs with the same function. Also, you can trace
		to multiple databases, multiple hep destinations and sip destinations using
		only one parameter. All you need now is defining *trace_id*
		parameters in modparam section and switch between them in
		tracer function. Also you cand turn tracing  on
		and off using *trace_on* either globally(for all trace_ids)
		or for a certain trace_id.


IMPORTANT: In 2.2 version support for stateless trace has been removed.


The tracing tracing can be turned on/off using fifo command.


opensips-cli -x mi trace on
	opensips-cli -x mi trace [some_trace_id] on


opensips-cli -x mi trace off
	opensips-cli -x mi trace [some_trace_id] off


Starting with OpenSIPS 3.0 you can use the *trace_start* to
		create dynamic dynamic tracing destinations based on some custom filters.


### Dependencies


#### OpenSIPS Modules


The following modules must be loaded before this module:


- *database module* - mysql, postrgress,
				dbtext, unixodbc... only if you are using a database type
				trace id
- *b2b_logic* - only if you want to trace
				B2B sessions.
- *dialog* - only if you want to trace
				SIP dialogs (INVITE based).
- *tm* - only if you want to trace 
				SIP transactions.
- *proto_hep* - only if you want to 
				trace / replicate messages over HEP protocol.


#### External Libraries or Applications


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


- *None*.


### Exported Parameters


#### trace_on (integer)


Parameter to enable/disable trace (on(1)/off(0))


*Default value is "1"(enabled).*


```c title="Set trace_on parameter"
...
modparam("tracer", "trace_on", 1)
...
```


#### trace_local_ip (str)


The address to be used in the fields that specify the source address
		(protocol, ip and port) for locally generated messages. If not set,
		the module sets it to the address of the socket that will be used to send
		the message. Protocol and/or port are optional and if omitted will take
		the default values: udp and 5060.


*Default value is "NULL".*


```c title="Set trace_local_ip parameter"
...
#Resulting address: udp:10.1.1.1:5064
modparam("tracer", "trace_local_ip", "10.1.1.1:5064")
...

...
#Resulting address: tcp:10.1.1.1:5060
modparam("tracer, "trace_local_ip", "tcp:10.1.1.1")
...

...
#Resulting address: tcp:10.1.1.1:5064
modparam("tracer", "trace_local_ip", "tcp:10.1.1.1:5064")
...

...
#Resulting address: udp:10.1.1.1:5060
modparam("tracer", "trace_local_ip", "10.1.1.1")
...
```


#### trace_id (str)


Specify a destination for the trace. This can be a hep id defined
			in proto_hep, a sip uri, a file, a syslog facility or a database
			url and a table. All parameters inside
			*trace_id* must be separated by
			*;*, excepting the last one. The parameters
			are given in key-value format, the possible keys being
			*uri* for HEP and SIP IDs and
			*uri* and *table*
			for databases. The format is
			*[id_name]key1=value1;key2=value2;*. HEP
			id's **MUST** be defined in proto_hep in order
			to be able to use them here.


When the uri is a *file*, the path to the file has
			to be specified after the colon. The output is always appended if the file
			exists, or created if it doesn't, using [file mode](#param_file_mode)
			permissions.


When the uri is *syslog*, it has to follow the following
			format: *syslog[:FACILITY[:LEVEL]]*. The default
			facility and levels are the ones used by OpenSIPS
			(*syslog_facility* and *log_level*).
			These can be tuned using
			[syslog default facility](#param_syslog_default_facility) and
			[syslog default level](#param_syslog_default_level) parameters.


One can declare multiple types of tracing under the same trace
			id, being identified by their name. So if you define two
			database url, one hep uri and one sip uri with the same name,
			when calling trace() with this name tracing shall be done
			to all the destinations.


All the old parameter such as db_url, table and duplicate_uri
			will form the trace id with the name "default".


*No default value. If not set the module will be useless.*


```c title="Set trace_id parameter"
...
/*DB trace id*/
modparam("tracer", "trace_id",
"[tid]
uri=mysql://xxxx:xxxx@10.10.10.10/opensips;
table=new_sip_trace;")
/* hep trace id with the hep id defined in proto_hep; check proto_hep docs
 * for more information */
modparam("proto_hep", "hep_id",  "[hid]10.10.10.10")
modparam("tracer", "trace_id", "[tid]uri=hep:hid")
/*sip trace id*/
modparam("tracer", "trace_id",
"[tid]uri=sip:10.10.10.11:5060")
/* notice that they all have the same name
 * meaning that calling trace("tid",...)
 * will do sql, sip and hep tracing */
/*file trace id*/
modparam("tracer", "trace_id",
"[tid]uri=file:/path/to/file")
/*syslog trace id at error (level -1)*/
modparam("tracer", "trace_id",
"[tid]uri=syslog:local0:-1")
...
```


#### syslog_default_facility (string)


When *syslog* tracing is used, this parameter specifies
			the log facility to write traces to.


*Default value is the value of *syslog_facility*.*


```c title="Set syslog_default_facility parameter"
...
modparam("tracer", "syslog_default_facility", "LOG_DAEMON")
...
```


#### syslog_default_level (integer)


When *syslog* tracing is used, this parameter specifies
			the level to write traces to.


*Default value is the value of *log_level*.*


```c title="Set syslog_default_level parameter"
...
modparam("tracer", "syslog_default_level", 2) # NOTICE
...
```


#### file_mode (integer)


When *file* tracing is used, this parameter
			specifies the permissions to be used to create the trace files.
			It follows the UNIX conventions.


*Default value is *0600 (rw-------)*.*


```c title="Set file_mode parameter"
...
modparam("tracer", "file_mode", 0644)
...
```


### Exported Functions


#### trace(trace_id, [scope], [type], [trace_attrs], [flags], [correlation_id])


This function has replaced the *sip_trace()* in OpenSIPS 3.0.


Store or replicate current processed SIP message, transaction / dialog or B2B session.
			It is stored in the form prior applying chages made to it. The traced_user_avp
			parameter is now an argument to trace() function. Since version 2.2, this function
			also catches internally generated replies in stateless mode(sl_send_reply(...)).


This function can be used from REQUEST_ROUTE, FAILURE_ROUTE, ONREPLY_ROUTE, BRANCH_ROUTE.


Meaning of the parameters is as follows:


- *trace_id (string)*
			the name of the *trace_id* specifying where to do
			the tracing.
- *scope (string, optional)* what do you 
		want to trace: dialog, transaction, B2B session or only the message. 
		If not specified, will try the topmost trace that can be done: 
		if dialog module loaded will trace dialogs, else if tm module loaded
		will trace transaction and if none of these loaded will trace messages.
Types can be the following:

  - *'m'/'M'* trace messages. Is the only
				one you should use in stateless mode.
  - *'t'/'T'* trace transactions. If tm
					module not loaded, it will be in stateless transaction aware
					mode meaning that will catch selected requests both in and out
				and internally generated replies.
  - *'d'/'D'* trace dialog
  - *'b'/'B'* trace all the traffic
				related to the B2B session to be later created
- *type (string, optional)* list of types of messages to
			be traced by this function; if not set only sip messages shall be traced;
			if the parameter is set, but *sip* is not specified,
			*sip* shall not be traced;
			all the parameters from the list shall be separated by '|'
Current possible types to be traced are the following:

  - *sip* - enable sip messages 
					tracing;
  - *xlog* - enable xlog messages 
					tracing in current scope(dialog, transaction, B2B session
					or message);
  - *rest* - enable rest messages 
					tracing;
- *trace_attrs (string, optional)* this parameter
			replaces the traced_user_avp from the old version. To avoid duplicating
			an entry only for this parameter, whatever you put here(string/pvar)
			shall be stored in the trace_attrs column in the sip_trace table.
- *flags (string,pvar)* are some control
			flags over the tracing process (how and what to be traced).

  - *C* - trace only the SIP caller side;
  - *c* - trace onlt the SIP callee side;
If both *C* and *c* flags are missing, tracing of both sides/legs is assumed.
NOTE these flags are supported only by transactional and dialog tracing
- *correlation_id (string,pvar)* a custom
			SIP correlation ID to be forced (normally the SIP Call-ID is used)
			to correlate this traffic (transaction, dialog) with other traffic.


```c title="trace() usage"
...
/* see declaration of tid in trace_id section */
	$var(trace_id) = "tid";
	$var(user) = "osip_user@opensips.org";

...
/* Example 1: how to trace a dialog sip and xlog */
	if (has_totag()) {
		match_dialog();
	} else {
		if (is_method("INVITE") {
			trace($var(trace_id), "d", "sip|xlog", $var(user));
		}
	}
...
/* Example 2: how to trace initial INVITE and BYE, sip and rest */
	if (has_totag()) {
		if (is_method("BYE")) {
			trace($var(trace_id), "m", "sip|rest", $var(user));
		}
	} else {
		if (is_method("INVITE")) {
			trace($var(trace_id), "m", "sip|rest", $var(user));
		}
	}

...
/* Example 3: trace initial INVITE transaction's only xlog and rest, no sip */
	if (!has_totag()) {
		if (is_method("INVITE")) {
			trace($var(trace_id), "t", "xlog|rest", $var(user));
		}
	}
...
/* Example 4: stateless transaction aware mode!*/
/* tm module must not be loaded */
	if (is_method("REGISTER")) {
		trace($var(trace_id), "t", "xlog|rest", $var(user));
		if (!www_authorize("", "subscriber")) {
			/* tracer will also catch the 401 generated by www_challenge() */
			www_challenge("", "auth");
		}
	}
```


### Exported MI Functions


#### trace


Enable/disable tracing(globally or for a specific trace id) or dump
			info about trace ids. This command requires named parameters
			(each parameter is ginven in the format param_name=param_value).


Name: *trace*


Parameters:


- *id* (optional) - the name of the tracing instance.
				If this parameter is missing the command will
				either dump info for all tace ids(and return the global tracing state)
				or set the global tracing state.
- *mode* (optional) - 
				possible values are:

  - "on" - enable tracing
  - "off" - disable tracing
If the first parameter is missing, the command wil set the global
				tracing state, otherwise it will set the state for a specific trace id.
				If you turn global trace on but some of the trace ids had tracing set to
				off, then they shall not do tracing. If you want to turn the tracing on
				for all trace ids you will have to set it separately for each of them.
If this parameter is missing but the first is set, the command will
				only dump info about that specific trace id. If both parameters are
				missing, the command will return the global tracing state and dump
				info for each id.


MI FIFO Command Format:


```c
# Display global tracing mode and all trace destinations:
opensips-cli -x mi trace
# Turn off global tracing:
opensips-cli -x mi trace mode=off
# Turn on tracing for destination id tid2:
opensips-cli -x mi trace id=tid2 mode=on
		
```


#### trace_start


Creates a dynamic tracing destination based using custom filters.
			This function can be used to debug calls for certain destinations
			real-time.


Dynamic destinations are not restart persistent!


Name: *trace_start*


Parameters:


- *id* - the name of the tracing instance.
- *uri* - the destination uri for this instance.
- *filter* (optional) - used to filter the traffic
				received by the sender. This parameter should be an array that can
				contain multiple filters in the *condition=value*
				format.
				Possible values for the *condition* argument are:

  - caller
  - callee
  - ip
The *condition* parameter can consist of multiple different filters.
				In order to satisfy the overall condition and send traffic to the desired destination,
				all conditions have to be satisfied.
If this parameter is missing all traffic is forwarded to the destination.
The filter is applied for any incoming request
- *scope* - the scope to engage the tracing for.
				The format received by this parameter is similar to the one
				received by the *trace()* function.
- *type* - the type of messages you want to receive.
				The format received by this parameter is similar to the one
				received by the *trace()* function.


MI FIFO Command to start tracing calls from IP 127.0.0.1 to HEP destination 10.0.0.1:9060:


```c
		opensips-cli -x mi trace_start id=ip_filter uri=hep:10.0.0.1:9060 filter=ip=127.0.0.1
		
```


MI FIFO Command to start tracing calls from user Alice to user Bob:


```c
		opensips-cli -x mi trace_start id=alice_bob uri=hep:10.0.0.1:9060 filter=caller=Alice filter=caller=Bob
		
```


#### trace_stop


Stops OpenSIPS from sending traffic to a dynamic trace id created
			using the *trace_start* command.


Name: *trace_stop*


Parameters:


- *id* - the name of the tracing instance to be stopped.


MI FIFO Command to stop tracing calls from user Alice to user Bob:


```c
		opensips-cli -x mi trace_stop alice_bob
		
```


### Database setup


Before running OpenSIPS with tracer, you have to setup the database
			tables where the module will store the data. For that, if the
			table were not created by the installation script or you choose
			to install everything by yourself you can use the tracer-create.sql
			SQL script in the database directories in the
			opensips/scripts folder as template.
			You can also find the complete database documentation on the
			project webpage, [https://opensips.org/docs/db/db-schema-devel.html](https://opensips.org/docs/db/db-schema-devel.html).


### Known Issues


ACKs related to a transaction that are leaving OpenSIPS are not
			traced since they are handled statelessly using forward_request function.
			Fixing it would mean to register a fwdcb callback that would be called
			for all the messages but would be used only by ACKs, which would be
			highly ineffective.
<!-- CONTRIBUTORS -->

### License

All documentation files (i.e. .md extension) are licensed under the Creative Common License 4.0
