Highest number of DDS samples in the DataReader’s queue over the lifetime of the DataReader.

Current number of DDS samples in the DataReader’s queue.

Includes DDS samples that may not yet be available to be read or taken by the user due to DDS samples being received out of order or settings in the 46.6 PRESENTATION QosPolicy.

The number of batched samples received by the DataReader that were marked as removed by the DataWriter.

When the DataReader receives a batch, the batch can contain samples marked as removed by the DataWriter. Examples of removed samples in a batch are samples that were replaced due to KEEP_LAST_HISTORY_QOS on the DataWriter (see 47.12 HISTORY QosPolicy) or samples that outlived the DataWriter's 47.14 LIFESPAN QoS Policy duration. By default, any sample marked as removed from a batch is dropped, unless you set the dds.data_reader.accept_writer_removed_batch_samples property in the 47.19 PROPERTY QosPolicy (DDS Extension) to TRUE. (By default, it is set to FALSE.)

Note: Historical data with removed batch samples written before the DataReader joined the DDS domain are also included in the count.

The number of samples dropped as a result of receiving a sample older than the last one, using DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS.

When the DataReader is using DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS:

• If the DataReader receives a sample for an instance with a source timestamp that is older than the last source timestamp received for the instance, the sample is dropped and included in this count.
• If the DataReader receives a sample for an instance with a source timestamp that is equal to the last source timestamp received for the instance and the writer has a higher virtual GUID, the sample is dropped and included in this count.

The number of samples dropped as a result of receiving a sample in the future, using DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS.

When the DataReader is using DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS, the DataReader will accept a sample only if the source timestamp is no farther in the future from the reception timestamp than the source_timestamp_tolerance. Otherwise, the sample is dropped and included in this count.

The number of samples dropped as a result of receiving a sample from a DataWriter with a lower strength, using Exclusive Ownership.

When using Exclusive Ownership, the DataReader receives data from multiple DataWriters. Each instance can only be owned by one DataWriter. If other DataWriters write samples belonging to this instance, the samples will be dropped.

The number of samples filtered by the DataReader due to ContentFilteredTopics.

When using a content filter on the DataReader side, if the sample received by the DataReader does not pass the filter, it will be dropped.

The number of samples filtered by the DataReader due to the 48.4 TIME_BASED_FILTER QosPolicy.

When using the 48.4 TIME_BASED_FILTER QosPolicy on the DataReader side, if the sample received by the DataReader does not pass the minimum_separation filter, it will be dropped.

The number of samples expired by the DataReader due to the 47.14 LIFESPAN QoS Policy or the autopurge sample delays in the 48.3 READER_DATA_LIFECYCLE QoS Policy:

• DDS_LifespanQosPolicy: When a sample expires due to the DDS_LifespanQosPolicy, the data is removed from the DataReader caches. This sample will be considered dropped if its DDS_SampleStateKind is DDS_NOT_READ_SAMPLE_STATE.
• DDS_ReaderDataLifecycleQosPolicy::autopurge_nowriter_samples_delay: When a sample expires due to the autopurge_nowriter_samples_delay, this sample will be considered dropped if its DDS_SampleStateKind is DDS_NOT_READ_SAMPLE_STATE.
• DDS_ReaderDataLifecycleQosPolicy::autopurge_disposed_samples_delay: When a sample expires due to the autopurge_disposed_samples_delay, this sample will be considered dropped if its DDS_SampleStateKind is DDS_NOT_READ_SAMPLE_STATE.

The number of virtual duplicate samples dropped by the DataReader. A sample is a virtual duplicate if it has the same identity (Virtual Writer GUID and Virtual Sequence Number) as a previously received sample.

When two DataWriters with the same logical data source publish a sample with the same sequence_number, one sample will be dropped and the other will be received by the DataReader.

This can happen when multiple writers are writing on behalf of the same original DataWriter: for example, in systems with redundant RTI Routing Service applications or when a DataReader is receiving samples both directly from the original DataWriter and from an instance of RTI Persistence Service.

The number of samples replaced by the DataReader due to DDS_KEEP_LAST_HISTORY_QOS replacement in the 47.12 HISTORY QosPolicy.

When the number of samples for an instance in the queue reaches the depth value in the HISTORY QosPolicy, a new sample for the instance will replace the oldest sample for the instance in the queue. The new sample will be accepted, and the old sample will be dropped.

This counter will only be updated if the replaced sample's DDS_SampleStateKind is DDS_NOT_READ_SAMPLE_STATE.

Number of samples of the state NOT_READ_SAMPLE_STATE that were dropped when removing an instance due to instance replacement via the instance_replacement field in the 48.2 DATA_READER_RESOURCE_LIMITS QosPolicy (DDS Extension).

Number of instances currently in the DataReader's queue that have an instance_state of ALIVE.

Highest number of ALIVE instances in the DataReader's queue over the lifetime of the DataReader.

Number of instances in the DataReader's queue that have an instance_state of NOT_ALIVE_NO_WRITERS.

Highest number of NOT_ALIVE_NO_WRITERS instances in the DataReader's queue over the lifetime of the DataReader.

Number of instances in the DataReader's queue that have an instance_state of NOT_ALIVE_DISPOSED.

Highest number of NOT_ALIVE_DISPOSED instances in the DataReader's queue over the lifetime of the DataReader.

Number of detached instances—which contain only the minimum instance state—currently being maintained in the DataReader's queue.

If keep_minimum_state_for_instances in the 48.2 DATA_READER_RESOURCE_LIMITS QosPolicy (DDS Extension) is true (by default, it is), the DataReader will keep up to max_total_instances (in the DATA_READER_RESOURCE_LIMITS QosPolicy) of detached instances in its queue. See 40.8.7 Active State and Minimum State for more information.

The number of samples received by a DataReader.

Note: When data is fragmented, this count is updated when all of the fragments required to reassemble a sample are received, not when individual fragments are received. The fragment count is tracked in the received_fragment_count.

Change in the received_sample_count since the last time the status was read.

The number of bytes received by a DataReader.

Note: When data is fragmented, this statistic is updated upon the receipt of each fragment, not when a sample is reassembled.

Change in received_sample_bytes since the last time the status was read.

The number of DDS samples received from a DataWriter, not for the first time, by this DataReader.

Change in duplicate_sample_count since the last time the status was read.

The number of bytes of DDS samples received from a DataWriter received, not for the first time, by this DataReader.

Change in the duplicate_sample_bytes since the last time the status was read.

The number of DDS samples filtered by this DataReader due to ContentFilteredTopics or Time-Based Filter.

Change in the filtered_sample_count since the last time the status was read.

The number of bytes of DDS samples filtered by this DataReader due to ContentFilteredTopics or Time-Based Filter.

Change in the filtered_sample_bytes since the last time the status was read.

The number of Heartbeats received from a DataWriter by this DataReader.

Change in the received_heartbeat_count since the last time the status was read.

The number of bytes of Heartbeats received from a DataWriter by this DataReader.

Change in the received_heartbeat_bytes since the last time the status was read.

The number of ACKs sent from this DataReader to a matching DataWriter.

Change in the sent_ack_count since the last time the status was read.

The number of bytes of ACKs sent from this DataReader to a matching DataWriter.

Change in the sent_ack_bytes since the last time the status was read.

The number of NACKs sent from this DataReader to a matching DataWriter.

Change in the sent_nack_count since the last time the status was read.

The number of bytes of NACKs sent from this DataReader to a matching DataWriter.

Change in the sent_nack_bytes since the last time the status was read.

The number of GAPs received from a DataWriter to this DataReader.

Change in the received_gap_count since the last time the status was read.

The number of bytes of GAPs received from a DataWriter to this DataReader.

Change in the received_gap_bytes since the last time the status was read.

The number of times a sample is rejected because it cannot be accepted by a reliable DataReader. Samples rejected by a reliable DataReader will be NACKed, and they will have to be resent by the DataWriter if they are still available in the DataWriter queue.

Note: This count is a subset of the total_count in the 40.7.8 SAMPLE_REJECTED Status.The total_count in the SAMPLE_REJECTED status includes both protocol-related rejections, that trigger a repair or resend (the rejected_sample_count described here), and the rejections described in the 40.7.8 SAMPLE_REJECTED Status. For example, the DDS_REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT in the SAMPLE_REJECTED status is not part of the rejected_sample_count because it does not trigger a repair or resend.

Change in the rejected_sample_count since the last time the status was read.

The number of samples dropped by the DataReader due to the receive window being full and the sample received out-of-order.

When using reliable 47.21 RELIABILITY QosPolicy, if the DataReader receives samples out-of-order, they are stored internally until the missing samples are received. The number of out-of-order samples that the DataReader can keep is set by the receive_window_size in the Table 48.2 DDS_RtpsReliableReaderProtocol_t. When the receive window is full, any out-of-order sample received will be dropped and included in this count (but not in the SampleRejectedStatus).

Sequence number of the first available DDS sample in a matched DataWriter's reliability queue. Applicable only when retrieving matched DataWriter statuses.

Sequence number of the last available DDS sample in a matched DataWriter's reliability queue. Applicable only when retrieving matched DataWriter statuses.

Sequence number of the last committed DDS sample (i.e. available to be read or taken) in a matched DataWriter's reliability queue. Applicable only when retrieving matched DataWriter statuses.

For best-effort DataReaders, this is the sequence number of the latest DDS sample received.

For reliable DataReaders, this is the sequence number of the latest DDS sample that is available to be read or taken from the DataReader's queue.

Number of received DDS samples that are not yet available to be read or taken due to being received out of order. Applicable only when retrieving matched DataWriter statuses.

The number of fragments (DATA_FRAG messages) that have been received by this DataReader. This count is incremented upon the receipt of each DATA_FRAG message. Fragments from duplicate samples do not count towards this number. Applicable only when data is fragmented.

The number of DATA_FRAG messages that have been dropped by the DataReader. This count does not include malformed fragments. Applicable only when data is fragmented.

The number of samples that have been reassembled by the DataReader. This statistic is incremented when all of the fragments that are required to reassemble an entire sample have been received. Applicable only when data is fragmented.

The number of NACK FRAG RTPS messages that have been sent from the DataReader to a DataWriter. NACK FRAG RTPS messages are sent when large data is used in conjunction with reliable communication. They have the same properties as NACK messages, but instead of applying to samples, they apply to fragments. Applicable only when data is fragmented.

Number of matched DataWriters that are currently alive.

Number of matched DataWriters that are not currently alive.

The change in the alive_count since the last time the Listener was called or the status was read.

The change in the not_alive_count since the last time the Listener was called or the status was read.

Note that a positive not_alive_count_change means one of the following:

• The DomainParticipant containing the matched DataWriter has lost liveliness or has been deleted.
• The matched DataWriter has lost liveliness or has been deleted.

Cumulative number of times that the deadline was violated for any instance read by the DataReader.

The change in total_count since the last time the Listener was called or the status was read.

Cumulative number of times the DataReader discovered a DataWriter for the same Topic with an offered QoS that is incompatible with that requested by the DataReader.

The change in total_count since the last time the Listener was called or the status was read.

The ID of the QosPolicy that was found to be incompatible the last time an incompatibility was detected. (Note: if there are multiple incompatible policies, only one of them is reported here.)

Cumulative count of all the DDS samples that have been lost, across all instances of data written for the Topic.

The incremental number of DDS samples lost since the last time the Listener was called or the status was read.

The sample was not lost.

max_data_availability_waiting_time in the 47.1 AVAILABILITY QosPolicy (DDS Extension) expired.

When using BEST_EFFORT in the 47.21 RELIABILITY QosPolicy, a sample was lost because it could not be decoded.

When using RELIABLE in the RELIABILITY QosPolicy, the sample is rejected, not lost, with the reason REJECTED_BY_DECODE_FAILURE.

A sample was lost because it could not be deserialized. A sample may fail to be deserialized for the following reasons:

• The subscribing application has received a sample with a sequence or string member that is longer than the maximum allowed by the DataReader's data type.
• The subscribing application has received a sample with an unknown enum value. See the description of the dds.sample_assignability.accept_unknown_enum_value property in the Property Reference Guide for more information.
• The subscribing application has received a sample with an unknown union discriminator value. See the description of the dds.sample_assignability.accept_unknown_union_discriminator property in the Property Reference Guide for more information.
• The subscribing application has received a sample with an out-of-range value for one of the members that has been configured with a minimum or maximum value using the min, max, or range type annotations.
• Sample corruption has occurred. If this is the case, then using RTI Security Plugins or enabling CRC (see the compute_crc and check_crc fields in the 44.9 WIRE_PROTOCOL QosPolicy (DDS Extension)) can help avoid these failures.

A sample was lost because it is part of an incomplete coherent set. An incomplete coherent set is a coherent set for which some of the samples are missing.

For example, consider a DataWriter using KEEP_LAST in the 47.12 HISTORY QosPolicy with a depth of 1. The DataWriter publishes two samples of the same instance as part of a coherent set “CS1” ; the first sample of “CS1” is replaced by a new sample before it can be successfully delivered to the DataReader. In this case, the coherent set containing the two samples is considered incomplete. The new sample, by default, will not be provided to the application, and will be reported as LOST_BY_INCOMPLETE_COHERENT_SET. (You can change this default behavior by setting drop_incomplete_ coherent_set to FALSE in the 46.6 PRESENTATION QosPolicy. If you do, the new sample will be provided to the application, but it will be marked as part of an incomplete coherent set in the 41.6 The SampleInfo Structure.)

max_instances in the 47.22 RESOURCE_LIMITS QosPolicy was reached.

A sample was lost because it was part of a large coherent set. A large coherent set is a coherent set that cannot fit all at once into the DataReader queue because resource limits are exceeded.

For example, if max_samples_per_instance on the DataReader is 10 and the coherent set has 15 samples for a given instance, the coherent set is a large coherent set that will be considered incomplete.

The resource limits that can lead to large coherent sets are: max_samples, max_samples_per_instance, max_instances, and max_samples_per_remote_writer.

A sample was lost because there was not enough memory to store the sample.

A resource limit on the number of samples published by a DataWriter on behalf of a virtual DataWriter that a DataReader may store was reached. (This field is currently not used.)

max_remote_writers_per_instance in the 48.2 DATA_READER_RESOURCE_LIMITS QosPolicy (DDS Extension) was reached. (This limit is the number of DataWriters for a single instance from which a DataReader may read.)

max_remote_writers_per_sample in the 47.22 RESOURCE_LIMITS QosPolicy was reached. (This limit is the number of DataWriters that are allowed to write the same sample.)

When using BEST_EFFORT in the 47.21 RELIABILITY QosPolicy, max_samples in the 47.22 RESOURCE_LIMITS QosPolicy was reached.

When using RELIABLE in the RELIABILITY QosPolicy, reaching max_samples triggers a rejection, not a loss, with the reason REJECTED_BY_SAMPLES_LIMIT.

When using BEST_EFFORT in the 47.21 RELIABILITY QosPolicy, max_samples_per_instance in the 47.22 RESOURCE_LIMITS QosPolicy was reached.

When using RELIABLE in the RELIABILITY QosPolicy, reaching max_samples_per_instance triggers a rejection, not a loss, with the reason REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT.

When using BEST_EFFORT in the 47.21 RELIABILITY QosPolicy, max_samples_per_remote_writer in the 48.2 DATA_READER_RESOURCE_LIMITS QosPolicy (DDS Extension) was reached. (This limit is the number of samples from a given DataWriter that a DataReader may store.)

When using RELIABLE in the RELIABILITY QosPolicy, reaching max_samples_per_remote_writer triggers a rejection, not a loss, with the reason REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT.

A sample was lost because it didn't contain enough information for the DataReader to know what instance it was associated with.

max_remote_virtual_writers in the 48.2 DATA_READER_RESOURCE_LIMITS QosPolicy (DDS Extension) was reached. (This limit is the number of virtual DataWriters from which a DataReader may read.)

Cumulative count of all the DDS samples that have been rejected by the DataReader.

The incremental number of DDS samples rejected since the last time the Listener was called or the status was read.

The current number of writers with which the DataReader is matched.

The change in current_count since the last time the Listener was called or the status was read.

Reason for rejecting the last DDS sample. See Table 40.11 DDS_SampleRejectedStatusKind.

DDS sample was accepted.

When using RELIABLE in the 47.21 RELIABILITY QosPolicy, a sample was rejected because it could not be decoded.

When using BEST_EFFORT in the 47.21 RELIABILITY QosPolicy, the sample is lost, not rejected, with the reason LOST_BY_DECODE_FAILURE.

This field is not currently used.

When using RELIABLE in the 47.21 RELIABILITY QosPolicy, max_samples in the 47.22 RESOURCE_LIMITS QosPolicy was reached.

When using BEST_EFFORT in the RELIABILITY QosPolicy, reaching max_samples triggers a loss, not a rejection, with the reason LOST_BY_SAMPLES_LIMIT.

When using RELIABLE in the 47.21 RELIABILITY QosPolicy, max_samples_per_instance in the 47.22 RESOURCE_LIMITS QosPolicy was reached.

When using BEST_EFFORT in the RELIABILITY QosPolicy, reaching max_samples_per_instance triggers a loss, not a rejection, with the reason LOST_BY_SAMPLES_PER_INSTANCE_LIMIT.

When using RELIABLE in the 47.21 RELIABILITY QosPolicy, max_samples_per_remote_writer in the 48.2 DATA_READER_RESOURCE_LIMITS QosPolicy (DDS Extension) was reached. (This limit is the number of samples that a DataReader may store from a specific DataWriter.)

When using BEST_EFFORT in the RELIABILITY QosPolicy, reaching max_samples_per_remote_writer triggers a loss, not a rejection, with the reason LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT.

Cumulative number of times the DataReader discovered a "match" with a DataWriter.

This number increases whenever a new match is discovered. It does not decrease when an existing match goes away for any of the reasons listed above.

The changes in total_count since the last time the listener was called or the status was read.

Note that this number will never be negative (because it’s the total number of times the DataReader ever matched with a DataWriter).

The number of DataWriters currently matched to the concerned DataReader.

This number increases when a new match is discovered and decreases when an existing match goes away for any of the reasons listed above.

The change in current_count since the last time the listener was called or the status was read.

Note that a negative current_count_change means that one or more DataWriters have become unmatched for one or more of the reasons listed above.

Greatest number of DataWriters that matched this DataReader simultaneously. That is, there was no moment in time when more than this many DataWriters matched this DataReader. (As a result, total_count can be higher than current_count_peak.)