go mod tidy

.gitignore

@@ -1,2 +1,2 @@
-vpp-snmp-agent
+govpp-snmp-agentx
-govpp-snmp-example
+vppcfg.yaml

LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

README.md

@@ -1,6 +1,8 @@
 # VPP SNMP AgentX Bridge
 
-A Go application that bridges VPP (Vector Packet Processing) interface statistics to SNMP using the AgentX protocol. It queries VPP interface counters and exposes them via the standard IF-MIB (1.3.6.1.2.1.31.1.1.1) for SNMP monitoring.
+A Go application that bridges VPP (Vector Packet Processing) interface statistics to SNMP using the
+AgentX protocol. It queries VPP interface counters and exposes them via the standard IF-MIB
+for SNMP monitoring.
 
 ## Features
 
@@ -14,21 +16,22 @@ A Go application that bridges VPP (Vector Packet Processing) interface statistic
 ## Architecture
 
 ```
-VPP Stats Socket → VPP Stats Client → Interface MIB → AgentX → SNMP Master Agent
+VPP Stats Socket → VPP Stats Client → Interface MIB → AgentX → SNMPd
 ```
 
-The application consists of three main components:
+The application consists of four main components:
 
 1. **VPP Stats Client** (`vppstats/`): Connects to VPP stats socket and retrieves interface counters
 2. **Interface MIB** (`ifmib/`): Maps VPP statistics to SNMP IF-MIB structure
-3. **AgentX Client**: Registers with SNMP master agent to serve the MIB data
+3. **AgentX Client** (`agentx/`): Handles AgentX protocol connection and MIB registration
+4. **Main Application**: Orchestrates the components and handles configuration
 
 ## Build Instructions
 
 ### Development Build
 
 ```bash
-go build -o vpp-snmp-agent .
+go build -o govpp-snmp-agentx .
 ```
 
 ### Static Binary Build
@@ -37,11 +40,11 @@ For deployment without Go runtime dependencies:
 
 ```bash
 # Linux static binary
-CGO_ENABLED=0 GOOS=linux go build -a -ldflags '-extldflags "-static"' -o vpp-snmp-agent .
+CGO_ENABLED=0 GOOS=linux go build -a -ldflags '-extldflags "-static"' -o govpp-snmp-agentx .
 
 # Cross-compile for different architectures
-CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -ldflags '-extldflags "-static"' -o vpp-snmp-agent-linux-amd64 .
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -ldflags '-extldflags "-static"' -o govpp-snmp-agentx-linux-amd64 .
-CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -a -ldflags '-extldflags "-static"' -o vpp-snmp-agent-linux-arm64 .
+CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -a -ldflags '-extldflags "-static"' -o govpp-snmp-agentx-linux-arm64 .
 ```
 
 ### Release Build with Version Info
@@ -49,7 +52,7 @@ CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -a -ldflags '-extldflags "-static
 ```bash
 VERSION=$(git describe --tags --always --dirty)
 BUILD_TIME=$(date -u '+%Y-%m-%d_%H:%M:%S')
-CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION} -X main.buildTime=${BUILD_TIME}" -o vpp-snmp-agent .
+CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION} -X main.buildTime=${BUILD_TIME}" -o govpp-snmp-agentx .
 ```
 
 ## Usage
@@ -58,13 +61,13 @@ CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION} -X main.buildTime=${
 
 ```bash
 # Run with default settings
-./vpp-snmp-agent
+./govpp-snmp-agentx
 
 # Run with custom AgentX address
-./vpp-snmp-agent -agentx-addr 127.0.0.1:705
+./govpp-snmp-agentx -agentx.addr 127.0.0.1:705
 
 # Run with Unix socket AgentX connection
-./vpp-snmp-agent -agentx-addr /var/agentx/master
+./govpp-snmp-agentx -agentx.addr /var/agentx/master
 ```
 
 ### Command Line Flags
@@ -73,14 +76,21 @@ CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION} -X main.buildTime=${
 
 | Flag | Default | Description |
 |------|---------|-------------|
-| `-agentx-addr` | `localhost:705` | AgentX master agent address (hostname:port or Unix socket path) |
 | `-debug` | `false` | Enable debug logging |
+| `-vppcfg` | `""` | VPP configuration YAML file to read interface descriptions from |
+
+#### AgentX Module Flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `-agentx.addr` | `localhost:705` | AgentX master agent address (hostname:port or Unix socket path) |
 
 #### VPP Statistics Module Flags
 
 | Flag | Default | Description |
 |------|---------|-------------|
-| `-vppstats.addr` | `/var/run/vpp/stats.sock` | VPP statistics socket path |
+| `-vppstats.api.addr` | `/var/run/vpp/api.sock` | VPP API socket path |
+| `-vppstats.stats.addr` | `/var/run/vpp/stats.sock` | VPP statistics socket path |
 | `-vppstats.period` | `10` | Interval in seconds for querying VPP interface stats |
 | `-vppstats.ifindex-offset` | `1000` | Offset to add to VPP interface indices for SNMP |
 
@@ -88,26 +98,63 @@ CGO_ENABLED=0 go build -ldflags "-X main.version=${VERSION} -X main.buildTime=${
 
 ```bash
 # Enable debug logging
-./vpp-snmp-agent -debug
+./govpp-snmp-agentx -debug
 
 # Custom polling interval (5 seconds)
-./vpp-snmp-agent -vppstats.period 5
+./govpp-snmp-agentx -vppstats.period 5
 
 # Custom VPP stats socket
-./vpp-snmp-agent -vppstats.addr /custom/path/stats.sock
+./govpp-snmp-agentx -vppstats.stats.addr /custom/path/stats.sock
+
+# Custom VPP API socket
+./govpp-snmp-agentx -vppstats.api.addr /custom/path/api.sock
 
 # Custom interface index offset (start at 2000)
-./vpp-snmp-agent -vppstats.ifindex-offset 2000
+./govpp-snmp-agentx -vppstats.ifindex-offset 2000
+
+# With VPP configuration file for interface descriptions
+./govpp-snmp-agentx -vppcfg /etc/vpp/vppcfg.yaml
 
 # Full configuration
-./vpp-snmp-agent \
+./govpp-snmp-agentx \
-  -agentx-addr /var/agentx/master \
+  -agentx.addr /var/agentx/master \
   -debug \
-  -vppstats.addr /var/run/vpp/stats.sock \
+  -vppcfg /etc/vpp/vppcfg.yaml \
+  -vppstats.api.addr /var/run/vpp/api.sock \
+  -vppstats.stats.addr /var/run/vpp/stats.sock \
   -vppstats.period 5 \
   -vppstats.ifindex-offset 1000
 ```
 
+## VPP Configuration File
+
+The `-vppcfg` flag accepts a YAML configuration file that describes VPP interfaces and their descriptions. This file is used to populate the `ifAlias` (.18) field in the ifXTable with meaningful interface descriptions.
+
+### YAML Format Example
+
+```yaml
+interfaces:
+  GigabitEthernet82/0/0:
+    description: 'Infra: Management interface'
+  TenGigabitEthernet1/0/2:
+    description: 'Infra: Core uplink'
+    sub-interfaces:
+      100:
+        description: 'Cust: Customer VLAN 100'
+      200:
+        description: 'Transit: Provider VLAN 200'
+loopbacks:
+  loop0:
+    description: 'Core: Router loopback'
+```
+
+### Description Mapping
+
+- **Main interfaces**: Use the `description` field directly
+- **Sub-interfaces**: Use the `description` field from the `sub-interfaces` section
+- **Loopbacks**: Use the `description` field from the `loopbacks` section
+- **Fallback**: If no description is found, the interface name is used as the alias
+
 ## SNMP Interface Mapping
 
 VPP interfaces are mapped to SNMP indices with a configurable offset (default 1000):
@@ -135,6 +182,7 @@ The application implements the ifXTable (1.3.6.1.2.1.31.1.1.1) with the followin
 | `.11.{index}` | ifHCOutUcastPkts | Counter64 | TX unicast packets (high capacity) |
 | `.12.{index}` | ifHCOutMulticastPkts | Counter64 | TX multicast packets (high capacity) |
 | `.13.{index}` | ifHCOutBroadcastPkts | Counter64 | TX broadcast packets (high capacity) |
+| `.18.{index}` | ifAlias | DisplayString | Interface description/alias (from VPP config or interface name) |
 
 ## SNMP Query Examples
 
@@ -148,6 +196,16 @@ snmpwalk -v2c -c public localhost 1.3.6.1.2.1.31.1.1.1.1
 snmpget -v2c -c public localhost 1.3.6.1.2.1.31.1.1.1.1.1000
 ```
 
+### Query Interface Descriptions
+
+```bash
+# Get all interface descriptions/aliases
+snmpwalk -v2c -c public localhost 1.3.6.1.2.1.31.1.1.1.18
+
+# Get specific interface description (interface 0 with default offset)
+snmpget -v2c -c public localhost 1.3.6.1.2.1.31.1.1.1.18.1000
+```
+
 ### Query Interface Counters
 
 ```bash
@@ -236,7 +294,10 @@ snmpwalk -v2c -c public localhost 1.3.6.1.2.1.31.1.1.1
 
 ## License
 
-This project uses the LGPL 3.0 licensed go-agentx library.
+This project uses the LGPL 3.0 licensed go-agentx library. It has been modified due to a bug,
+see details in [[GitHub PR#7](https://github.com/posteo/go-agentx/pull/11)], and as such is
+licensed also LGPL 3.0. The go-agentx source code in this project will be removed once the
+upstream PR is merged.
 
 ## Contributing
 

agentx/agentx.go

@@ -0,0 +1,48 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package agentx
+
+import (
+	"flag"
+	"strings"
+	"time"
+
+	"github.com/posteo/go-agentx"
+
+	"govpp-snmp-agentx/ifmib"
+	"govpp-snmp-agentx/logger"
+)
+
+var (
+	// Flags for AgentX configuration
+	AgentXAddr = flag.String("agentx.addr", "localhost:705", "Address to connect to (hostname:port or Unix socket path)")
+)
+
+// StartAgentXRoutine initializes the AgentX client and registers the interface MIB
+func StartAgentXRoutine(interfaceMIB *ifmib.InterfaceMIB) error {
+	var network, address string
+	if strings.HasPrefix(*AgentXAddr, "/") {
+		network = "unix"
+		address = *AgentXAddr
+	} else {
+		network = "tcp"
+		address = *AgentXAddr
+	}
+
+	logger.Debugf("Connecting to AgentX at %s://%s", network, address)
+
+	client, err := agentx.Dial(network, address)
+	if err != nil {
+		return err
+	}
+	client.Timeout = 1 * time.Minute
+	client.ReconnectInterval = 1 * time.Second
+
+	// Register the interface MIB with the AgentX client
+	if err := interfaceMIB.RegisterWithClient(client); err != nil {
+		return err
+	}
+
+	logger.Printf("Successfully registered with AgentX at %s://%s", network, address)
+	return nil
+}

agentx/agentx_test.go

@@ -0,0 +1,53 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package agentx
+
+import (
+	"flag"
+	"testing"
+)
+
+func TestAgentXAddrFlag(t *testing.T) {
+	// Test that the flag is registered with correct default
+	if *AgentXAddr != "localhost:705" {
+		t.Errorf("Expected default AgentX address to be 'localhost:705', got '%s'", *AgentXAddr)
+	}
+}
+
+func TestAgentXAddrFlagParsing(t *testing.T) {
+	// Save original flag value
+	originalAddr := *AgentXAddr
+	defer func() { *AgentXAddr = originalAddr }()
+
+	// Test Unix socket path
+	testAddr := "/var/run/test.sock"
+	*AgentXAddr = testAddr
+	
+	if *AgentXAddr != testAddr {
+		t.Errorf("Expected AgentX address to be '%s', got '%s'", testAddr, *AgentXAddr)
+	}
+
+	// Test TCP address
+	testAddr = "192.168.1.1:705"
+	*AgentXAddr = testAddr
+	
+	if *AgentXAddr != testAddr {
+		t.Errorf("Expected AgentX address to be '%s', got '%s'", testAddr, *AgentXAddr)
+	}
+}
+
+func TestFlagRegistration(t *testing.T) {
+	// Test that our flag is properly registered
+	f := flag.Lookup("agentx.addr")
+	if f == nil {
+		t.Error("Expected agentx.addr flag to be registered")
+	}
+	
+	if f.DefValue != "localhost:705" {
+		t.Errorf("Expected flag default value to be 'localhost:705', got '%s'", f.DefValue)
+	}
+	
+	if f.Usage != "Address to connect to (hostname:port or Unix socket path)" {
+		t.Errorf("Unexpected flag usage string: %s", f.Usage)
+	}
+}

config/config.go

@@ -1,3 +1,5 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
 package config
 
 // Global configuration variables

config/config_test.go

@@ -0,0 +1,30 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package config
+
+import "testing"
+
+func TestDebugFlagDefault(t *testing.T) {
+	// Test that Debug flag starts as false by default
+	if Debug != false {
+		t.Errorf("Expected Debug to be false by default, got %v", Debug)
+	}
+}
+
+func TestDebugFlagSet(t *testing.T) {
+	// Save original value
+	original := Debug
+	defer func() { Debug = original }()
+
+	// Test setting Debug to true
+	Debug = true
+	if Debug != true {
+		t.Errorf("Expected Debug to be true after setting, got %v", Debug)
+	}
+
+	// Test setting Debug to false
+	Debug = false
+	if Debug != false {
+		t.Errorf("Expected Debug to be false after setting, got %v", Debug)
+	}
+}

go.mod

@@ -1,4 +1,4 @@
-module govpp-snmp-example
+module govpp-snmp-agentx
 
 go 1.23.8
 
@@ -7,11 +7,13 @@ toolchain go1.23.10
 require (
 	github.com/posteo/go-agentx v0.2.1
 	go.fd.io/govpp v0.12.0
+	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/ftrvxmtrx/fd v0.0.0-20150925145434-c6d800382fff // indirect
+	github.com/kr/text v0.2.0 // indirect
 	github.com/lunixbochs/struc v0.0.0-20200521075829-a4cb8d33dbbe // indirect
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	golang.org/x/sys v0.31.0 // indirect

go.sum

@@ -1,3 +1,4 @@
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -7,6 +8,10 @@ github.com/ftrvxmtrx/fd v0.0.0-20150925145434-c6d800382fff h1:zk1wwii7uXmI0znwU+
 github.com/ftrvxmtrx/fd v0.0.0-20150925145434-c6d800382fff/go.mod h1:yUhRXHewUVJ1k89wHKP68xfzk7kwXUx/DV1nx4EBMbw=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/lunixbochs/struc v0.0.0-20200521075829-a4cb8d33dbbe h1:ewr1srjRCmcQogPQ/NCx6XCk6LGVmsVCc9Y3vvPZj+Y=
 github.com/lunixbochs/struc v0.0.0-20200521075829-a4cb8d33dbbe/go.mod h1:vy1vK6wD6j7xX6O6hXe621WabdtNkou2h7uRtTfRMyg=
 github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y=
@@ -29,6 +34,8 @@ golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
 golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

ifmib/ifmib.go

@@ -1,7 +1,10 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
 package ifmib
 
 import (
 	"fmt"
+	"io/ioutil"
 	"sync"
 	"time"
 
@@ -9,9 +12,10 @@ import (
 	"github.com/posteo/go-agentx/pdu"
 	"github.com/posteo/go-agentx/value"
 	"go.fd.io/govpp/api"
+	"gopkg.in/yaml.v3"
 	
-	"govpp-snmp-example/logger"
+	"govpp-snmp-agentx/logger"
-	"govpp-snmp-example/vppstats"
+	"govpp-snmp-agentx/vppstats"
 )
 
 // IF-MIB OID bases:
@@ -56,22 +60,36 @@ import (
 // ifHCOutUcastPkts    .11 - Counter64
 // ifHCOutMulticastPkts .12 - Counter64
 // ifHCOutBroadcastPkts .13 - Counter64
+// ifAlias             .18 - DisplayString
 
 const ifEntryOID = "1.3.6.1.2.1.2.2.1"
 const ifXTableOID = "1.3.6.1.2.1.31.1.1.1"
 
+// VPP Config YAML structures
+type VPPConfig struct {
+	Interfaces map[string]VPPInterface `yaml:"interfaces"`
+	Loopbacks  map[string]VPPInterface `yaml:"loopbacks"`
+}
+
+type VPPInterface struct {
+	Description    string                    `yaml:"description"`
+	SubInterfaces  map[string]VPPInterface   `yaml:"sub-interfaces"`
+}
+
 type InterfaceMIB struct {
 	mutex           sync.RWMutex
 	handler         *agentx.ListHandler
 	ifEntrySession  *agentx.Session
 	ifXTableSession *agentx.Session
 	stats           map[uint32]*api.InterfaceCounters // indexed by interface index
+	descriptions    map[string]string                 // interface name -> description mapping
 }
 
 func NewInterfaceMIB() *InterfaceMIB {
 	return &InterfaceMIB{
-		handler: &agentx.ListHandler{},
+		handler:      &agentx.ListHandler{},
-		stats:   make(map[uint32]*api.InterfaceCounters),
+		stats:        make(map[uint32]*api.InterfaceCounters),
+		descriptions: make(map[string]string),
 	}
 }
 
@@ -79,6 +97,51 @@ func (m *InterfaceMIB) GetHandler() *agentx.ListHandler {
 	return m.handler
 }
 
+func (m *InterfaceMIB) LoadVPPConfig(configPath string) error {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+
+	// Read YAML file
+	data, err := ioutil.ReadFile(configPath)
+	if err != nil {
+		return fmt.Errorf("failed to read VPP config file: %v", err)
+	}
+
+	// Parse YAML
+	var config VPPConfig
+	if err := yaml.Unmarshal(data, &config); err != nil {
+		return fmt.Errorf("failed to parse VPP config YAML: %v", err)
+	}
+
+	// Extract interface descriptions
+	for ifName, ifConfig := range config.Interfaces {
+		if ifConfig.Description != "" {
+			m.descriptions[ifName] = ifConfig.Description
+			logger.Debugf("Loaded description for interface %s: %s", ifName, ifConfig.Description)
+		}
+
+		// Process sub-interfaces
+		for subID, subConfig := range ifConfig.SubInterfaces {
+			if subConfig.Description != "" {
+				subIfName := fmt.Sprintf("%s.%s", ifName, subID)
+				m.descriptions[subIfName] = subConfig.Description
+				logger.Debugf("Loaded description for sub-interface %s: %s", subIfName, subConfig.Description)
+			}
+		}
+	}
+
+	// Extract loopback descriptions
+	for ifName, ifConfig := range config.Loopbacks {
+		if ifConfig.Description != "" {
+			m.descriptions[ifName] = ifConfig.Description
+			logger.Debugf("Loaded description for loopback %s: %s", ifName, ifConfig.Description)
+		}
+	}
+
+	logger.Printf("Loaded %d interface descriptions from VPP config", len(m.descriptions))
+	return nil
+}
+
 func (m *InterfaceMIB) UpdateStats(interfaceStats *api.InterfaceStats) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
@@ -298,6 +361,16 @@ func (m *InterfaceMIB) addIfXTable(iface *api.InterfaceCounters, idx int) {
 	item = m.handler.Add(fmt.Sprintf("%s.13.%d", ifXTableOID, idx))
 	item.Type = pdu.VariableTypeCounter64
 	item.Value = iface.TxBroadcast.Packets
+
+	// ifAlias (.18) - Interface description/alias
+	item = m.handler.Add(fmt.Sprintf("%s.18.%d", ifXTableOID, idx))
+	item.Type = pdu.VariableTypeOctetString
+	// Use description from VPP config if available, otherwise use interface name
+	if desc, exists := m.descriptions[iface.InterfaceName]; exists {
+		item.Value = desc
+	} else {
+		item.Value = iface.InterfaceName
+	}
 }
 
 func (m *InterfaceMIB) RegisterWithClient(client *agentx.Client) error {

ifmib/ifmib_test.go

@@ -0,0 +1,180 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package ifmib
+
+import (
+	"os"
+	"testing"
+
+	"go.fd.io/govpp/api"
+)
+
+func TestNewInterfaceMIB(t *testing.T) {
+	mib := NewInterfaceMIB()
+	
+	if mib == nil {
+		t.Fatal("NewInterfaceMIB returned nil")
+	}
+	
+	if mib.handler == nil {
+		t.Error("Expected handler to be initialized")
+	}
+	
+	if mib.stats == nil {
+		t.Error("Expected stats map to be initialized")
+	}
+	
+	if mib.descriptions == nil {
+		t.Error("Expected descriptions map to be initialized")
+	}
+	
+	if len(mib.stats) != 0 {
+		t.Errorf("Expected stats map to be empty, got %d entries", len(mib.stats))
+	}
+	
+	if len(mib.descriptions) != 0 {
+		t.Errorf("Expected descriptions map to be empty, got %d entries", len(mib.descriptions))
+	}
+}
+
+func TestGetHandler(t *testing.T) {
+	mib := NewInterfaceMIB()
+	handler := mib.GetHandler()
+	
+	if handler == nil {
+		t.Error("GetHandler returned nil")
+	}
+	
+	if handler != mib.handler {
+		t.Error("GetHandler returned different handler than expected")
+	}
+}
+
+func TestLoadVPPConfigValidYAML(t *testing.T) {
+	mib := NewInterfaceMIB()
+	
+	// Create a temporary YAML file
+	yamlContent := `interfaces:
+  GigabitEthernet0/0/0:
+    description: 'Test: Interface'
+    sub-interfaces:
+      100:
+        description: 'Test: Sub-interface'
+loopbacks:
+  loop0:
+    description: 'Test: Loopback'
+`
+	
+	tmpfile, err := os.CreateTemp("", "test_*.yaml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpfile.Name())
+	
+	if _, err := tmpfile.Write([]byte(yamlContent)); err != nil {
+		t.Fatal(err)
+	}
+	if err := tmpfile.Close(); err != nil {
+		t.Fatal(err)
+	}
+	
+	// Test loading the config
+	err = mib.LoadVPPConfig(tmpfile.Name())
+	if err != nil {
+		t.Fatalf("LoadVPPConfig failed: %v", err)
+	}
+	
+	// Check that descriptions were loaded
+	if len(mib.descriptions) != 3 {
+		t.Errorf("Expected 3 descriptions, got %d", len(mib.descriptions))
+	}
+	
+	if mib.descriptions["GigabitEthernet0/0/0"] != "Test: Interface" {
+		t.Errorf("Unexpected interface description: %s", mib.descriptions["GigabitEthernet0/0/0"])
+	}
+	
+	if mib.descriptions["GigabitEthernet0/0/0.100"] != "Test: Sub-interface" {
+		t.Errorf("Unexpected sub-interface description: %s", mib.descriptions["GigabitEthernet0/0/0.100"])
+	}
+	
+	if mib.descriptions["loop0"] != "Test: Loopback" {
+		t.Errorf("Unexpected loopback description: %s", mib.descriptions["loop0"])
+	}
+}
+
+func TestLoadVPPConfigNonExistentFile(t *testing.T) {
+	mib := NewInterfaceMIB()
+	
+	err := mib.LoadVPPConfig("/nonexistent/file.yaml")
+	if err == nil {
+		t.Error("Expected error for non-existent file")
+	}
+}
+
+func TestLoadVPPConfigInvalidYAML(t *testing.T) {
+	mib := NewInterfaceMIB()
+	
+	// Create a temporary file with invalid YAML
+	invalidYAML := `interfaces:
+  test: [
+`
+	
+	tmpfile, err := os.CreateTemp("", "invalid_*.yaml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpfile.Name())
+	
+	if _, err := tmpfile.Write([]byte(invalidYAML)); err != nil {
+		t.Fatal(err)
+	}
+	if err := tmpfile.Close(); err != nil {
+		t.Fatal(err)
+	}
+	
+	err = mib.LoadVPPConfig(tmpfile.Name())
+	if err == nil {
+		t.Error("Expected error for invalid YAML")
+	}
+}
+
+func TestUpdateStatsBasic(t *testing.T) {
+	mib := NewInterfaceMIB()
+	
+	// Create mock interface stats
+	stats := &api.InterfaceStats{
+		Interfaces: []api.InterfaceCounters{
+			{
+				InterfaceIndex: 0,
+				InterfaceName:  "test0",
+				Rx: api.InterfaceCounterCombined{
+					Packets: 100,
+					Bytes:   1000,
+				},
+				Tx: api.InterfaceCounterCombined{
+					Packets: 200,
+					Bytes:   2000,
+				},
+			},
+		},
+	}
+	
+	// Call UpdateStats (this will test the basic flow without AgentX sessions)
+	mib.UpdateStats(stats)
+	
+	// Check that stats were stored
+	if len(mib.stats) != 1 {
+		t.Errorf("Expected 1 interface in stats, got %d", len(mib.stats))
+	}
+	
+	if storedStats, exists := mib.stats[0]; !exists {
+		t.Error("Expected interface 0 to be stored in stats")
+	} else {
+		if storedStats.InterfaceName != "test0" {
+			t.Errorf("Expected interface name 'test0', got '%s'", storedStats.InterfaceName)
+		}
+		if storedStats.Rx.Packets != 100 {
+			t.Errorf("Expected RX packets 100, got %d", storedStats.Rx.Packets)
+		}
+	}
+}

logger/logger.go

@@ -1,44 +1,52 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
 package logger
 
 import (
 	"fmt"
-	"log"
 	"path/filepath"
 	"runtime"
 	
-	"govpp-snmp-example/config"
+	"govpp-snmp-agentx/config"
 )
 
-// logf logs a message with automatic caller information (file:function)
+// getCallerInfo returns caller information in the format "file.go:function"
-func logf(format string, args ...interface{}) {
+func getCallerInfo() string {
-	pc, file, _, ok := runtime.Caller(2)
+	pc, file, _, ok := runtime.Caller(2) // Skip getCallerInfo and Printf/Debugf
 	if !ok {
-		log.Printf(format, args...)
+		return "unknown:unknown"
-		return
 	}
 	
 	fn := runtime.FuncForPC(pc)
 	if fn == nil {
-		log.Printf(format, args...)
+		return "unknown:unknown"
-		return
 	}
 	
 	funcName := filepath.Base(fn.Name())
 	fileName := filepath.Base(file)
 	
-	prefix := fmt.Sprintf("%s:%s", fileName, funcName)
+	return fmt.Sprintf("%s:%s", fileName, funcName)
-	message := fmt.Sprintf(format, args...)
-	log.Printf("%s %s", prefix, message)
 }
 
-// Printf logs a message with caller information
+// Printf logs a message with caller information in SYSLOG style
 func Printf(format string, args ...interface{}) {
-	logf(format, args...)
+	caller := getCallerInfo()
+	message := fmt.Sprintf(format, args...)
+	syslogMessage := fmt.Sprintf("INFO %s %s", caller, message)
+	fmt.Println(syslogMessage)
 }
 
 // Debugf logs a debug message with caller information if global debug is enabled
 func Debugf(format string, args ...interface{}) {
 	if config.Debug {
-		logf(format, args...)
+		caller := getCallerInfo()
+		message := fmt.Sprintf(format, args...)
+		syslogMessage := fmt.Sprintf("DEBUG %s %s", caller, message)
+		fmt.Println(syslogMessage)
 	}
+}
+
+// Sync flushes any buffered log entries (no-op for fmt.Println)
+func Sync() {
+	// No buffering with fmt.Println, so this is a no-op
 }

logger/logger_test.go

@@ -0,0 +1,113 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package logger
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"strings"
+	"testing"
+
+	"govpp-snmp-agentx/config"
+)
+
+func TestPrintf(t *testing.T) {
+	// Capture stdout
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	Printf("test message: %s", "hello")
+
+	// Close writer and restore stdout
+	w.Close()
+	os.Stdout = oldStdout
+
+	// Read captured output
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	output := buf.String()
+
+	// Check output format: "INFO file.go:function message"
+	if !strings.HasPrefix(output, "INFO ") {
+		t.Errorf("Expected output to start with 'INFO ', got: %s", output)
+	}
+	
+	if !strings.Contains(output, "logger_test.go:logger.TestPrintf") {
+		t.Errorf("Expected output to contain caller info, got: %s", output)
+	}
+	
+	if !strings.Contains(output, "test message: hello") {
+		t.Errorf("Expected output to contain message, got: %s", output)
+	}
+}
+
+func TestDebugfWithDebugEnabled(t *testing.T) {
+	// Save original debug state
+	originalDebug := config.Debug
+	defer func() { config.Debug = originalDebug }()
+
+	// Enable debug
+	config.Debug = true
+
+	// Capture stdout
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	Debugf("debug message: %s", "test")
+
+	// Close writer and restore stdout
+	w.Close()
+	os.Stdout = oldStdout
+
+	// Read captured output
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	output := buf.String()
+
+	// Check output format: "DEBUG file.go:function message"
+	if !strings.HasPrefix(output, "DEBUG ") {
+		t.Errorf("Expected output to start with 'DEBUG ', got: %s", output)
+	}
+	
+	if !strings.Contains(output, "debug message: test") {
+		t.Errorf("Expected output to contain message, got: %s", output)
+	}
+}
+
+func TestDebugfWithDebugDisabled(t *testing.T) {
+	// Save original debug state
+	originalDebug := config.Debug
+	defer func() { config.Debug = originalDebug }()
+
+	// Disable debug
+	config.Debug = false
+
+	// Capture stdout
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	Debugf("debug message: %s", "test")
+
+	// Close writer and restore stdout
+	w.Close()
+	os.Stdout = oldStdout
+
+	// Read captured output
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	output := buf.String()
+
+	// Should be empty when debug is disabled
+	if output != "" {
+		t.Errorf("Expected no output when debug is disabled, got: %s", output)
+	}
+}
+
+func TestSync(t *testing.T) {
+	// Test that Sync doesn't panic (it's a no-op now)
+	Sync()
+}

main.go

@@ -1,54 +1,55 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
 package main
 
 import (
 	"flag"
 	"log"
-	"strings"
+	"os"
-	"time"
+	"os/signal"
+	"syscall"
 
-	"github.com/posteo/go-agentx"
+	"govpp-snmp-agentx/agentx"
-
+	"govpp-snmp-agentx/config"
-	"govpp-snmp-example/config"
+	"govpp-snmp-agentx/ifmib"
-	"govpp-snmp-example/ifmib"
+	"govpp-snmp-agentx/logger"
-	"govpp-snmp-example/vppstats"
+	"govpp-snmp-agentx/vppstats"
 )
 
 func main() {
-	addr := flag.String("agentx-addr", "localhost:705", "Address to connect to (hostname:port or Unix socket path)")
 	debug := flag.Bool("debug", false, "Enable debug logging")
+	vppcfg := flag.String("vppcfg", "", "VPP configuration YAML file to read interface descriptions from")
 	flag.Parse()
 
 	// Set global debug flag
 	config.Debug = *debug
 
-	var network, address string
-	if strings.HasPrefix(*addr, "/") {
-		network = "unix"
-		address = *addr
-	} else {
-		network = "tcp"
-		address = *addr
-	}
-
-	client, err := agentx.Dial(network, address)
-	if err != nil {
-		log.Fatalf("Failed to dial %s %s: %v", network, address, err)
-	}
-	client.Timeout = 1 * time.Minute
-	client.ReconnectInterval = 1 * time.Second
-
 	// Create the interface MIB
 	interfaceMIB := ifmib.NewInterfaceMIB()
 
-	// Register the interface MIB with the AgentX client
+	// Load VPP config if specified
-	if err := interfaceMIB.RegisterWithClient(client); err != nil {
+	if *vppcfg != "" {
-		log.Fatalf("Failed to register interface MIB: %v", err)
+		if err := interfaceMIB.LoadVPPConfig(*vppcfg); err != nil {
+			log.Fatalf("Failed to load VPP config: %v", err)
+		}
+	}
+
+	// Start AgentX routine
+	if err := agentx.StartAgentXRoutine(interfaceMIB); err != nil {
+		log.Fatalf("Failed to start AgentX: %v", err)
 	}
 
 	// Start VPP stats routine with callback to update MIB
 	vppstats.StartStatsRoutine(interfaceMIB.UpdateStats)
 
-	for {
+	// Set up signal handling for graceful shutdown
-		time.Sleep(100 * time.Millisecond)
+	sigChan := make(chan os.Signal, 1)
-	}
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	// Wait for shutdown signal
+	<-sigChan
+	logger.Printf("Shutting down...")
+	
+	// Flush any buffered log entries
+	logger.Sync()
 }

main_test.go

@@ -0,0 +1,20 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package main
+
+import (
+	"os"
+	"testing"
+)
+
+func TestMainCompiles(t *testing.T) {
+	// This test simply ensures that main package compiles
+	// More comprehensive integration tests would require mocking VPP and SNMP
+	if os.Getenv("BE_MAIN") == "1" {
+		// This would run main(), but we skip it in tests
+		return
+	}
+	
+	// Just test that we can access main package
+	t.Log("Main package compiles successfully")
+}

vppstats/stats.go

@@ -1,24 +1,28 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
 package vppstats
 
 import (
 	"flag"
-	"log"
 	"time"
 
+	"go.fd.io/govpp/adapter/socketclient"
 	"go.fd.io/govpp/adapter/statsclient"
 	"go.fd.io/govpp/api"
+	"go.fd.io/govpp/binapi/vpe"
 	"go.fd.io/govpp/core"
-	
+
-	"govpp-snmp-example/logger"
+	"govpp-snmp-agentx/logger"
 )
 
 type StatsCallback func(*api.InterfaceStats)
 
 var (
 	// Flags for VPP stats configuration
-	StatsAddr      = flag.String("vppstats.addr", "/var/run/vpp/stats.sock", "VPP stats socket path")
+	ApiAddr       = flag.String("vppstats.api.addr", "/var/run/vpp/api.sock", "VPP API socket path")
-	IfIndexOffset  = flag.Int("vppstats.ifindex-offset", 1000, "Offset to add to VPP interface indices for SNMP")
+	StatsAddr     = flag.String("vppstats.stats.addr", "/var/run/vpp/stats.sock", "VPP stats socket path")
-	Period         = flag.Int("vppstats.period", 10, "Interval in seconds for querying VPP interface stats")
+	IfIndexOffset = flag.Int("vppstats.ifindex-offset", 1000, "Offset to add to VPP interface indices for SNMP")
+	Period        = flag.Int("vppstats.period", 10, "Interval in seconds for querying VPP interface stats")
 )
 
 // StartStatsRoutine starts a goroutine that queries VPP interface stats at the configured interval
@@ -28,41 +32,137 @@ func StartStatsRoutine(callback StatsCallback) {
 }
 
 func statsRoutine(period time.Duration, callback StatsCallback) {
-	logger.Debugf("Starting VPP stats routine with socket: %s, period: %v", *StatsAddr, period)
+	logger.Debugf("Starting VPP stats routine with API: %s, Stats: %s, period: %v", *ApiAddr, *StatsAddr, period)
 
-	// Create stats client
+	var conn *core.Connection
-	client := statsclient.NewStatsClient(*StatsAddr)
+	var statsConn *core.StatsConnection
-
+	var connected = false
-	// Connect using core.ConnectStats (proper way)
+	var wasConnected = false
-	c, err := core.ConnectStats(client)
-	if err != nil {
-		log.Printf("Failed to connect to VPP stats: %v", err)
-		return
-	}
-	defer c.Disconnect()
-
-	// Query stats immediately on startup
-	queryInterfaceStats(c, callback)
 
 	ticker := time.NewTicker(period)
 	defer ticker.Stop()
 
+	defer func() {
+		// Safely disconnect connections with panic recovery
+		if conn != nil {
+			func() {
+				defer func() {
+					if r := recover(); r != nil {
+						logger.Debugf("Recovered from conn.Disconnect panic: %v", r)
+					}
+				}()
+				conn.Disconnect()
+			}()
+		}
+		if statsConn != nil {
+			func() {
+				defer func() {
+					if r := recover(); r != nil {
+						logger.Debugf("Recovered from statsConn.Disconnect panic: %v", r)
+					}
+				}()
+				statsConn.Disconnect()
+			}()
+		}
+	}()
+
 	for {
+		// Check if we need to connect/reconnect
+		if !connected {
+			// Clean up existing connections
+			if conn != nil {
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							logger.Debugf("Recovered from conn.Disconnect during reconnect: %v", r)
+						}
+					}()
+					conn.Disconnect()
+				}()
+				conn = nil
+			}
+			if statsConn != nil {
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							logger.Debugf("Recovered from statsConn.Disconnect during reconnect: %v", r)
+						}
+					}()
+					statsConn.Disconnect()
+				}()
+				statsConn = nil
+			}
+
+			// Create API connection first - only proceed if this succeeds
+			var err error
+			conn, err = core.Connect(socketclient.NewVppClient(*ApiAddr))
+			if err != nil {
+				if wasConnected {
+					logger.Printf("VPP API connection lost: %v", err)
+					wasConnected = false
+				} else {
+					logger.Debugf("Failed to connect to VPP API: %v", err)
+				}
+				connected = false
+				time.Sleep(time.Second)
+				continue
+			}
+
+			// Only try stats connection if API connection succeeded
+			statsClient := statsclient.NewStatsClient(*StatsAddr)
+			statsConn, err = core.ConnectStats(statsClient)
+			if err != nil {
+				logger.Printf("VPP stats connection failed: %v", err)
+				// Close the API connection since we can't get stats
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							logger.Debugf("Recovered from conn.Disconnect during stats error: %v", r)
+						}
+					}()
+					conn.Disconnect()
+				}()
+				conn = nil
+				connected = false
+				time.Sleep(time.Second)
+				continue
+			}
+
+			logger.Printf("Connected to VPP (API: %s, Stats: %s)", *ApiAddr, *StatsAddr)
+			connected = true
+			wasConnected = true
+		}
+
+		// Query stats if connected
+		if connected {
+			if !queryInterfaceStats(conn, statsConn, callback) {
+				connected = false
+				continue
+			}
+		}
+
+		// Wait for next tick
 		select {
 		case <-ticker.C:
-			queryInterfaceStats(c, callback)
+			continue
 		}
 	}
 }
 
-func queryInterfaceStats(c *core.StatsConnection, callback StatsCallback) {
+func queryInterfaceStats(conn *core.Connection, statsConn *core.StatsConnection, callback StatsCallback) bool {
+	// Check VPP liveness using API call
+	if !checkVPPLiveness(conn) {
+		logger.Printf("VPP liveness check failed")
+		return false
+	}
+
 	// Create the proper struct for interface stats
 	stats := new(api.InterfaceStats)
 
 	// Use the GetInterfaceStats method - this is the correct approach
-	if err := c.GetInterfaceStats(stats); err != nil {
+	if err := statsConn.GetInterfaceStats(stats); err != nil {
 		logger.Printf("Failed to get interface stats: %v", err)
-		return
+		return false
 	}
 
 	// Always log basic info
@@ -80,4 +180,58 @@ func queryInterfaceStats(c *core.StatsConnection, callback StatsCallback) {
 	if callback != nil {
 		callback(stats)
 	}
+
+	return true
 }
+
+func checkVPPLiveness(conn *core.Connection) bool {
+	// Create a channel for the API call
+	ch, err := conn.NewAPIChannel()
+	if err != nil {
+		logger.Debugf("Failed to create API channel: %v", err)
+		return false
+	}
+
+	// Use a flag to track if channel was closed successfully
+	var channelClosed bool
+	defer func() {
+		if !channelClosed {
+			// Recover from potential panic when closing already closed channel
+			defer func() {
+				if r := recover(); r != nil {
+					logger.Debugf("Recovered from channel close panic: %v", r)
+				}
+			}()
+			ch.Close()
+		}
+	}()
+
+	// Create ShowVersion request
+	req := &vpe.ShowVersion{}
+	reply := &vpe.ShowVersionReply{}
+
+	// Send the request with timeout
+	if err := ch.SendRequest(req).ReceiveReply(reply); err != nil {
+		logger.Debugf("VPP ShowVersion failed: %v", err)
+		// Try to close the channel properly on error
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					logger.Debugf("Channel already closed during error handling")
+				}
+			}()
+			ch.Close()
+			channelClosed = true
+		}()
+		return false
+	}
+
+	// Close channel successfully
+	ch.Close()
+	channelClosed = true
+
+	// If we got here, VPP is responsive
+	logger.Debugf("VPP liveness check passed (version: %s)", string(reply.Version))
+	return true
+}
+

vppstats/stats_test.go

@@ -0,0 +1,163 @@
+// Copyright 2025, IPng Networks GmbH, Pim van Pelt <pim@ipng.ch>
+
+package vppstats
+
+import (
+	"flag"
+	"fmt"
+	"testing"
+	"time"
+
+	"go.fd.io/govpp/api"
+)
+
+func TestVPPStatsFlags(t *testing.T) {
+	// Test default values
+	if *ApiAddr != "/var/run/vpp/api.sock" {
+		t.Errorf("Expected default API address to be '/var/run/vpp/api.sock', got '%s'", *ApiAddr)
+	}
+	
+	if *StatsAddr != "/var/run/vpp/stats.sock" {
+		t.Errorf("Expected default stats address to be '/var/run/vpp/stats.sock', got '%s'", *StatsAddr)
+	}
+	
+	if *IfIndexOffset != 1000 {
+		t.Errorf("Expected default interface index offset to be 1000, got %d", *IfIndexOffset)
+	}
+	
+	if *Period != 10 {
+		t.Errorf("Expected default period to be 10, got %d", *Period)
+	}
+}
+
+func TestFlagRegistrations(t *testing.T) {
+	tests := []struct {
+		name     string
+		flagName string
+		defValue string
+	}{
+		{"API address", "vppstats.api.addr", "/var/run/vpp/api.sock"},
+		{"Stats address", "vppstats.stats.addr", "/var/run/vpp/stats.sock"},
+		{"Index offset", "vppstats.ifindex-offset", "1000"},
+		{"Period", "vppstats.period", "10"},
+	}
+	
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := flag.Lookup(tt.flagName)
+			if f == nil {
+				t.Errorf("Expected %s flag to be registered", tt.flagName)
+				return
+			}
+			
+			if f.DefValue != tt.defValue {
+				t.Errorf("Expected %s flag default value to be '%s', got '%s'", 
+					tt.flagName, tt.defValue, f.DefValue)
+			}
+		})
+	}
+}
+
+func TestStatsCallbackType(t *testing.T) {
+	// Test that we can create a valid callback function
+	var called bool
+	var receivedStats *api.InterfaceStats
+	
+	callback := func(stats *api.InterfaceStats) {
+		called = true
+		receivedStats = stats
+	}
+	
+	// Create mock stats
+	mockStats := &api.InterfaceStats{
+		Interfaces: []api.InterfaceCounters{
+			{
+				InterfaceIndex: 1,
+				InterfaceName:  "test",
+			},
+		},
+	}
+	
+	// Call the callback
+	callback(mockStats)
+	
+	if !called {
+		t.Error("Expected callback to be called")
+	}
+	
+	if receivedStats != mockStats {
+		t.Error("Expected callback to receive the same stats object")
+	}
+	
+	if len(receivedStats.Interfaces) != 1 {
+		t.Errorf("Expected 1 interface, got %d", len(receivedStats.Interfaces))
+	}
+	
+	if receivedStats.Interfaces[0].InterfaceName != "test" {
+		t.Errorf("Expected interface name 'test', got '%s'", receivedStats.Interfaces[0].InterfaceName)
+	}
+}
+
+func TestPeriodConversion(t *testing.T) {
+	// Test that period conversion works correctly
+	originalPeriod := *Period
+	defer func() { *Period = originalPeriod }()
+	
+	testPeriods := []struct {
+		input    int
+		expected time.Duration
+	}{
+		{1, time.Second},
+		{5, 5 * time.Second},
+		{10, 10 * time.Second},
+		{60, time.Minute},
+	}
+	
+	for _, tt := range testPeriods {
+		t.Run(fmt.Sprintf("period_%d", tt.input), func(t *testing.T) {
+			*Period = tt.input
+			result := time.Duration(*Period) * time.Second
+			
+			if result != tt.expected {
+				t.Errorf("Expected period %v, got %v", tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestFlagValues(t *testing.T) {
+	// Save original flag values
+	originalApiAddr := *ApiAddr
+	originalStatsAddr := *StatsAddr
+	originalOffset := *IfIndexOffset
+	originalPeriod := *Period
+	
+	defer func() {
+		*ApiAddr = originalApiAddr
+		*StatsAddr = originalStatsAddr
+		*IfIndexOffset = originalOffset
+		*Period = originalPeriod
+	}()
+	
+	// Test setting flag values
+	*ApiAddr = "/custom/api.sock"
+	*StatsAddr = "/custom/stats.sock"
+	*IfIndexOffset = 2000
+	*Period = 30
+	
+	if *ApiAddr != "/custom/api.sock" {
+		t.Errorf("Expected API address to be '/custom/api.sock', got '%s'", *ApiAddr)
+	}
+	
+	if *StatsAddr != "/custom/stats.sock" {
+		t.Errorf("Expected stats address to be '/custom/stats.sock', got '%s'", *StatsAddr)
+	}
+	
+	if *IfIndexOffset != 2000 {
+		t.Errorf("Expected interface index offset to be 2000, got %d", *IfIndexOffset)
+	}
+	
+	if *Period != 30 {
+		t.Errorf("Expected period to be 30, got %d", *Period)
+	}
+}