diff --git a/build/rpm/pcp.spec.in b/build/rpm/pcp.spec.in
index 62b07568681..e6529ae013e 100755
--- a/build/rpm/pcp.spec.in
+++ b/build/rpm/pcp.spec.in
@@ -1674,6 +1674,20 @@ This package contains the PCP Performance Metrics Domain Agent (PMDA) for
 collecting statistics for nVidia RDMA over Converged Ethernet (RoCE) devices.
 # end pcp-pmda-rocestat
 
+#
+# pcp-pmda-rds
+#
+%package pmda-rds
+License: GPL-2.0-or-later
+Summary: Performance Co-Pilot (PCP) metrics for Reliable Datagram Sockets (RDS) protocol
+URL: https://pcp.io
+Requires: pcp = @package_version@ pcp-libs = @package_version@
+Requires: python3-pcp
+%description pmda-rds
+This package contains the PCP Performance Metrics Domain Agent (PMDA) for
+collecting statistics for RDS connections
+# end pcp-pmda-rds
+
 #
 # pcp-pmda-openvswitch
 #
@@ -2376,6 +2390,7 @@ basic_manifest | keep '(etc/pcp|pmdas)/podman(/|$)' >pcp-pmda-podman-files
 basic_manifest | keep '(etc/pcp|pmdas)/postfix(/|$)' >pcp-pmda-postfix-files
 basic_manifest | keep '(etc/pcp|pmdas)/postgresql(/|$)' >pcp-pmda-postgresql-files
 basic_manifest | keep '(etc/pcp|pmdas)/rabbitmq(/|$)' >pcp-pmda-rabbitmq-files
+basic_manifest | keep '(etc/pcp|pmdas)/rds(/|$)' >pcp-pmda-rds-files
 basic_manifest | keep '(etc/pcp|pmdas)/redis(/|$)' >pcp-pmda-redis-files
 basic_manifest | keep '(etc/pcp|pmdas)/resctrl(/|$)|sys-fs-resctrl' >pcp-pmda-resctrl-files
 basic_manifest | keep '(etc/pcp|pmdas)/rocestat(/|$)' >pcp-pmda-rocestat-files
@@ -2415,7 +2430,7 @@ for pmda_package in \
     nutcracker nvidia \
     openmetrics opentelemetry openvswitch oracle \
     pdns perfevent podman postfix postgresql \
-    rabbitmq redis resctrl rocestat roomtemp rsyslog \
+    rabbitmq rds redis resctrl rocestat roomtemp rsyslog \
     samba sendmail shping slurm smart snmp \
     sockets statsd summary systemd \
     unbound uwsgi \
@@ -2856,6 +2871,9 @@ done
 %preun pmda-rocestat
 %{pmda_remove "$1" "rocestat"}
 
+%preun pmda-rds
+%{pmda_remove "$1" "rds"}
+
 %preun pmda-uwsgi
 %{pmda_remove "$1" "uwsgi"}
 %endif
@@ -3184,6 +3202,8 @@ fi
 
 %files pmda-rocestat -f pcp-pmda-rocestat-files.rpm
 
+%files pmda-rds -f pcp-pmda-rds-files.rpm
+
 %files pmda-uwsgi -f pcp-pmda-uwsgi-files.rpm
 
 %files export-pcp2graphite -f pcp-export-pcp2graphite-files.rpm
diff --git a/build/rpm/redhat.spec b/build/rpm/redhat.spec
index c53336d8dc8..0c2fc9d4875 100644
--- a/build/rpm/redhat.spec
+++ b/build/rpm/redhat.spec
@@ -1781,6 +1781,21 @@ collecting statistics for nVidia RDMA over Converged Ethernet (RoCE) devices.
 # end pcp-pmda-rocestat
 %endif
 
+#
+# pcp-pmda-rds
+#
+%package pmda-rds
+License: GPL-2.0-or-later
+Summary: Performance Co-Pilot (PCP) metrics for Reliable Datagram Sockets (RDS) protocol
+URL: https://pcp.io
+Requires: pcp = %{version}-%{release} pcp-libs = %{version}-%{release}
+Requires: python3-pcp
+%description pmda-rds
+This package contains the PCP Performance Metrics Domain Agent (PMDA) for
+collecting statistics for RDS connections.
+# end pcp-pmda-rds
+%endif
+
 %if !%{disable_mongodb}
 #
 # pcp-pmda-mongodb
@@ -2516,6 +2531,7 @@ basic_manifest | keep '(etc/pcp|pmdas)/podman(/|$)' >pcp-pmda-podman-files
 basic_manifest | keep '(etc/pcp|pmdas)/postfix(/|$)' >pcp-pmda-postfix-files
 basic_manifest | keep '(etc/pcp|pmdas)/postgresql(/|$)' >pcp-pmda-postgresql-files
 basic_manifest | keep '(etc/pcp|pmdas)/rabbitmq(/|$)' >pcp-pmda-rabbitmq-files
+basic_manifest | keep '(etc/pcp|pmdas)/rds(/|$)' >pcp-pmda-rds-files
 basic_manifest | keep '(etc/pcp|pmdas)/redis(/|$)' >pcp-pmda-redis-files
 basic_manifest | keep '(etc/pcp|pmdas)/resctrl(/|$)|sys-fs-resctrl' >pcp-pmda-resctrl-files
 basic_manifest | keep '(etc/pcp|pmdas)/rocestat(/|$)' >pcp-pmda-rocestat-files
@@ -2556,7 +2572,7 @@ for pmda_package in \
     nutcracker nvidia \
     openmetrics opentelemetry openvswitch oracle \
     pdns perfevent podman postfix postgresql \
-    rabbitmq redis resctrl rocestat roomtemp rpm rsyslog \
+    rabbitmq rds redis resctrl rocestat roomtemp rpm rsyslog \
     samba sendmail shping slurm smart snmp \
     sockets statsd summary systemd \
     unbound uwsgi \
@@ -2949,6 +2965,9 @@ exit 0
 %preun pmda-rocestat
 %{pmda_remove "$1" "rocestat"}
 
+%preun pmda-rds
+%{pmda_remove "$1" "rds"}
+
 %endif
 
 %preun pmda-apache
@@ -3304,6 +3323,8 @@ fi
 
 %files pmda-rocestat -f pcp-pmda-rocestat-files.rpm
 
+%files pmda-rds -f pcp-pmda-rds-files.rpm
+
 %files pmda-uwsgi -f pcp-pmda-uwsgi-files.rpm
 
 %files export-pcp2graphite -f pcp-export-pcp2graphite-files.rpm
diff --git a/qa/1998 b/qa/1998
new file mode 100644
index 00000000000..1a4f6461db3
--- /dev/null
+++ b/qa/1998
@@ -0,0 +1,78 @@
+#!/bin/sh
+# PCP QA Test No. 1998
+# Testing PCP RDS PMDA - install, remove and values.
+#
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+. ./common.python
+
+pmda_path="$PCP_PMDAS_DIR/rds"
+pmda_script="$pmda_path/pmdards.python"
+test_script="rds/rds_test.python"
+
+[ -d $pmda_path ] || _notrun "RDS PMDA is not installed"
+
+$python -c "from pcp import pmda" >/dev/null 2>&1
+[ $? -eq 0 ] || _notrun "python pcp pmda module not installed"
+
+status=1	# failure is the default!
+trap "_cleanup_pmda rds; exit \$status" 0 1 2 3 15
+
+pmdards_filter()
+{
+    sed \
+        -e "s/Ran [0-9]* tests in [0-9]*\.[0-9][0-9]*s/Ran X tests in YYYs/" \
+        -e "s/FAILED (failures=[0-9]*)/FAILED (failures=X)/" \
+        -e "/^$/d"
+}
+
+pmdards_remove()
+{
+    cd $pmda_path
+    echo
+    echo "=== Removing RDS agent ==="
+    $sudo ./Remove >$tmp.out 2>&1
+}
+
+pmdards_install()
+{
+    cd $pmda_path
+    $sudo ./Remove >/dev/null 2>&1
+
+    echo
+    echo "=== Installing RDS agent ==="
+    $sudo ./Install </dev/null >$tmp.out 2>&1
+    cd $here
+}
+
+# Real QA test starts here
+_prepare_pmda rds
+
+pmdards_install
+
+echo "=== Report metric values ==="
+
+metrics=`pminfo rds | LC_COLLATE=POSIX sort`
+
+pminfo -dfmtT $metrics 2>&1
+
+pmdards_remove
+
+# Success, all done
+status=0
+exit
\ No newline at end of file
diff --git a/qa/1998.out b/qa/1998.out
new file mode 100644
index 00000000000..b2ed7dd679e
--- /dev/null
+++ b/qa/1998.out
@@ -0,0 +1,638 @@
+QA output created by 1998
+
+=== Installing RDS agent ===
+=== Report metric values ===
+
+rds.lat.arp_cache PMID: 255.9.2 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+    value "10.211.8.2 dev eth0 lladdr 58:ac:78:e3:66:7f used 451734/451794/451734 probes 0 STALE
+10.211.8.3 dev eth0 lladdr 58:ac:78:e3:59:ff used 451741/451801/451741 probes 0 STALE
+10.211.8.1 dev eth0 lladdr 00:00:0c:9f:f0:1f ref 1 used 12/0/12 probes 1 REACHABLE
+10.211.8.40 dev eth0 lladdr 56:6f:f5:fe:00:a9 used 12395/12390/12358 probes 1 STALE
+10.211.8.19 dev eth0 lladdr a4:4c:11:6c:c8:3f used 436243/436303/436243 probes 0 STALE
+fe80::5:73ff:fea0:2 dev eth0 lladdr 00:05:73:a0:00:02 router used 823/823/795 probes 1 STALE
+fe80::5aac:78ff:fee3:667f dev eth0 lladdr 58:ac:78:e3:66:7f router used 818/818/791 probes 1 STALE
+2606:b400:400:3451::2 dev eth0 lladdr 58:ac:78:e3:66:7f router used 15293/15293/15258 probes 1 STALE
+"
+
+rds.lat.rds_ping PMID: 255.9.1 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+    value "{}"
+
+rds.lat.ping PMID: 255.9.0 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+    value ""
+
+rds.info.retrans_queue PMID: 255.8.6 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+No value(s) available!
+
+rds.info.send_queue PMID: 255.8.5 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+No value(s) available!
+
+rds.info.recv_queue PMID: 255.8.4 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+No value(s) available!
+
+rds.info.rds_conns PMID: 255.8.3 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+No value(s) available!
+
+rds.info.sockets PMID: 255.8.2 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+    value "0.0.0.0 0 0.0.0.0 0 106496 106496 365993 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366074 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366122 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366135 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366148 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366316 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366332 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366397 0 31541 python3
+0.0.0.0 0 0.0.0.0 0 106496 106496 366398 0 31541 python3
+"
+
+rds.info.tcp_conns PMID: 255.8.1 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+No value(s) available!
+
+rds.info.ib_conns PMID: 255.8.0 []
+    Data Type: string  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: none
+No value(s) available!
+
+rds.sock.bytes_freed_from_sock PMID: 255.7.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: byte
+    value 0
+
+rds.sock.bytes_added_to_sock PMID: 255.7.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: byte
+    value 0
+
+rds.ib.listen_closed_stale PMID: 255.6.62 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tasklet_call PMID: 255.6.60 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.evt_handler_call PMID: 255.6.59 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.connect_raced PMID: 255.6.58 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.srq.empty_refills PMID: 255.6.57 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.srq.refills PMID: 255.6.56 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.srq.lows PMID: 255.6.55 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.1m_pool_depleted PMID: 255.6.54 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.1m_pool_wait PMID: 255.6.53 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.1m_pool_flush PMID: 255.6.52 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.1m_used PMID: 255.6.51 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.1m_free PMID: 255.6.50 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.1m_alloc PMID: 255.6.49 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.8k_pool_depleted PMID: 255.6.48 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.8k_pool_wait PMID: 255.6.47 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.8k_pool_flush PMID: 255.6.46 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.8k_used PMID: 255.6.45 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.8k_free PMID: 255.6.44 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rdma_mr.8k_alloc PMID: 255.6.43 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.cm.watchdog_triggered PMID: 255.6.42 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.atomic.fadd PMID: 255.6.41 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.atomic.cswp PMID: 255.6.40 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.yield.success PMID: 255.6.39 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.yield.accepting PMID: 255.6.38 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.yield.expired PMID: 255.6.37 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.yield.stale PMID: 255.6.36 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.yield.right_of_way PMID: 255.6.35 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.yield.yielding PMID: 255.6.34 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.nmb_cache_removed PMID: 255.6.33 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.nmb_cache_added PMID: 255.6.32 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.cache_removed PMID: 255.6.31 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.cache_added PMID: 255.6.30 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.get_miss PMID: 255.6.29 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.get_ready PMID: 255.6.28 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.put_percpu PMID: 255.6.27 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.get_percpu PMID: 255.6.26 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.free PMID: 255.6.25 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.alloc PMID: 255.6.24 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.put_free PMID: 255.6.23 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.put_alloc PMID: 255.6.22 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.put PMID: 255.6.21 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cache.get PMID: 255.6.20 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.credit_updates PMID: 255.6.19 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.total_incs PMID: 255.6.18 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.total_frags PMID: 255.6.17 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.alloc_limit PMID: 255.6.16 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.refill_lock_taken PMID: 255.6.15 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.refill_from_thread PMID: 255.6.14 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.refill_from_cq PMID: 255.6.13 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.refill_from_cm PMID: 255.6.12 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.ring_empty PMID: 255.6.11 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.rx.cq_event PMID: 255.6.10 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tx.cq_event PMID: 255.6.61 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tx.credit_updates PMID: 255.6.9 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tx.stalled PMID: 255.6.8 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tx.sg_mapping_failure PMID: 255.6.7 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tx.throttle PMID: 255.6.6 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.tx.ring_full PMID: 255.6.5 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.ack.received PMID: 255.6.4 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.ack.send_piggybacked PMID: 255.6.3 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.ack.send_delayed PMID: 255.6.2 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.ack.send_failure PMID: 255.6.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.ib.ack.sent PMID: 255.6.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.copy_from_user PMID: 255.5.6 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.copy_to_user PMID: 255.5.5 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.page_rem_miss PMID: 255.5.4 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.page_rem_hit PMID: 255.5.3 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.page_frees PMID: 255.5.2 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.page_gets PMID: 255.5.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.mem.page_allocs PMID: 255.5.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.sendq.send_lock_contention PMID: 255.4.3 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.sendq.q_full PMID: 255.4.2 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.sendq.q_empty PMID: 255.4.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.sendq.send_lock_q_raced PMID: 255.4.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.drop.dead_sock PMID: 255.3.30 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.drop.no_sock PMID: 255.3.29 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.drop.old_seq PMID: 255.3.28 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.drop.bad_csum PMID: 255.3.27 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_delivered PMID: 255.3.26 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_deliver_raced PMID: 255.3.25 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.ack_reqd PMID: 255.3.24 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.delayed_retry PMID: 255.3.23 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_imm_retry PMID: 255.3.22 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_mprds_pong PMID: 255.3.21 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_mprds_ping PMID: 255.3.20 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_hb_pong PMID: 255.3.19 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_hb_ping PMID: 255.3.18 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_pong PMID: 255.3.17 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_ping PMID: 255.3.16 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.rx.recv_rdma_bytes PMID: 255.3.15 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: byte
+    value 0
+
+rds.packet.rx.recv_queued PMID: 255.3.14 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_stuck_rm PMID: 255.3.13 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_drop_acked PMID: 255.3.12 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_ack_reqd PMID: 255.3.11 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_delayed_retry PMID: 255.3.10 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_imm_retry PMID: 255.3.9 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_mprds_pong PMID: 255.3.8 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_mprds_ping PMID: 255.3.7 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_hb_pong PMID: 255.3.6 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_hb_ping PMID: 255.3.5 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_pong PMID: 255.3.4 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_ping PMID: 255.3.3 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_rdma_bytes PMID: 255.3.2 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: byte
+    value 0
+
+rds.packet.tx.send_rdma PMID: 255.3.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.packet.tx.send_queued PMID: 255.3.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.cong.cong_update_received PMID: 255.2.3 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.cong.cong_send_error PMID: 255.2.2 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.cong.cong_update_queued PMID: 255.2.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.cong.cong_send_blocked PMID: 255.2.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.conn.qos_threshold_exceeded PMID: 255.1.1 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+rds.conn.conn_reset PMID: 255.1.0 []
+    Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
+    Semantics: instant  Units: count
+    value 0
+
+=== Removing RDS agent ===
diff --git a/qa/group b/qa/group
index 40c71e24d74..0eebb1f4ec2 100644
--- a/qa/group
+++ b/qa/group
@@ -2310,5 +2310,6 @@ telnet-probe
 1995 pmda.linux local
 1996 pmda.infiniband local
 1997 pcp nfsiostat python local
+1998 pmda.rds local python
 4751 libpcp threads valgrind local pcp helgrind
 9000 other local
diff --git a/src/pmdas/GNUmakefile b/src/pmdas/GNUmakefile
index 6d96bcfe3c3..a47f0a3db4d 100644
--- a/src/pmdas/GNUmakefile
+++ b/src/pmdas/GNUmakefile
@@ -41,7 +41,7 @@ PYPMDAS = bcc gluster zswap unbound mic haproxy \
 	libvirt lio openmetrics opentelemetry \
 	elasticsearch bpftrace mssql netcheck \
 	rabbitmq openvswitch nfsclient mongodb \
-	uwsgi rocestat hdb
+	uwsgi rocestat hdb rds
 
 SUBDIRS = $(CPMDAS) $(PLPMDAS) $(PYPMDAS)
 LDIRT = pmcd.conf
diff --git a/src/pmdas/rds/GNUmakefile b/src/pmdas/rds/GNUmakefile
new file mode 100644
index 00000000000..1eaa4aa1042
--- /dev/null
+++ b/src/pmdas/rds/GNUmakefile
@@ -0,0 +1,63 @@
+#
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+
+TOPDIR = ../../..
+include $(TOPDIR)/src/include/builddefs
+
+IAM	= rds
+PYSCRIPT = pmda$(IAM).python
+LDIRT	= domain.h root pmns $(IAM).log
+DOMAIN	= RDS
+SUBDIRS = modules
+
+PMDAADMDIR	= $(PCP_PMDASADM_DIR)/$(IAM)
+PMDATMPDIR	= $(PCP_PMDAS_DIR)/$(IAM)
+
+MAN_SECTION = 1
+MAN_PAGES = pmda$(IAM).$(MAN_SECTION)
+MAN_DEST = $(PCP_MAN_DIR)/man$(MAN_SECTION)
+
+default_pcp default ::	build-me
+
+include $(BUILDRULES)
+
+ifeq "$(HAVE_PYTHON)" "true"
+build-me:	check_domain
+
+install_pcp install ::	default 
+	$(INSTALL) -m 755 -d $(PMDAADMDIR)
+	$(INSTALL) -m 755 -d $(PMDATMPDIR)
+	$(INSTALL) -m 755 -t $(PMDATMPDIR) Install Remove $(PYSCRIPT) $(PMDAADMDIR)
+	@$(INSTALL_MAN)
+
+default_pcp default :: $(SUBDIRS)
+	$(SUBDIRS_MAKERULE)
+
+install_pcp install :: $(SUBDIRS)
+	$(SUBDIRS_MAKERULE)
+else
+build-me:
+install_pcp install:
+	@$(INSTALL_MAN)
+endif
+
+check_domain:	../../pmns/stdpmid
+	$(DOMAIN_PYTHONRULE)
+
+check:: $(PYSCRIPT)
+	$(PYLINT) $^
+
+check:: $(MAN_PAGES)
+	$(MANLINT) $^
diff --git a/src/pmdas/rds/Install b/src/pmdas/rds/Install
new file mode 100755
index 00000000000..05992cd24d6
--- /dev/null
+++ b/src/pmdas/rds/Install
@@ -0,0 +1,32 @@
+#
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+
+. $PCP_DIR/etc/pcp.env
+. $PCP_SHARE_DIR/lib/pmdaproc.sh
+
+iam=rds
+python_opt=true
+daemon_opt=false
+
+#
+# See pmcd(1) man page. PMDA starts up in the "not ready" state.
+# When it has finished starting up, it sends a PM_ERR_PMDAREADY
+# error PDU to PMCD to indicate it's ready to start processing
+# requests.
+
+ipc_prot="binary notready"
+pmdaSetup
+pmdaInstall
+exit
diff --git a/src/pmdas/rds/Remove b/src/pmdas/rds/Remove
new file mode 100755
index 00000000000..a77324f9610
--- /dev/null
+++ b/src/pmdas/rds/Remove
@@ -0,0 +1,35 @@
+#
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# Remove the rds PMDA
+#
+
+# source the PCP configuration environment variables
+. $PCP_DIR/etc/pcp.env
+
+# Get the common procedures and variable assignments
+#
+. $PCP_SHARE_DIR/lib/pmdaproc.sh
+
+# The name of the PMDA
+#
+iam=rds
+
+# Do it
+#
+pmdaSetup
+pmdaRemove
+
+
+exit
diff --git a/src/pmdas/rds/domain.h b/src/pmdas/rds/domain.h
new file mode 100644
index 00000000000..c57ad897123
--- /dev/null
+++ b/src/pmdas/rds/domain.h
@@ -0,0 +1 @@
+#define RDS 255
diff --git a/src/pmdas/rds/modules/GNUmakefile b/src/pmdas/rds/modules/GNUmakefile
new file mode 100644
index 00000000000..10bcb14a85b
--- /dev/null
+++ b/src/pmdas/rds/modules/GNUmakefile
@@ -0,0 +1,35 @@
+#
+# Copyright (c) 2025 Oracle and/or its affiliates
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+
+TOPDIR = ../../../..
+include $(TOPDIR)/src/include/builddefs
+
+IAM		= rds
+PYSCRIPTS	= $(shell echo *.python)
+
+PMDAADMDIR	= $(PCP_PMDASADM_DIR)/$(IAM)/modules
+PMDATMPDIR	= $(PCP_PMDAS_DIR)/$(IAM)/modules
+
+include $(BUILDRULES)
+
+default_pcp default:	$(SCRIPTS)
+
+install_pcp install:	default
+	$(INSTALL) -m 755 -d $(PMDAADMDIR)
+	$(INSTALL) -m 755 -d $(PMDATMPDIR)
+	$(INSTALL) -m 644 -t $(PMDATMPDIR) $(PYSCRIPTS) $(PMDAADMDIR)
+
+check:: $(PYSCRIPTS)
+	$(PYLINT) $^
diff --git a/src/pmdas/rds/modules/__init__.python b/src/pmdas/rds/modules/__init__.python
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/src/pmdas/rds/modules/ping.python b/src/pmdas/rds/modules/ping.python
new file mode 100644
index 00000000000..8d7baa709d8
--- /dev/null
+++ b/src/pmdas/rds/modules/ping.python
@@ -0,0 +1,321 @@
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+"""
+Python implementation of ping
+"""
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+# pylint: disable=global-statement,no-member
+
+from collections import defaultdict
+import json
+import socket
+import sys
+import os
+import time
+import select
+from datetime import datetime
+import argparse
+import struct
+import ipaddress
+import threading
+import signal
+import re
+import concurrent.futures
+from modules.rds_info import RdsInfo
+
+ICMP_ECHO = 8
+ICMP_MAX_RECV = 2048
+RDS_INFO_LEN = 176
+SOL_RDS = 276
+RDS_INFO_IB_CONNECTIONS = 10008
+
+pings_sent = 0
+pending = 0
+OWN_ID = os.getpid() & 0xFFFF
+pings_json = {}
+
+
+def signal_handler(sig, frame):
+    sys.exit(0)
+
+
+def create_socket():
+    try:
+        sock_fd = socket.socket(
+            socket.AF_INET, socket.SOCK_RAW, 1)  # 1 for ICMP
+        return sock_fd
+    except socket.error as err:
+        print("socket creation failed with error %s" % (err), file=sys.stderr)
+        return None
+
+
+def bind_socket(sock_fd, src_ip):
+    src_port = 0
+    try:
+        sock_fd.bind((src_ip, src_port))
+    except socket.error as err:
+        print("socket bind failed with error %s" % (err), file=sys.stderr)
+
+
+def calculate_checksum(source_string):
+    countTo = (int(len(source_string) / 2)) * 2
+    total = 0
+    count = 0
+
+    # Handle bytes in pairs (decoding as short ints)
+    loByte = 0
+    hiByte = 0
+    while count < countTo:
+        if sys.byteorder == "little":
+            loByte = source_string[count]
+            hiByte = source_string[count + 1]
+        else:
+            loByte = source_string[count + 1]
+            hiByte = source_string[count]
+        total = total + ((hiByte) * 256 + (loByte))
+        count += 2
+
+    # Handle last byte if applicable (odd-number of bytes)
+    # Endianness should be irrelevant in this case
+    if countTo < len(source_string):  # Check for odd length
+        loByte = source_string[len(source_string) - 1]
+        total += loByte
+
+    total &= 0xffffffff  # Truncate total to 32 bits (a variance from ping.c, which
+    # uses signed ints, but overflow is unlikely in ping)
+
+    total = (total >> 16) + (total & 0xffff)  # Add high 16 bits to low 16 bits
+    total += (total >> 16)                  # Add carry from above (if any)
+    answer = ~total & 0xffff              # Invert and truncate to 16 bits
+    answer = socket.htons(answer)
+
+    return answer
+
+
+def create_rds_socket():
+    try:
+        sock_fd = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
+        return sock_fd
+    except socket.error as err:
+        print("socket creation failed with error %s" % (err), file=sys.stderr)
+        return None
+
+
+def htosi(data, signed):
+    hex_string = data.hex()
+    return int.from_bytes(bytes.fromhex(hex_string), byteorder='little', signed=signed)
+
+
+def send_ping(sock_fd, src_ip, dst_ip_list, send_timestamps):
+    seq_number = 0
+    global pings_sent
+
+    for dst_ip in dst_ip_list:
+        checksum = 0
+        header = struct.pack("!BBHHH", ICMP_ECHO, 0,
+                             checksum, OWN_ID, seq_number)
+        checksum = calculate_checksum(header)
+        header = struct.pack("!BBHHH", ICMP_ECHO, 0,
+                             checksum, OWN_ID, seq_number)
+        packet = header
+        try:
+            sock_fd.sendto(packet, (dst_ip, 1))
+            send_timestamps[dst_ip] = datetime.now()
+        except socket.error as err:
+            print("socket send failed with error %s" % (err), file=sys.stderr)
+            # remove the added entry from the list
+            del send_timestamps[dst_ip]
+        pings_sent = pings_sent + 1
+
+
+def recv_pong(sock_fd, src_ip, num_dest, timeout, send_timestamps, print_all):
+
+    inputs = [sock_fd]
+    outputs = []
+    latencies_info = ""
+    pongs_rcvd = 0
+    sock_fd.settimeout(timeout)
+
+    select_timeout = timeout
+
+    select_timeout_msec = select_timeout * 1000
+    while True:
+        select_start_time = int(round(time.time() * 1000))
+        readable, writable, exceptional = select.select(
+            inputs, outputs, inputs, select_timeout)
+
+        for _ in readable:
+            try:
+                packet_data, (ipaddr, _) = sock_fd.recvfrom(ICMP_MAX_RECV)
+                icmp_header = struct.unpack("!BBHHH", packet_data[20:28])
+
+                if icmp_header[3] == OWN_ID:
+                    latency = datetime.now() - send_timestamps[ipaddr]
+                    lat_data = ("%s %s - %.3f |" %
+                                (src_ip, ipaddr, latency.microseconds))
+                    latencies_info = latencies_info + lat_data
+                    pongs_rcvd = pongs_rcvd + 1
+                    conn = "%s-%s" % (src_ip, ipaddr)
+                    pings_json[conn] = latency.microseconds
+                    del send_timestamps[ipaddr]
+            except KeyError:
+                continue
+
+        curr_time = int(round(time.time() * 1000))
+        time_elapsed = curr_time - select_start_time
+        select_timeout_msec = select_timeout_msec - time_elapsed
+        if select_timeout_msec < 0:
+            for keys, _ in send_timestamps.items():
+                lat_data = "%s %s - timeout |" % (src_ip, keys)
+                latencies_info = latencies_info + lat_data
+                conn = "%s-%s" % (src_ip, keys)
+                pings_json[conn] = -1
+            break
+
+        select_timeout = select_timeout_msec/1000
+
+        if num_dest - pongs_rcvd == 0:
+            break
+
+        if not (readable or writable or exceptional):
+            for keys, _ in send_timestamps.items():
+                lat_data = "%s %s - timeout |" % (src_ip, keys)
+                latencies_info = latencies_info + lat_data
+                conn = "%s-%s" % (src_ip, keys)
+                pings_json[conn] = -1
+
+            break
+
+    if not print_all:
+        print(latencies_info)
+
+
+def get_each_entry_len(data):
+    try:
+        rds_info_len = data[-4:].decode()
+    except ValueError:
+        rds_info_len = data[-4:-2].decode()
+
+    if '\x00' in rds_info_len:
+        rds_info_len = ' '.join(rds_info_len.split('\x00'))
+    data = data[:-4]
+
+    rds_info_len = re.findall(r'\d+', rds_info_len)
+    rds_info_len = int(rds_info_len[-1])
+
+    return data, rds_info_len
+
+def ping_destinations(src_ip, dest_ip_list, timeout):
+    sock_fd = create_socket()
+    bind_socket(sock_fd, src_ip)
+    send_timestamps = {}
+    num_dest = len(dest_ip_list)
+    send_ping(sock_fd, src_ip, dest_ip_list, send_timestamps)
+    recv_pong(sock_fd, src_ip, num_dest, timeout, send_timestamps, True)
+    sock_fd.close()
+
+
+def ping_all_avlbl_dest(timeout):
+    rds_info = RdsInfo()
+    rds_connections = rds_info.main('-I').split("\n")
+
+    conns_dict = defaultdict(list)
+
+    for conn in rds_connections:
+        saddr, daddr = conn.split()[0:2]
+        if(validate_ip(saddr) == 0 and validate_ip(daddr) == 0):
+            conns_dict[saddr].append(daddr)
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        for saddr, dest_ip_list in conns_dict.items():
+            executor.submit(ping_destinations, saddr, dest_ip_list, timeout)
+
+    res = json.dumps(pings_json)
+    return res
+
+
+def validate_ip(ip_addr_str):
+    try:
+        ipaddress.ip_address(ip_addr_str)
+        return 0
+    except ValueError:
+        print("Invalid IP %s" % ip_addr_str, file=sys.stderr)
+        return 1
+
+
+def ping(args):
+    dest_ip_list = [str(item) for item in args.list.split(' ')]
+    for ip_addr in dest_ip_list:
+        if validate_ip(ip_addr):
+            print("Invalid IP being passed %s. Please rectify." % (ip_addr), file=sys.stderr)
+            sys.exit(1)
+
+    sock_fd = create_socket()
+    bind_socket(sock_fd, args.source_ip)
+
+    num_destinations = len(dest_ip_list)
+    send_timestamps = {}
+
+    thread2 = threading.Thread(target=recv_pong, args=(
+        sock_fd, args.source_ip, num_destinations, args.timeout, send_timestamps, False))
+    thread2.start()
+
+    thread1 = threading.Thread(target=send_ping, args=(
+        sock_fd, args.source_ip, dest_ip_list, send_timestamps))
+    thread1.start()
+
+    thread2.join()
+    thread1.join()
+
+    sock_fd.close()
+
+
+def main(argv):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(dest='destination_ip',
+                        help="destination ip is mandatory")
+    parser = argparse.ArgumentParser(description='python version of ping utility.',
+                                     epilog="sample usage: ping.python -d \"dst_ip_1 dst_ip_2\" -I src_ip")
+    parser.add_argument('-d', '--list', type=str)
+    parser.add_argument('-I', '--source_ip', type=str)
+    parser.add_argument('-t', '--timeout', type=float, default=3)
+    parser.add_argument('-a', '--auto', action='store_true')
+    parser.add_argument('-c', '--count', type=int, default=-1)
+
+    args = parser.parse_args()
+
+    if args.auto:
+        ping_all_avlbl_dest(args.timeout)
+        print(pings_json)
+        sys.exit(1)
+
+    else:
+        if args.count == -1:
+            while True:
+                ping(args)
+                time.sleep(1)
+        else:
+            iterations = args.count
+            while iterations > 0:
+                ping(args)
+                iterations = iterations - 1
+                if iterations:
+                    time.sleep(1)
+
+
+signal.signal(signal.SIGINT, signal_handler)
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/src/pmdas/rds/modules/rds_info.python b/src/pmdas/rds/modules/rds_info.python
new file mode 100644
index 00000000000..389ed5793f3
--- /dev/null
+++ b/src/pmdas/rds/modules/rds_info.python
@@ -0,0 +1,423 @@
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+import sys
+import struct
+import psutil
+import socket
+import ctypes
+import binascii
+from datetime import datetime
+
+# Constants for socket operations
+PF_RDS = 21
+SOCK_SEQPACKET = 5
+SOL_RDS = 276
+
+RDS_INFO_COUNTERS = 10000
+RDS_INFO_CONNECTIONS = 10001
+RDS_INFO_SEND_MESSAGES = 10003
+RDS_INFO_RETRANS_MESSAGES = 10004
+RDS_INFO_RECV_MESSAGES = 10005
+RDS_INFO_SOCKETS = 10006
+RDS_INFO_TCP_SOCKETS = 10007
+RDS_INFO_IB_CONNECTIONS = 10008
+RDS_INFO_CONN_PATHS = 10020
+
+# Connection drop reasons
+CONN_DROP_REASONS = [
+    "--", "user reset", "invalid connection state", "failure to move to DOWN state",
+    "connection destroy", "conn_connect failure", "hb timeout", "reconnect timeout",
+    "cancel operation on socket", "race between ESTABLISHED event and drop",
+    "conn is not in CONNECTING state", "qp event", "incoming REQ in CONN_UP state",
+    "incoming REQ in CONNECTING state", "passive setup_qp failure",
+    "rdma_accept failure", "active setup_qp failure", "rdma_connect failure",
+    "resolve_route failure", "detected rdma_cm_id mismatch", "ROUTE_ERROR event",
+    "ADDR_ERROR event", "CONNECT_ERROR or UNREACHABLE or DEVICE_REMOVE event",
+    "CONSUMER_DEFINED reject", "REJECTED event", "ADDR_CHANGE event",
+    "DISCONNECTED event", "TIMEWAIT_EXIT event", "post_recv failure",
+    "send_ack failure", "no header in incoming msg", "corrupted header in incoming msg",
+    "fragment header mismatch", "recv completion error", "send completion error",
+    "post_send failure", "rds_rdma module unload", "active bonding failover",
+    "corresponding loopback conn drop", "active bonding failback", "sk_state to TCP_CLOSE",
+    "tcp_send failure"
+]
+
+
+class RdsInfo:
+    """Class to implement standard RDS info operations."""
+
+    USAGE_MSG = (
+        "Usage: python rds_info.python <option>\n"
+        "Available options:\n"
+        "  -I: Get RDS InfiniBand connections\n"
+        "  -T: Get RDS TCP Connections\n"
+        "  -c: Get RDS counters\n"
+        "  -k: Get RDS socket information\n"
+        "  -n: Get RDS connection details\n"
+        "  -p: Get RDS connection paths\n"
+        "  -r: Get RDS receive queues\n"
+        "  -s: Get RDS send queues\n"
+        "  -t: Get RDS retransmit queues\n"
+        "  --help: Show this help message\n"
+    )
+
+    libc = ctypes.CDLL("libc.so.6", use_errno=True)
+
+    def create_rds_socket(self):
+        sock_fd = self.libc.socket(PF_RDS, SOCK_SEQPACKET, 0)
+        if sock_fd < 0:
+            return None
+        return sock_fd
+
+    def get_rds_info_data(self, sock_fd, query_type):
+        """Retrieve RDS information data."""
+        data_len = ctypes.c_int(0)
+        res = self.libc.getsockopt(
+            sock_fd, SOL_RDS, query_type, None, ctypes.byref(data_len))
+        if res < 0:
+            data_buffer = ctypes.create_string_buffer(int(data_len.value))
+            res = self.libc.getsockopt(
+                sock_fd, SOL_RDS, query_type, data_buffer, ctypes.byref(data_len))
+            if res < 0:
+                return None
+
+            return data_buffer.raw[:data_len.value], res
+
+        return None, None
+
+    @staticmethod
+    def little_endian_to_unsigned(hex_string, bit):
+        """Convert little-endian byte sequence to an unsigned integer."""
+        bit_format = "<I" if bit == 32 else "<Q"
+        byte_array = binascii.unhexlify(hex_string)
+        return struct.unpack(bit_format, byte_array)[0]
+
+    @staticmethod
+    def htosi(data, signed):
+        """Convert a hexadecimal string to a signed/unsigned integer."""
+        hex_string = data.hex()
+        return int.from_bytes(bytes.fromhex(hex_string), byteorder="little", signed=signed)
+
+    @staticmethod
+    def to_ipv6(data):
+        """Convert IPv4 to IPv6."""
+        data = data.strip("0")
+        res = data[4:12]
+        octets = [res[i:i+2] for i in range(0, len(res), 2)]
+        ip_addr = ".".join(str(int(i, 16)) for i in octets)
+        return f"::{data[:4]}:{ip_addr}"
+
+    @staticmethod
+    def parse_time(hex_time):
+        """
+        Convert the time to a human-readable format
+        """
+        time = ""
+        time = float(struct.unpack("<Q", hex_time)[0])
+        time = "---" if time == float(0) else (datetime.fromtimestamp(time))
+        return time
+
+    @staticmethod
+    def get_down_time(conn_time, attempt_time):
+        """Calculate down time."""
+        conn_time = float(struct.unpack("<Q", conn_time)[0])
+        attempt_time = float(struct.unpack("<Q", attempt_time)[0])
+        return conn_time - attempt_time
+
+    @staticmethod
+    def decode_flags(value):
+        """Decode RDS Flags."""
+        flags = "".join(
+            [char if value & (1 << i) else "-" for i, char in enumerate("scCE")])
+        return flags
+
+    def get_rds_ib_conns(self, sock_fd):
+        """Get RDS_INFO_IB_CONNECTIONS from socket and parse it."""
+        data, each = self.get_rds_info_data(sock_fd, RDS_INFO_IB_CONNECTIONS)
+        if not data or not each:
+            return ""
+
+        res = []
+        for i in range(0, len(data), each):
+            saddr = socket.inet_ntoa(data[i:i+4])
+            daddr = socket.inet_ntoa(data[i+4:i+8])
+            tos, sol = str(data[i+60]), str(data[i+61])
+
+            s_dev, d_dev, src_qp, dst_qp = "::", "::", -1, -1
+            if self.htosi(data[i+76:i+80], True) != -1:
+                s_dev = self.to_ipv6(data[i+11:i+27].hex())
+                d_dev = self.to_ipv6(data[i+27:i+43].hex())
+                src_qp = self.htosi(data[i+76:i+80], True)
+                dst_qp = self.htosi(data[i+88:i+92], True)
+
+            res.append(
+                f"{saddr:14}  {daddr:14}  {tos:3}  {sol:2}  {s_dev:31}  {d_dev:32}  {src_qp:9}  {dst_qp:9}")
+        return "\n".join(res)
+
+    def get_rds_tcp_conns(self, sock_fd):
+        """Get RDS_INFO_TCP_SOCKETS from socket and parse it."""
+        data, each = self.get_rds_info_data(sock_fd, RDS_INFO_TCP_SOCKETS)
+
+        if not data or not each:
+            return ""
+
+        res = []
+        for i in range(0, len(data), each):
+            laddr = socket.inet_ntoa(data[i:i+4])
+            lport = str(int(data[i+4:i+6].hex(), 16))
+            raddr = socket.inet_ntoa(data[i+6:i+10])
+            rport = str(int(data[i+10:i+12].hex(), 16))
+            hdr_remain = str(int(data[i+12:i+13].hex(), 16))
+            data_remain = str(int(data[i+13:i+14].hex(), 16))
+            sent_nxt = str(self.little_endian_to_unsigned(
+                data[i+28:i+32].hex(), 32))
+            exp_una = str(self.little_endian_to_unsigned(
+                data[i+32:i+36].hex(), 32))
+            seen_una = str(self.little_endian_to_unsigned(
+                data[i+36:i+40].hex(), 32))
+
+            res.append(
+                f"{laddr:15} {lport:5} {raddr:15} {rport:5} "
+                f"{hdr_remain:9} {data_remain:10} {sent_nxt:10} "
+                f"{exp_una:10} {seen_una:10}"
+            )
+        return "\n".join(res)
+
+    def get_rds_counters(self, sock_fd):
+        """Get RDS_INFO_COUNTERS from socket and parse it."""
+        data, each = self.get_rds_info_data(sock_fd, RDS_INFO_COUNTERS)
+        if not data or not each:
+            return ""
+
+        res = []
+        for i in range(0, len(data), each):
+            name = data[i:i+31].split(b"\x00", maxsplit=1)[0].decode("utf-8")
+            val = str(struct.unpack("<Q", data[i+32:i+40])[0])
+            res.append(f"{name} {val}")
+        return "\n".join(res)
+
+    def get_rds_conns(self, sock_fd):
+        """Get RDS_INFO_CONNECTIONS from socket and parse it."""
+        data, each = self.get_rds_info_data(sock_fd, RDS_INFO_CONNECTIONS)
+        if not data or not each:
+            return ""
+
+        res = []
+        for i in range(0, len(data), each):
+            laddr = socket.inet_ntoa(data[i+16:i+20])
+            raddr = socket.inet_ntoa(data[i+20:i+24])
+            tos = str(struct.unpack("<b", data[i + 41: i + 42])[0])
+            next_tx = str(self.little_endian_to_unsigned(
+                data[i + 0: i + 4].hex(), 32))
+            next_rx = str(self.little_endian_to_unsigned(
+                data[i + 8: i + 12].hex(), 32))
+            flags = self.decode_flags(
+                int(struct.unpack("<b", data[i + 40: i + 41])[0]))
+
+            res.append(f"{laddr} {raddr} {tos}  {next_rx} {next_tx} {flags}")
+
+        return "\n".join(res)
+
+    def get_rds_sockets(self, sock_fd):
+        """
+        Get RDS_INFO_SOCKETS from the socket and parse it into a human-readable format.
+        """
+        data, each = self.get_rds_info_data(sock_fd, RDS_INFO_SOCKETS)
+
+        if not data or not each:
+            return ""
+
+        res = []
+
+        for i in range(0, len(data), each):
+            laddr = socket.inet_ntoa(data[i + 4: i + 8])
+            raddr = socket.inet_ntoa(data[i + 8: i + 12])
+            lport = str(int(data[i + 12: i + 14].hex(), 16))
+            rport = str(int(data[i + 14: i + 16].hex(), 16))
+
+            snd_buf = str(struct.unpack("<I", data[i: i + 4])[0])
+            rcv_buf = self.little_endian_to_unsigned(
+                data[i + 16: i + 20].hex(), 32)
+            inode = str(struct.unpack("<Q", data[i + 20: i + 28])[0])
+
+            # Default values for pid and comm
+            pid, comm = "NA", "NA"
+
+            try:
+                cong = self.htosi(data[i+32:i+36], True)
+                pid = struct.unpack("<I", data[i + 28: i + 32])[0]
+                comm = psutil.Process(pid).name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, struct.error):
+                comm, pid, cong = "NA", "NA", -1
+
+            if cong == 0:
+                cong = -1
+            elif cong == -1:
+                cong = 0
+
+            if not comm:
+                comm = "NA"
+                pid = "NA"
+                cong = -1
+
+            res.append(
+                f"{laddr:15} {lport:5} {raddr:15} {rport:5} "
+                f"{snd_buf:10} {rcv_buf:10} {inode:8} {cong:8} {pid:10} {comm:16}"
+            )
+
+        return "\n".join(res)
+
+    def get_rds_queues(self, sock_fd, arg):
+        """
+        Get RDS_INFO queue messages from the socket and parse it into a human readable format.
+        Args:
+            sock_fd : socket
+            arg ('-r', '-s', '-t') : Type of the queue.
+        Return:
+            res : String containing send/recv/retrans queue data in a readable format.
+        """
+        queue = {
+            "-s": [RDS_INFO_SEND_MESSAGES, "Send"],
+            "-r": [RDS_INFO_RECV_MESSAGES, "Receive"],
+            "-t": [RDS_INFO_RETRANS_MESSAGES, "Retrans"],
+        }
+
+        data, each = self.get_rds_info_data(sock_fd, queue[arg][0])
+        if not data or not each:
+            return ""
+
+        res = []
+
+        for i in range(0, len(data), each):
+            laddr = str(socket.inet_ntoa(data[i + 12: i + 16]))
+            raddr = str(socket.inet_ntoa(data[i + 16: i + 20]))
+            lport = str(int(data[i + 20: i + 22].hex(), 16))
+            rport = str(int(data[i + 22: i + 24].hex(), 16))
+            tos = str(struct.unpack("<b", data[i + 24: i + 25])[0])
+            seq = str(struct.unpack("<Q", data[i: i + 8])[0])
+            byte = str(struct.unpack("<I", data[i + 8: i + 12])[0])
+
+            res.append(f"{laddr} {lport} {raddr} {rport} {tos} {seq} {byte}")
+        return "\n".join(res)
+
+    def get_rds_paths(self, sock_fd):
+        """
+        Get RDS_INFO_CONN_PATHS from the socket and parse it into a human-readable format.
+        """
+        data, each = self.get_rds_info_data(sock_fd, RDS_INFO_CONN_PATHS)
+        if not data or not each:
+            return ""
+
+        res = []
+
+        # Header for the main connection paths
+        res.append(
+            f"{'LocalAddr':<15} {'RemoteAddr':<15} {'Tos':<4} {'Trans':<10}")
+
+        for i in range(0, len(data), each):
+            saddr = socket.inet_ntoa(data[i + 12: i + 16])
+            daddr = socket.inet_ntoa(data[i + 28: i + 32])
+            tos = str(struct.unpack("<b", data[i + 48: i + 49])[0])
+            trans = data[i + 32: i +
+                         48].split(b"\x00", maxsplit=1)[0].decode("utf-8")
+
+            res.append(f"{saddr:<15} {daddr:<15} {tos:<4} {trans:<10}")
+
+            path_num = int(struct.unpack("<b", data[i + 49: i + 50])[0])
+
+            res += "\n"
+
+            # Header for the path details
+            res.append(
+                f"{'P':<2} {'Connected@':<22} {'Attempt@':<22} {'Reset@':<22} "
+                f"{'Attempts':<10} {'RDS':<5} {'Down(Secs)':<13} {'Reason':<15}"
+            )
+
+            path_data = data[i + 50: i + 346]
+            for j in range(0, len(path_data), 37):
+                attempt_time = self.parse_time(path_data[j + 0: j + 8])
+                conn_time = self.parse_time(path_data[j + 8: j + 16])
+                reset_time = self.parse_time(path_data[j + 16: j + 24])
+
+                reason = int(struct.unpack("<I", path_data[j + 24: j + 28])[0])
+                reason = (
+                    CONN_DROP_REASONS[reason]
+                    if reason < len(CONN_DROP_REASONS)
+                    else str(reason)
+                )
+
+                attempts = str(struct.unpack(
+                    "<I", path_data[j + 28: j + 32])[0])
+                p_no = str(struct.unpack("<b", path_data[j + 32: j + 33])[0])
+
+                rds_flags = self.decode_flags(
+                    int(struct.unpack("<b", path_data[j + 36: j + 37])[0])
+                )
+
+                down = "---"
+                if rds_flags == "--C-" and reset_time != "---":
+                    down = self.get_down_time(
+                        path_data[j + 8: j + 16], path_data[j + 0: j + 8]
+                    )
+
+                res.append(
+                    f"{p_no:2} {str(conn_time):<21} {str(attempt_time):<22} {str(reset_time):<22} "
+                    f"{attempts:10} {rds_flags:5} {down:13} {reason:15}"
+                )
+
+                if path_num == 0:
+                    break
+
+        return "\n".join(res)
+
+    def main(self, option):
+        """
+        Wrapper function for all the above RDS-INFO options
+        """
+        infos = {
+            "-I": {"method": self.get_rds_ib_conns, "description": "Get RDS InfiniBand connections"},
+            "-T": {"method": self.get_rds_tcp_conns, "description": "Get RDS TCP connetions"},
+            "-c": {"method": self.get_rds_counters, "description": "Get RDS counters"},
+            "-k": {"method": self.get_rds_sockets, "description": "Get RDS socket information"},
+            "-n": {"method": self.get_rds_conns, "description": "Get RDS connection details"},
+            "-p": {"method": self.get_rds_paths, "description": "Get RDS connection paths"},
+            "-r": {"method": lambda sock_fd: self.get_rds_queues(sock_fd, '-r'),
+                   "description": "Get RDS receive queues"},
+            "-s": {"method": lambda sock_fd: self.get_rds_queues(sock_fd, '-s'), "description": "Get RDS send queues"},
+            "-t": {"method": lambda sock_fd: self.get_rds_queues(sock_fd, '-t'),
+                   "description": "Get RDS retransmit queues"},
+        }
+
+        # If the user requests help or an invalid option is passed
+        if option == "--help" or option not in infos:
+            print(self.USAGE_MSG, file=sys.stderr)
+            return ""
+
+        sock_fd = self.create_rds_socket()
+        res = infos[option]["method"](sock_fd)
+        self.libc.close(sock_fd)
+        return res
+
+
+if __name__ == "__main__":
+    # Ensure an argument is passed
+    if len(sys.argv) != 2:
+        print(RdsInfo.USAGE_MSG, file=sys.stderr)
+        sys.exit(1)
+
+    cmd_option = sys.argv[1]
+    rds_info = RdsInfo()
+    result = rds_info.main(cmd_option)
+    if result:
+        print(result)
diff --git a/src/pmdas/rds/modules/rds_ping.python b/src/pmdas/rds/modules/rds_ping.python
new file mode 100644
index 00000000000..8b07bbaadd0
--- /dev/null
+++ b/src/pmdas/rds/modules/rds_ping.python
@@ -0,0 +1,267 @@
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+# pylint: disable=no-member
+
+import argparse
+from collections import defaultdict
+import fcntl
+import ipaddress
+import select
+import signal
+import struct
+import sys
+import threading
+import socket
+import time
+import json
+from time import perf_counter
+
+from modules.rds_info import RdsInfo
+
+rds_pings_json = {}
+
+def signal_handler(sig, frame):
+    sys.exit(0)
+
+def create_rds_socket():
+    try:
+        sock_fd = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
+        return sock_fd
+    except socket.error as err:
+        print("socket creation failed with error %s" % (err), file=sys.stderr)
+        return None
+
+def bind_rds_socket(sock_fd, saddr):
+    src_port = 0
+    try:
+        sock_fd.bind((saddr, src_port))
+    except socket.error as err:
+        print("socket bind failed with error %s" % (err), file=sys.stderr)
+
+
+def set_tos(sock_fd, tos):
+    try:
+        fcntl.ioctl(sock_fd, 0x89E0, struct.pack('L', int(tos)))
+    except socket.error as err:
+        print("Setting QOS failed with error %s" % (err), file=sys.stderr)
+
+def validate_ip(ip_addr_str):
+    try:
+        ipaddress.ip_address(ip_addr_str)
+        return 0
+    except ValueError:
+        print("Invalid IP %s" % ip_addr_str, file=sys.stderr)
+        return 1
+
+def send_rds_ping(sock_fd, saddr, tos, dst_ip_list, send_timestamps):
+    """
+    Sends RDS pings to the destination IPs and stores timestamps in a thread-specific dictionary.
+    """
+    dst_port = 0
+    try:
+        for dst_ip in dst_ip_list:
+            data = ""
+            sock_fd.sendto(data.encode('utf-8'), (dst_ip, dst_port))
+            timestamp = perf_counter()
+            conn = f"{saddr}-{dst_ip}-{tos}"
+            send_timestamps[conn] = timestamp
+    except socket.error:
+        pass
+
+def recv_rds_pong(sock_fd, saddr, tos, num_dest, timeout, send_timestamps, thread_results):
+    """
+    Receives RDS pongs and calculates latencies based on timestamps from the thread-specific dictionary.
+    """
+    pongs_rcvd = 0
+    inputs = [sock_fd]
+    outputs = []
+    sock_fd.settimeout(timeout + 1)  # Add a small buffer to the timeout
+
+    while True:
+        readable, writable, exceptional = select.select(inputs, outputs, inputs, timeout)
+
+
+        for _ in readable:
+            try:
+                _, (ipaddr, _) = sock_fd.recvfrom(0)
+                conn = f"{saddr}-{ipaddr}-{tos}"
+                if conn in send_timestamps:
+                    latency = perf_counter() - send_timestamps[conn]
+                    thread_results[conn] = int(latency * 1_000_000)  # Convert seconds to microseconds
+                    del send_timestamps[conn]
+                    pongs_rcvd += 1
+            except Exception:
+                for conn in list(send_timestamps.keys()):
+                    thread_results[conn] = -1
+                break
+
+        if num_dest - pongs_rcvd == 0:
+            break
+
+        if not (readable or writable or exceptional):
+            # Timeout occurred, mark remaining connections as timed out
+            for conn in list(send_timestamps.keys()):
+                thread_results[conn] = -1
+            break
+
+def rds_ping_all_avlbl_dest(timeout):
+    """
+    Main function to send and receive RDS pings for all available destinations.
+    """
+    sockets_list = []
+    threads_list = []
+    thread_results_list = []  # List to store thread-specific results
+
+    rds_info = RdsInfo()
+    rds_connections = rds_info.main("-I").split("\n")
+
+    conns_dict = defaultdict(list)
+    for conn in rds_connections:
+        try:
+            saddr, daddr, tos = conn.split()[0:3]
+            conns_dict[f"{saddr} {tos}"].append(daddr)
+        except ValueError:
+            continue
+
+    for key, dest_ip_list in conns_dict.items():
+        saddr, tos = key.split()[0:2]
+
+        num_dest = len(dest_ip_list)
+        sock_fd = create_rds_socket()
+        bind_rds_socket(sock_fd, saddr)
+        set_tos(sock_fd, tos)
+        sockets_list.append(sock_fd)
+
+        # Thread-specific dictionaries
+        send_timestamps = {}
+        thread_results = {}
+        thread_results_list.append(thread_results)
+
+        # Start recv_rds_pong thread
+        thread2 = threading.Thread(target=recv_rds_pong, args=(
+            sock_fd, saddr, tos, num_dest, timeout, send_timestamps, thread_results))
+        thread2.start()
+        threads_list.append(thread2)
+
+        # Start send_rds_ping thread
+        thread1 = threading.Thread(target=send_rds_ping, args=(
+            sock_fd, saddr, tos, dest_ip_list, send_timestamps))
+        thread1.start()
+        threads_list.append(thread1)
+
+    for thread in threads_list:
+        thread.join()
+
+    for sock in sockets_list:
+        sock.close()
+
+    # Merge thread-specific results into the global dictionary
+    for thread_results in thread_results_list:
+        rds_pings_json.update(thread_results)
+
+    # Return the JSON-formatted result
+    return json.dumps(rds_pings_json, indent=4)
+
+
+def rds_ping_multiple_destinations(source_ip, destination_ips, tos, timeout):
+    """
+    Pings multiple RDS connections from a single source IP and returns the latencies as a string.
+    """
+    sock_fd = create_rds_socket()
+    bind_rds_socket(sock_fd, source_ip)
+    set_tos(sock_fd, tos)
+
+    # Thread-specific dictionaries
+    send_timestamps = {}
+    thread_results = {}
+
+    # Start recv_rds_pong thread
+    thread2 = threading.Thread(target=recv_rds_pong, args=(
+        sock_fd, source_ip, tos, len(destination_ips), timeout, send_timestamps, thread_results))
+    thread2.start()
+
+    # Start send_rds_ping thread
+    thread1 = threading.Thread(target=send_rds_ping, args=(
+        sock_fd, source_ip, tos, destination_ips, send_timestamps))
+    thread1.start()
+
+    # Wait for threads to complete
+    thread1.join()
+    thread2.join()
+
+    sock_fd.close()
+
+    # Format and return the latency result
+    return print_latencies(thread_results)
+
+def print_latencies(latencies_dict):
+    print(f"{'Source':<20} {'Destination':<20} {'QoS':<5} {'Latency':<10}")
+
+    for conn, latency in latencies_dict.items():
+        try:
+            saddr, daddr, qos = conn.split('-')
+            qos = int(qos)
+        except ValueError:
+            print(f"Invalid connection key format: {conn}", file=sys.stderr)
+            continue
+
+        latency_display = f"{latency} usec" if latency != -1 else "Timeout"
+        print(f"{saddr:<20} {daddr:<20} {qos:<5} {latency_display:<10}")
+    print()
+
+def main(argv):
+    parser = argparse.ArgumentParser(description='python version of rds-ping utility.',
+                                     epilog="sample usage: rds_ping.python -d \"dst_ip1,dst_ip2\" -I saddr -Q tos")
+    parser.add_argument('-d', '--destination_ip', type=str, help="Comma-separated list of destination IP addresses")
+    parser.add_argument('-Q', '--tos', type=str, default=0, help="Type of Service (QoS)")
+    parser.add_argument('-I', '--source_ip', type=str, help="Source IP address")
+    parser.add_argument('-t', '--timeout', type=float, default=3, help="Timeout in seconds")
+    parser.add_argument('-c', '--count', type=int, default=-1, help="Number of iterations")
+    parser.add_argument('-a', '--all_connections', action='store_true', help="Ping all connections")
+    args = parser.parse_args()
+
+    if args.all_connections:
+        rds_ping_all_avlbl_dest(args.timeout)
+        print_latencies(rds_pings_json)
+        sys.exit(1)
+    elif args.source_ip and args.destination_ip:
+        destination_ips = args.destination_ip.split(",")  # Split the destination IPs into a list
+        try:
+            if args.count == -1:
+                while True:
+                    _ = rds_ping_multiple_destinations(args.source_ip, destination_ips, args.tos, args.timeout)
+                    time.sleep(1)
+            else:
+                iterations = args.count
+                while iterations > 0:
+                    _ = rds_ping_multiple_destinations(args.source_ip, destination_ips, args.tos, args.timeout)
+                    iterations -= 1
+                    if iterations:
+                        time.sleep(1)
+        except KeyboardInterrupt:
+            sys.exit(1)
+    else:
+        print(
+            "Error: Both source_ip (-I) and dest_ip (-d) must be provided for single or multiple connection ping.",
+            file=sys.stderr
+            )
+        sys.exit(1)
+
+
+signal.signal(signal.SIGINT, signal_handler)
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/src/pmdas/rds/pmdards.1 b/src/pmdas/rds/pmdards.1
new file mode 100644
index 00000000000..598f1232df1
--- /dev/null
+++ b/src/pmdas/rds/pmdards.1
@@ -0,0 +1,77 @@
+'\"macro stdmacro
+.\"
+.\" Copyright (c) 2025 Oracle and/or its affiliates.
+.\" DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+.\"
+.\" This program is free software; you can redistribute it and/or modify it
+.\" under the terms of the GNU General Public License as published by the
+.\" Free Software Foundation; either version 2 of the License, or (at your
+.\" option) any later version.
+.\"
+.\" This program is distributed in the hope that it will be useful, but
+.\" WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+.\" or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+.\" for more details.
+.\"
+.\"
+.TH PMDARDS 1  "PCP" "Performance Co-Pilot" "General Commands Manual"
+.SH NAME
+\f3pmdards\f1 \- Performance Metrics Domain Agent (PMDA) for RDS
+.SH DESCRIPTION
+The
+.B RDS PMDA
+is a Performance Co-Pilot (PCP) module that collects and exports performance
+statistics for Reliable Datagram Sockets (RDS).
+.SH INSTALLATION
+To install the RDS PMDA, follow these steps:
+.RS
+.nf
+# cd $PCP_PMDAS_DIR/rds
+# ./Install
+.fi
+.RE
+
+To verify that the PMDA is running:
+.RS
+.nf
+$ pminfo -t rds
+.fi
+.RE
+
+.SH USAGE
+To query RDS metrics, use the following command:
+.RS
+.nf
+$ pminfo rds
+.fi
+.RE
+To retrieve specific metric values:
+.RS
+.nf
+$ pmval rds.packet.tx.send_queued
+.fi
+.RE
+
+.SH FILES
+.TP
+.I $PCP_PMDAS_DIR/rds/Install
+Installation script for RDS PMDA.
+.TP
+.I $PCP_PMDAS_DIR/rds/Remove
+Uninstallation script.
+.TP
+.I $PCP_LOG_DIR/pmcd/rds.log
+Log file for Rocestat PMDA events and errors.
+
+.SH PCP ENVIRONMENT
+Environment variables with the prefix PCP_ are used to parameterize the file and
+directory names used by PCP. On each installation, the file /etc/pcp.conf contains
+the local values for these variables. The $PCP_CONF variable may be used to specify
+an alternative configuration file, as described in pcp.conf(5).
+
+.SH SEE ALSO
+.BR PCPIntro (1),
+.BR pmcd (1),
+.BR pminfo (1)
+and
+.BR PMDA (3).
\ No newline at end of file
diff --git a/src/pmdas/rds/pmdards.python b/src/pmdas/rds/pmdards.python
new file mode 100755
index 00000000000..721245cd8e8
--- /dev/null
+++ b/src/pmdas/rds/pmdards.python
@@ -0,0 +1,452 @@
+# __author__ = "Mohith Kumar Thummaluru"
+# __email__ = "mohith.k.kumar.thummaluru@oracle.com"
+# __version__ = "1.0.1"
+#
+# Copyright (c) 2025 Oracle and/or its affiliates.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# pylint: disable=no-self-use, consider-using-f-string, too-many-instance-attributes
+# pylint: disable=c-extension-no-member, consider-iterating-dictionary
+# pylint: disable=too-many-locals, too-many-arguments, too-many-lines, unused-argument, line-too-long
+# pylint: disable=too-many-return-statements, too-many-branches, too-many-statements, bare-except
+# pylint: disable=wrong-import-position
+"""
+Python implementation of the "rds" Performance Metrics Domain Agent.
+"""
+
+import os
+import subprocess
+import threading
+from enum import Enum
+from collections import defaultdict, namedtuple
+
+import cpmapi as c_api
+from cpmda import PMDA_FETCH_NOVALUES
+from pcp.pmda import PMDA, pmdaMetric
+from pcp.pmapi import pmUnits
+from pcp.pmapi import pmContext as PCP
+
+PMDA_DIR = PCP.pmGetConfig('PCP_PMDAS_DIR')
+MODULES_DIR = os.path.join(PMDA_DIR, "rds", "modules")
+
+# create a simlink for files with .python extension to support imports
+for filename in os.listdir(MODULES_DIR):
+    if filename.endswith('.python'):
+        src = os.path.join(MODULES_DIR, filename)
+        dst = os.path.join(MODULES_DIR, filename[:-4])
+        if not os.path.exists(dst):
+            os.symlink(src, dst)
+
+from modules.rds_ping import rds_ping_all_avlbl_dest
+from modules.ping import ping_all_avlbl_dest
+from modules.rds_info import RdsInfo
+
+Metric = namedtuple("Metric", ["key", "name", "type", "units"])
+
+class Cluster(Enum):
+    CONN = 1
+    CONG = 2
+    PACKET = 3
+    SENDQ = 4
+    MEM = 5
+    IB = 6
+    SOCK = 7
+    RDS_INFO = 8
+    LAT = 9
+
+class ThreadWithReturnValue(threading.Thread):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._return = None
+
+    def run(self):
+        if self._target:
+            self._return = self._target(*self._args, **self._kwargs)
+
+    def join(self, *args, **kwargs):
+        super().join(*args, **kwargs)
+        return self._return
+
+
+class RDSPMDA(PMDA):
+    """
+    A RDS Performance Metrics Domain Agent.
+    """
+    # Centralized metric mapping
+    pm_type_64 = c_api.PM_TYPE_U64
+
+    byte_units = pmUnits(1, 0, 0, c_api.PM_SPACE_BYTE, 0, 0)
+    count_units = pmUnits(0, 0, 1, 0, 0, 0)
+    pmunits = pmUnits(0, 0, 0, 0, 0, 0)
+
+    METRICS = {
+        # CLUSTER_CONN
+        Cluster.CONN: [
+            Metric("conn_reset", "rds.conn.conn_reset", pm_type_64, count_units),
+            Metric("qos_threshold_exceeded", "rds.conn.qos_threshold_exceeded", pm_type_64, count_units),
+        ],
+
+        # CLUSTER_CONG
+        Cluster.CONG: [
+            Metric("cong_send_blocked", "rds.cong.cong_send_blocked", pm_type_64, count_units),
+            Metric("cong_update_queued", "rds.cong.cong_update_queued", pm_type_64, count_units),
+            Metric("cong_send_error", "rds.cong.cong_send_error", pm_type_64, count_units),
+            Metric("cong_update_received", "rds.cong.cong_update_received", pm_type_64, count_units),
+        ],
+
+        Cluster.PACKET: [
+        # CLUSTER_PACKET (TX)
+            Metric("send_queued", "rds.packet.tx.send_queued", pm_type_64, count_units),
+            Metric("send_rdma", "rds.packet.tx.send_rdma", pm_type_64, count_units),
+            Metric("send_rdma_bytes", "rds.packet.tx.send_rdma_bytes", pm_type_64, byte_units),
+            Metric("send_ping", "rds.packet.tx.send_ping", pm_type_64, count_units),
+            Metric("send_pong", "rds.packet.tx.send_pong", pm_type_64, count_units),
+            Metric("send_hb_ping", "rds.packet.tx.send_hb_ping", pm_type_64, count_units),
+            Metric("send_hb_pong", "rds.packet.tx.send_hb_pong", pm_type_64, count_units),
+            Metric("send_mprds_ping", "rds.packet.tx.send_mprds_ping", pm_type_64, count_units),
+            Metric("send_mprds_pong", "rds.packet.tx.send_mprds_pong", pm_type_64, count_units),
+            Metric("send_immediate_retry", "rds.packet.tx.send_imm_retry", pm_type_64, count_units),
+            Metric("send_delayed_retry", "rds.packet.tx.send_delayed_retry", pm_type_64, count_units),
+            Metric("send_ack_required", "rds.packet.tx.send_ack_reqd", pm_type_64, count_units),
+            Metric("send_drop_acked", "rds.packet.tx.send_drop_acked", pm_type_64, count_units),
+            Metric("send_stuck_rm", "rds.packet.tx.send_stuck_rm", pm_type_64, count_units),
+
+        # CLUSTER_PACKET (RX)
+            Metric("recv_queued", "rds.packet.rx.recv_queued", pm_type_64, count_units),
+            Metric("recv_rdma_bytes", "rds.packet.rx.recv_rdma_bytes", pm_type_64, byte_units),
+            Metric("recv_ping", "rds.packet.rx.recv_ping", pm_type_64, count_units),
+            Metric("recv_pong", "rds.packet.rx.recv_pong", pm_type_64, count_units),
+            Metric("recv_hb_ping", "rds.packet.rx.recv_hb_ping", pm_type_64, count_units),
+            Metric("recv_hb_pong", "rds.packet.rx.recv_hb_pong", pm_type_64, count_units),
+            Metric("recv_mprds_ping", "rds.packet.rx.recv_mprds_ping", pm_type_64, count_units),
+            Metric("recv_mprds_pong", "rds.packet.rx.recv_mprds_pong", pm_type_64, count_units),
+            Metric("recv_immediate_retry", "rds.packet.rx.recv_imm_retry", pm_type_64, count_units),
+            Metric("recv_delayed_retry", "rds.packet.rx.delayed_retry", pm_type_64, count_units),
+            Metric("recv_ack_required", "rds.packet.rx.ack_reqd", pm_type_64, count_units),
+            Metric("recv_deliver_raced", "rds.packet.rx.recv_deliver_raced", pm_type_64, count_units),
+            Metric("recv_delivered", "rds.packet.rx.recv_delivered", pm_type_64, count_units),
+            Metric("recv_drop_bad_checksum", "rds.packet.rx.drop.bad_csum", pm_type_64, count_units),
+            Metric("recv_drop_old_seq", "rds.packet.rx.drop.old_seq", pm_type_64, count_units),
+            Metric("recv_drop_no_sock", "rds.packet.rx.drop.no_sock", pm_type_64, count_units),
+            Metric("recv_drop_dead_sock", "rds.packet.rx.drop.dead_sock", pm_type_64, count_units),
+        ],
+
+        # CLUSTER_SENDQ
+        Cluster.SENDQ : [
+            Metric("send_lock_queue_raced", "rds.sendq.send_lock_q_raced", pm_type_64, count_units),
+            Metric("send_queue_empty", "rds.sendq.q_empty", pm_type_64, count_units),
+            Metric("send_queue_full", "rds.sendq.q_full", pm_type_64, count_units),
+            Metric("send_lock_contention", "rds.sendq.send_lock_contention", pm_type_64, count_units),
+        ],
+
+        # CLUSTER_MEM
+        Cluster.MEM : [
+            Metric("page_allocs", "rds.mem.page_allocs", pm_type_64, count_units),
+            Metric("page_gets", "rds.mem.page_gets", pm_type_64, count_units),
+            Metric("page_frees", "rds.mem.page_frees", pm_type_64, count_units),
+            Metric("page_remainder_hit", "rds.mem.page_rem_hit", pm_type_64, count_units),
+            Metric("page_remainder_miss", "rds.mem.page_rem_miss", pm_type_64, count_units),
+            Metric("copy_to_user", "rds.mem.copy_to_user", pm_type_64, count_units),
+            Metric("copy_from_user", "rds.mem.copy_from_user", pm_type_64, count_units),
+        ],
+
+        # CLUSTER_IB
+        Cluster.IB : [
+            Metric("ib_ack_sent", "rds.ib.ack.sent", pm_type_64, count_units),
+            Metric("ib_ack_send_failure", "rds.ib.ack.send_failure", pm_type_64, count_units),
+            Metric("ib_ack_send_delayed", "rds.ib.ack.send_delayed", pm_type_64, count_units),
+            Metric("ib_ack_send_piggybacked", "rds.ib.ack.send_piggybacked", pm_type_64, count_units),
+            Metric("ib_ack_received", "rds.ib.ack.received", pm_type_64, count_units),
+            Metric("ib_tx_ring_full", "rds.ib.tx.ring_full", pm_type_64, count_units),
+            Metric("ib_tx_throttle", "rds.ib.tx.throttle", pm_type_64, count_units),
+            Metric("ib_tx_sg_mapping_failure", "rds.ib.tx.sg_mapping_failure", pm_type_64, count_units),
+            Metric("ib_tx_stalled", "rds.ib.tx.stalled", pm_type_64, count_units),
+            Metric("ib_tx_credit_updates", "rds.ib.tx.credit_updates", pm_type_64, count_units),
+            Metric("ib_rx_cq_event", "rds.ib.rx.cq_event", pm_type_64, count_units),
+            Metric("ib_rx_ring_empty", "rds.ib.rx.ring_empty", pm_type_64, count_units),
+            Metric("ib_rx_refill_from_cm", "rds.ib.rx.refill_from_cm", pm_type_64, count_units),
+            Metric("ib_rx_refill_from_cq", "rds.ib.rx.refill_from_cq", pm_type_64, count_units),
+            Metric("ib_rx_refill_from_thread", "rds.ib.rx.refill_from_thread", pm_type_64, count_units),
+            Metric("ib_rx_refill_lock_taken", "rds.ib.rx.refill_lock_taken", pm_type_64, count_units),
+            Metric("ib_rx_alloc_limit", "rds.ib.rx.alloc_limit", pm_type_64, count_units),
+            Metric("ib_rx_total_frags", "rds.ib.rx.total_frags", pm_type_64, count_units),
+            Metric("ib_rx_total_incs", "rds.ib.rx.total_incs", pm_type_64, count_units),
+            Metric("ib_rx_credit_updates", "rds.ib.rx.credit_updates", pm_type_64, count_units),
+            Metric("ib_rx_cache_get", "rds.ib.rx.cache.get", pm_type_64, count_units),
+            Metric("ib_rx_cache_put", "rds.ib.rx.cache.put", pm_type_64, count_units),
+            Metric("ib_rx_cache_put_alloc", "rds.ib.rx.cache.put_alloc", pm_type_64, count_units),
+            Metric("ib_rx_cache_put_free", "rds.ib.rx.cache.put_free", pm_type_64, count_units),
+            Metric("ib_rx_cache_alloc", "rds.ib.rx.cache.alloc", pm_type_64, count_units),
+            Metric("ib_rx_cache_free", "rds.ib.rx.cache.free", pm_type_64, count_units),
+            Metric("ib_rx_cache_get_percpu", "rds.ib.rx.cache.get_percpu", pm_type_64, count_units),
+            Metric("ib_rx_cache_put_percpu", "rds.ib.rx.cache.put_percpu", pm_type_64, count_units),
+            Metric("ib_rx_cache_get_ready", "rds.ib.rx.cache.get_ready", pm_type_64, count_units),
+            Metric("ib_rx_cache_get_miss", "rds.ib.rx.cache.get_miss", pm_type_64, count_units),
+            Metric("ib_recv_cache_added", "rds.ib.rx.cache.cache_added", pm_type_64, count_units),
+            Metric("ib_recv_cache_removed", "rds.ib.rx.cache.cache_removed", pm_type_64, count_units),
+            Metric("ib_recv_nmb_cache_added", "rds.ib.rx.cache.nmb_cache_added", pm_type_64, count_units),
+            Metric("ib_recv_nmb_cache_removed", "rds.ib.rx.cache.nmb_cache_removed", pm_type_64, count_units),
+            Metric("ib_yield_yielding", "rds.ib.yield.yielding", pm_type_64, count_units),
+            Metric("ib_yield_right_of_way", "rds.ib.yield.right_of_way", pm_type_64, count_units),
+            Metric("ib_yield_stale", "rds.ib.yield.stale", pm_type_64, count_units),
+            Metric("ib_yield_expired", "rds.ib.yield.expired", pm_type_64, count_units),
+            Metric("ib_yield_accepting", "rds.ib.yield.accepting", pm_type_64, count_units),
+            Metric("ib_yield_success", "rds.ib.yield.success", pm_type_64, count_units),
+            Metric("ib_atomic_cswp", "rds.ib.atomic.cswp", pm_type_64, count_units),
+            Metric("ib_atomic_fadd", "rds.ib.atomic.fadd", pm_type_64, count_units),
+            Metric("ib_cm_watchdog_triggered", "rds.ib.cm.watchdog_triggered", pm_type_64, count_units),
+            Metric("ib_rdma_mr_8k_alloc", "rds.ib.rdma_mr.8k_alloc", pm_type_64, count_units),
+            Metric("ib_rdma_mr_8k_free", "rds.ib.rdma_mr.8k_free", pm_type_64, count_units),
+            Metric("ib_rdma_mr_8k_used", "rds.ib.rdma_mr.8k_used", pm_type_64, count_units),
+            Metric("ib_rdma_mr_8k_pool_flush", "rds.ib.rdma_mr.8k_pool_flush", pm_type_64, count_units),
+            Metric("ib_rdma_mr_8k_pool_wait", "rds.ib.rdma_mr.8k_pool_wait", pm_type_64, count_units),
+            Metric("ib_rdma_mr_8k_pool_depleted", "rds.ib.rdma_mr.8k_pool_depleted", pm_type_64, count_units),
+            Metric("ib_rdma_mr_1m_alloc", "rds.ib.rdma_mr.1m_alloc", pm_type_64, count_units),
+            Metric("ib_rdma_mr_1m_free", "rds.ib.rdma_mr.1m_free", pm_type_64, count_units),
+            Metric("ib_rdma_mr_1m_used", "rds.ib.rdma_mr.1m_used", pm_type_64, count_units),
+            Metric("ib_rdma_mr_1m_pool_flush", "rds.ib.rdma_mr.1m_pool_flush", pm_type_64, count_units),
+            Metric("ib_rdma_mr_1m_pool_wait", "rds.ib.rdma_mr.1m_pool_wait", pm_type_64, count_units),
+            Metric("ib_rdma_mr_1m_pool_depleted", "rds.ib.rdma_mr.1m_pool_depleted", pm_type_64, count_units),
+            Metric("ib_srq_lows", "rds.ib.srq.lows", pm_type_64, count_units),
+            Metric("ib_srq_refills", "rds.ib.srq.refills", pm_type_64, count_units),
+            Metric("ib_srq_empty_refills", "rds.ib.srq.empty_refills", pm_type_64, count_units),
+            Metric("ib_connect_raced", "rds.ib.connect_raced", pm_type_64, count_units),
+            Metric("ib_evt_handler_call", "rds.ib.evt_handler_call", pm_type_64, count_units),
+            Metric("ib_tasklet_call", "rds.ib.tasklet_call", pm_type_64, count_units),
+            Metric("ib_tx_cq_event", "rds.ib.tx.cq_event", pm_type_64, count_units),
+            Metric("ib_listen_closed_stale", "rds.ib.listen_closed_stale", pm_type_64, count_units),
+        ],
+
+        # CLUSTER_SOCK
+        Cluster.SOCK : [
+            Metric("recv_bytes_added_to_sock", "rds.sock.bytes_added_to_sock", pm_type_64, byte_units),
+            Metric("recv_bytes_freed_fromsock", "rds.sock.bytes_freed_from_sock", pm_type_64, byte_units),
+        ],
+
+        Cluster.RDS_INFO: [
+            Metric("rds_info_ib_conns", "rds.info.ib_conns", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_info_tcp_conns", "rds.info.tcp_conns", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_info_sockets", "rds.info.sockets", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_info_rds_conns", "rds.info.rds_conns", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_info_recv_queue", "rds.info.recv_queue", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_info_send_queue", "rds.info.send_queue", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_info_retrans_queue", "rds.info.retrans_queue", c_api.PM_TYPE_STRING, pmunits),
+        ],
+
+        Cluster.LAT: [
+            Metric("ping", "rds.lat.ping", c_api.PM_TYPE_STRING, pmunits),
+            Metric("rds_ping", "rds.lat.rds_ping", c_api.PM_TYPE_STRING, pmunits),
+            Metric("arp_cache", "rds.lat.arp_cache", c_api.PM_TYPE_STRING, pmunits),
+        ],
+    }
+
+    def populate_rds_info_metric(self, arg):
+        """
+        Wrapper Caller function for all the RDS-INFO options
+        """
+        rds_info_data = ""
+        res = self.rds_info.main(arg)
+        for line in res.splitlines():
+            conn_str = " "
+            line_list = list(filter(None, line.rstrip().split(" ")))
+            conn_str = " ".join([str(elem) for elem in line_list]) + "\n"
+            rds_info_data += conn_str
+        return rds_info_data
+
+    def get_ip_neighbour_stats(self):
+        try:
+            result = subprocess.run(['ip', '-s', 'neighbour'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, check=True)
+            output = result.stdout
+            return output
+        except subprocess.CalledProcessError as e:
+            self.log(f"Error running 'ip -s neighbour': {e}")
+            return ""
+
+    def populate_rds_couters(self):
+        """
+        Fetch RDS counters and populate the rds_counters dictionary.
+        """
+        # self.log("Fetching RDS counters...")
+        res = self.rds_info.main("-c")
+        for line in res.splitlines():
+            line_list = list(filter(None, line.rstrip().split(" ")))
+            self.rds_counters[str(line_list[0])] = int(line_list[1])
+
+    def populate_latency_data(self):
+        """
+        Fetch ping and RDS ping data using threads.
+        """
+        # self.log("Starting threads for ping data...")
+        thread1 = ThreadWithReturnValue(target=lambda: rds_ping_all_avlbl_dest(timeout=3))
+        thread2 = ThreadWithReturnValue(target=lambda: ping_all_avlbl_dest(timeout=3))
+
+        thread1.start()
+        thread2.start()
+
+        self.rds_ping_str = thread1.join() or ""
+        self.ping_str = thread2.join() or ""
+
+    def populate_arp_stats(self):
+        """
+        Fetch ARP stats and store them in arp_str.
+        """
+        self.arp_str = self.get_ip_neighbour_stats()
+
+    def populate_rds_info(self):
+        """
+        Fetch and cache RDS_INFO metrics.
+        """
+        # self.log("Fetching and caching RDS info data...")
+        rds_info_opts = [
+            ("rds_info_ib_conns", "-I"),
+            ("rds_info_tcp_conns", "-T"),
+            ("rds_info_sockets", "-k"),
+            ("rds_info_rds_conns", "-n"),
+            ("rds_info_recv_queue", "-r"),
+            ("rds_info_send_queue", "-s"),
+            ("rds_info_retrans_queue", "-t"),
+        ]
+
+        for metric_key, opt in rds_info_opts:
+            try:
+                res = self.populate_rds_info_metric(opt)
+                self.rds_info_cache[metric_key] = res
+                # self.log(f"Cached data for metric {metric_key}, size: {sys.getsizeof(res)} bytes")
+            except Exception as e:
+                self.log(f"Error fetching data for metric {metric_key}: {e}")
+                self.rds_info_cache[metric_key] = None
+
+    def populate_data(self):
+        """
+        Populate data for the PMDA.
+        """
+        self.populate_rds_couters()
+        self.populate_latency_data()
+        self.populate_arp_stats()
+        self.populate_rds_info()
+
+    def rds_fetch_callback(self, cluster, item, inst):
+        """
+        Fetch callback for retrieving metric values based on the METRICS structure.
+        """
+        # self.log(f"Fetching data for cluster {cluster}, item {item}, instance {inst}")
+
+        # Convert cluster to Cluster enum
+        cluster = Cluster(cluster)
+
+        if cluster not in self.METRICS:
+            self.log(f"Unknown cluster {cluster}")
+            return [c_api.PM_ERR_PMID, 0]
+
+        metrics = self.METRICS[cluster]
+        if item >= len(metrics):
+            self.log(f"Unknown item {item} in cluster {cluster}")
+            return [c_api.PM_ERR_PMID, 0]
+
+        metric = metrics[item]
+        metric_key = metric.key
+
+        if cluster == Cluster.RDS_INFO:
+            return self._fetch_rds_info(metric_key)
+        if cluster == Cluster.LAT:
+            return self._fetch_latency_metrics(item)
+
+        value = self.rds_counters.get(metric_key)
+        if value is not None:
+            return [value, 1]
+
+        self.log(f"Failed to fetch data for cluster {cluster}, item {item}")
+        return [c_api.PM_ERR_NAME, 0]
+
+    def _fetch_rds_info(self, metric_key):
+        """
+        Fetch data for the RDS_INFO cluster.
+        """
+        res = self.rds_info_cache.get(metric_key, "")
+        if not res:
+            self.log(f"No data available for metric {metric_key}")
+            return [PMDA_FETCH_NOVALUES, 0]
+        return [res, 1]
+
+    def _fetch_latency_metrics(self, item):
+        """
+        Fetch data for the LAT cluster.
+        """
+        if item == 0:
+            return [self.ping_str, 1]
+        elif item == 1:
+            return [self.rds_ping_str, 1]
+        elif item == 2:
+            return [self.arp_str, 1]
+        else:
+            self.log(f"Unknown item {item} in LAT cluster")
+            return [c_api.PM_ERR_PMID, 0]
+
+    def register_metrics(self):
+        """Register metrics based on the METRICS structure."""
+        null_indom = c_api.PM_INDOM_NULL
+        inst_sem = c_api.PM_SEM_INSTANT
+
+        for cluster, metrics in self.METRICS.items():
+            for item, metric in enumerate(metrics):
+                self.add_metric(
+                    metric.name,
+                    pmdaMetric(
+                        self.pmid(cluster.value, item),
+                        metric.type,
+                        null_indom,
+                        inst_sem,
+                        metric.units,
+                    ),
+                )
+
+        self.log("Registered all metrics!")
+    def __init__(self, name, domain, user, logfile):
+
+        super().__init__(name, domain, logfile)
+        if user is not None:
+            self.set_user(user)
+            self.log('Note: running as user "%s"' % user)
+
+        self.connect_pmcd()
+        self.pmda_name = name
+
+        self.ping_str = ""
+        self.rds_ping_str = ""
+        self.arp_str = ""
+        self.rds_counters = defaultdict()
+        self.rds_info_cache = defaultdict()
+
+        self.rds_info = RdsInfo()
+
+        self.register_metrics()
+        self.set_fetch(self.populate_data)
+        self.set_fetch_callback(self.rds_fetch_callback)
+
+    @classmethod
+    def in_pmda_setup(cls):
+        """Check if PMDA is in setup state"""
+        return os.environ.get('PCP_PYTHON_DOMAIN') or os.environ.get('PCP_PYTHON_PMNS')
+
+if __name__ == "__main__":
+    # This PMDA starts up in the "notready" state, see the Install script where
+    # the IPC protocol is ipc_prot="binary notready". See also pmcd(1) man page.
+    # The "binary notready" setting can also be manually configured in pmcd.conf.
+    pmda = RDSPMDA(name='rds', domain=255, user="root", logfile='rds.log')
+
+    pmda.pmda_ready()
+    if not pmda.in_pmda_setup():
+        pmda.log("Ready to process requests.")
+
+    # Now enter the main loop
+    pmda.run()
diff --git a/src/pmdas/rds/pmns b/src/pmdas/rds/pmns
new file mode 100644
index 00000000000..6b8c3a3d19d
--- /dev/null
+++ b/src/pmdas/rds/pmns
@@ -0,0 +1 @@
+rds		255:*:*
diff --git a/src/pmns/stdpmid.pcp b/src/pmns/stdpmid.pcp
index 73187e9f936..06b1d217f70 100644
--- a/src/pmns/stdpmid.pcp
+++ b/src/pmns/stdpmid.pcp
@@ -162,7 +162,8 @@ QA_TEST_PERL	252
 SIMPLE		253
 MEMORY_PYTHON	254
 # end QA section
-### MORE FREE SLOTS 255..510 ###
+RDS		255
+### MORE FREE SLOTS 256..510 ###
 #
 # 511 is REALLY reserved ... see DYNAMIC_PMID in libpcp.h
 #