diff --git a/kf/bpf.go b/kf/bpf.go
index c0a7e083..14862687 100644
--- a/kf/bpf.go
+++ b/kf/bpf.go
@@ -180,18 +180,18 @@ func LoadRootProgram(ifaceName string, direction string, progType string, conf *
 	if fileExists(rootProgBPF.MapNamePath) {
 		log.Warn().Msgf("previous instance of root program %s persisted map %s file exists", rootProgBPF.Program.Name, rootProgBPF.MapNamePath)
 		if err := rootProgBPF.RemoveRootProgMapFile(ifaceName); err != nil {
-			log.Warn().Msgf("previous instance of root program %s map file removed unsuccessfully - %s ", rootProgBPF.Program.Name, rootProgBPF.MapNamePath)
+			log.Warn().Err(err).Msgf("previous instance of root program %s map file not removed successfully - %s ", rootProgBPF.Program.Name, rootProgBPF.MapNamePath)
 		}
 	}
 
 	if progType == models.XDPType {
 		rlimit.RemoveMemlock()
 		if err := rootProgBPF.LoadXDPAttachProgram(ifaceName); err != nil {
-			return nil, fmt.Errorf("failed to load xdp root program on iface \"%s\" name %s direction %s with err %v", ifaceName, rootProgBPF.Program.Name, direction, err)
+			return nil, fmt.Errorf("failed to load xdp root program on iface \"%s\" name %s direction %s with err %w", ifaceName, rootProgBPF.Program.Name, direction, err)
 		}
 	} else if progType == models.TCType {
 		if err := rootProgBPF.LoadTCAttachProgram(ifaceName, direction); err != nil {
-			return nil, fmt.Errorf("failed to load tc root program on iface \"%s\" name %s direction %s with err %v", ifaceName, rootProgBPF.Program.Name, direction, err)
+			return nil, fmt.Errorf("failed to load tc root program on iface \"%s\" name %s direction %s with err %w", ifaceName, rootProgBPF.Program.Name, direction, err)
 		}
 	}
 
@@ -214,7 +214,7 @@ func StopExternalRunningProcess(processName string) error {
 	myPid := os.Getpid()
 	processList, err := ps.Processes()
 	if err != nil {
-		return fmt.Errorf("failed to fetch processes list with err %v", err)
+		return fmt.Errorf("failed to fetch processes list with err %w", err)
 	}
 	log.Info().Msgf("Searching for process %s and not ppid %d", processName, myPid)
 	for _, process := range processList {
@@ -226,7 +226,7 @@ func StopExternalRunningProcess(processName string) error {
 					err = osProcess.Kill()
 				}
 				if err != nil {
-					return fmt.Errorf("external BPFProgram stop failed with error: %v", err)
+					return fmt.Errorf("external BPFProgram stop failed with error: %w", err)
 				}
 			}
 		}
@@ -275,7 +275,7 @@ func (b *BPF) Stop(ifaceName, direction string, chain bool) error {
 	if len(b.Program.CmdStop) < 1 && b.Program.UserProgramDaemon {
 		// Loaded using user program
 		if err := b.ProcessTerminate(); err != nil {
-			return fmt.Errorf("BPFProgram %s process terminate failed with error: %v", b.Program.Name, err)
+			return fmt.Errorf("BPFProgram %s process terminate failed with error: %w", b.Program.Name, err)
 		}
 		if b.Cmd != nil {
 			if err := b.Cmd.Wait(); err != nil {
@@ -287,7 +287,7 @@ func (b *BPF) Stop(ifaceName, direction string, chain bool) error {
 		cmd := filepath.Join(b.FilePath, b.Program.CmdStop)
 
 		if err := assertExecutable(cmd); err != nil {
-			return fmt.Errorf("no executable permissions on %s - error %v", b.Program.CmdStop, err)
+			return fmt.Errorf("no executable permissions on %s - error %w", b.Program.CmdStop, err)
 		}
 
 		args := make([]string, 0, len(b.Program.StopArgs)<<1)
@@ -315,7 +315,7 @@ func (b *BPF) Stop(ifaceName, direction string, chain bool) error {
 	// unload the BPF programs
 	if b.ProgMapCollection != nil {
 		if err := b.UnloadProgram(ifaceName, direction); err != nil {
-			return fmt.Errorf("BPFProgram %s unload failed on interface %s with error: %v", b.Program.Name, ifaceName, err)
+			return fmt.Errorf("BPFProgram %s unload failed on interface %s with error: %w", b.Program.Name, ifaceName, err)
 		}
 		log.Info().Msgf("%s => %s direction => %s - program is unloaded/detached successfully", ifaceName, b.Program.Name, direction)
 	}
@@ -340,7 +340,7 @@ func (b *BPF) Start(ifaceName, direction string, chain bool) error {
 	if len(b.Program.CmdStart) > 0 {
 		// Verify other instance is running
 		if err := StopExternalRunningProcess(b.Program.CmdStart); err != nil {
-			return fmt.Errorf("failed to stop external instance of the program %s with error : %v", b.Program.CmdStart, err)
+			return fmt.Errorf("failed to stop external instance of the program %s with error : %w", b.Program.CmdStart, err)
 		}
 	}
 
@@ -355,11 +355,11 @@ func (b *BPF) Start(ifaceName, direction string, chain bool) error {
 	if len(b.Program.ObjectFile) > 0 {
 		if chain {
 			if err := b.LoadBPFProgramChain(ifaceName, direction); err != nil {
-				return fmt.Errorf("loading bpf program %s - error %v", b.Program.Name, err)
+				return fmt.Errorf("loading bpf program %s - error %w", b.Program.Name, err)
 			}
 		} else {
 			if err := b.AttachBPFProgram(ifaceName, direction); err != nil {
-				return fmt.Errorf("attaching bpf program %s - error %v", b.Program.Name, err)
+				return fmt.Errorf("attaching bpf program %s - error %w", b.Program.Name, err)
 			}
 		}
 	} else {
@@ -369,20 +369,20 @@ func (b *BPF) Start(ifaceName, direction string, chain bool) error {
 	// Start user program before loading
 	if len(b.Program.CmdStart) > 0 {
 		if err := b.StartUserProgram(ifaceName, direction, chain); err != nil {
-			return fmt.Errorf("user program startup failed %s - error %v", b.Program.CmdStart, err)
+			return fmt.Errorf("user program startup failed %s - error %w", b.Program.CmdStart, err)
 		}
 	}
 
 	// making sure program fd map pinned file is created
 	if err := b.VerifyPinnedProgMap(chain, true); err != nil {
-		return fmt.Errorf("failed to find pinned file %s  %v", b.MapNamePath, err)
+		return fmt.Errorf("failed to find pinned file %s  %w", b.MapNamePath, err)
 	}
 
 	// BPF map config values
 	if len(b.Program.MapArgs) > 0 {
 		if err := b.UpdateBPFMaps(ifaceName, direction); err != nil {
 			log.Error().Err(err).Msg("failed to update ebpf program BPF maps")
-			return fmt.Errorf("failed to update ebpf program BPF maps %v", err)
+			return fmt.Errorf("failed to update ebpf program BPF maps %w", err)
 		}
 	}
 
@@ -390,7 +390,7 @@ func (b *BPF) Start(ifaceName, direction string, chain bool) error {
 	if len(b.Program.UpdateArgs) > 0 {
 		if err := b.UpdateArgs(ifaceName, direction); err != nil {
 			log.Error().Err(err).Msg("failed to update ebpf program config update")
-			return fmt.Errorf("failed to update ebpf program config update %v", err)
+			return fmt.Errorf("failed to update ebpf program config update %w", err)
 		}
 	}
 
@@ -410,7 +410,7 @@ func (b *BPF) Start(ifaceName, direction string, chain bool) error {
 
 		if err != nil {
 			log.Error().Err(err).Msg("failed to fetch ebpf program FD")
-			return fmt.Errorf("failed to fetch ebpf program FD %v", err)
+			return fmt.Errorf("failed to fetch ebpf program FD %w", err)
 		}
 	}
 
@@ -427,7 +427,7 @@ func (b *BPF) Start(ifaceName, direction string, chain bool) error {
 	userProgram, bpfProgram, err := b.isRunning()
 	if !userProgram && !bpfProgram {
 		log.Error().Err(err).Msg("eBPF program failed to start")
-		return fmt.Errorf("bpf program %s failed to start %v", b.Program.Name, err)
+		return fmt.Errorf("bpf program %s failed to start %w", b.Program.Name, err)
 	}
 
 	log.Info().Msgf("BPF program - %s started Program ID %d", b.Program.Name, uint32(b.ProgID))
@@ -468,7 +468,7 @@ func (b *BPF) UpdateArgs(ifaceName, direction string) error {
 	cmd := filepath.Join(b.FilePath, b.Program.CmdUpdate)
 	// Validate
 	if err := assertExecutable(cmd); err != nil {
-		return fmt.Errorf("no executable permissions on %s - error %v", b.Program.CmdUpdate, err)
+		return fmt.Errorf("no executable permissions on %s - error %w", b.Program.CmdUpdate, err)
 	}
 
 	args := make([]string, 0, len(b.Program.UpdateArgs)<<1)
@@ -494,13 +494,14 @@ func (b *BPF) UpdateArgs(ifaceName, direction string) error {
 	UpdateCmd := execCommand(cmd, args...)
 	if err := UpdateCmd.Start(); err != nil {
 		stats.Incr(stats.BPFUpdateFailedCount, b.Program.Name, direction, ifaceName)
-		log.Warn().Err(err).Msgf("user mode BPF program failed - %s", b.Program.Name)
-		return fmt.Errorf("failed to start : %s %v %v", cmd, args, err)
+		customerr := fmt.Errorf("failed to start : %s %v %w", cmd, args, err)
+		log.Warn().Err(customerr).Msgf("user mode BPF program failed - %s", b.Program.Name)
+		return customerr
 	}
 
 	if err := UpdateCmd.Wait(); err != nil {
 		stats.Incr(stats.BPFUpdateFailedCount, b.Program.Name, direction, ifaceName)
-		return fmt.Errorf("cmd wait at starting of bpf program returned with error %v", err)
+		return fmt.Errorf("cmd wait at starting of bpf program returned with error %w", err)
 	}
 
 	stats.Incr(stats.BPFUpdateCount, b.Program.Name, direction, ifaceName)
@@ -586,7 +587,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 	isDefaultURLUsed := false
 	platform, err := GetPlatform()
 	if err != nil {
-		return fmt.Errorf("failed to identify platform type: %v", err)
+		return fmt.Errorf("failed to identify platform type: %w", err)
 	}
 
 	RepoURL := b.Program.EPRURL
@@ -598,9 +599,9 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 	URL, err := url.Parse(RepoURL)
 	if err != nil {
 		if isDefaultURLUsed {
-			return fmt.Errorf("unknown ebpf-repo format : %v", err)
+			return fmt.Errorf("unknown ebpf-repo format : %w", err)
 		} else {
-			return fmt.Errorf("unknown ebpf_package_repo_url format : %v", err)
+			return fmt.Errorf("unknown ebpf_package_repo_url format : %w", err)
 		}
 	}
 
@@ -618,7 +619,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 			// Get the data
 			resp, err := client.Get(URL.String())
 			if err != nil {
-				return fmt.Errorf("download failed: %v", err)
+				return fmt.Errorf("download failed: %w", err)
 			}
 			defer resp.Body.Close()
 
@@ -632,7 +633,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 			if fileExists(URL.Path) {
 				f, err := os.Open(URL.Path)
 				if err != nil {
-					return fmt.Errorf("opening err : %v", err)
+					return fmt.Errorf("opening err : %w", err)
 				}
 				buf.ReadFrom(f)
 				f.Close()
@@ -648,7 +649,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 			c := bytes.NewReader(buf.Bytes())
 			zipReader, err := zip.NewReader(c, int64(c.Len()))
 			if err != nil {
-				return fmt.Errorf("failed to create zip reader: %v", err)
+				return fmt.Errorf("failed to create zip reader: %w", err)
 			}
 			tempDir := filepath.Join(conf.BPFDir, b.Program.Name, b.Program.Version)
 
@@ -656,7 +657,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 
 				zippedFile, err := file.Open()
 				if err != nil {
-					return fmt.Errorf("unzip failed: %v", err)
+					return fmt.Errorf("unzip failed: %w", err)
 				}
 				defer zippedFile.Close()
 
@@ -674,14 +675,14 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 						file.Mode(),
 					)
 					if err != nil {
-						return fmt.Errorf("unzip failed to create file: %v", err)
+						return fmt.Errorf("unzip failed to create file: %w", err)
 					}
 					defer outputFile.Close()
 
 					buf := copyBufPool.Get().(*bytes.Buffer)
 					_, err = io.CopyBuffer(outputFile, zippedFile, buf.Bytes())
 					if err != nil {
-						return fmt.Errorf("GetArtifacts failed to copy files: %v", err)
+						return fmt.Errorf("GetArtifacts failed to copy files: %w", err)
 					}
 					copyBufPool.Put(buf)
 				}
@@ -694,7 +695,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 		{
 			archive, err := gzip.NewReader(buf)
 			if err != nil {
-				return fmt.Errorf("failed to create Gzip reader: %v", err)
+				return fmt.Errorf("failed to create Gzip reader: %w", err)
 			}
 			defer archive.Close()
 			tarReader := tar.NewReader(archive)
@@ -706,7 +707,7 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 				if err == io.EOF {
 					break
 				} else if err != nil {
-					return fmt.Errorf("untar failed: %v", err)
+					return fmt.Errorf("untar failed: %w", err)
 				}
 
 				fPath, err := ValidatePath(header.Name, tempDir)
@@ -717,21 +718,21 @@ func (b *BPF) GetArtifacts(conf *config.Config) error {
 				info := header.FileInfo()
 				if info.IsDir() {
 					if err = os.MkdirAll(fPath, info.Mode()); err != nil {
-						return fmt.Errorf("untar failed to create directories: %v", err)
+						return fmt.Errorf("untar failed to create directories: %w", err)
 					}
 					continue
 				}
 
 				file, err := os.OpenFile(fPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, info.Mode())
 				if err != nil {
-					return fmt.Errorf("untar failed to create file: %v", err)
+					return fmt.Errorf("untar failed to create file: %w", err)
 				}
 				defer file.Close()
 
 				buf := copyBufPool.Get().(*bytes.Buffer)
 				_, err = io.CopyBuffer(file, tarReader, buf.Bytes())
 				if err != nil {
-					return fmt.Errorf("GetArtifacts failed to copy files: %v", err)
+					return fmt.Errorf("GetArtifacts failed to copy files: %w", err)
 				}
 				copyBufPool.Put(buf)
 			}
@@ -754,7 +755,7 @@ func (b *BPF) createUpdateRulesFile(direction string) (string, error) {
 	fileName := path.Join(b.FilePath, direction, b.Program.RulesFile)
 
 	if err := os.WriteFile(fileName, []byte(b.Program.Rules), 0644); err != nil {
-		return "", fmt.Errorf("create or Update Rules File failed with error %v", err)
+		return "", fmt.Errorf("create or Update Rules File failed with error %w", err)
 	}
 
 	return fileName, nil
@@ -794,12 +795,12 @@ func (b *BPF) GetBPFMap(mapName string) (*BPFMap, error) {
 
 	ebpfInfo, err := ebpfMap.Info()
 	if err != nil {
-		return nil, fmt.Errorf("fetching map info failed %v", err)
+		return nil, fmt.Errorf("fetching map info failed %w", err)
 	}
 
 	tempMapID, ok := ebpfInfo.ID()
 	if !ok {
-		return nil, fmt.Errorf("fetching map id failed %v", err)
+		return nil, fmt.Errorf("fetching map id failed %w", err)
 	}
 
 	newBPFMap := BPFMap{
@@ -818,7 +819,7 @@ func (b *BPF) AddMetricsBPFMap(mapName, aggregator string, key, samplesLength in
 	var tmpMetricsBPFMap MetricsBPFMap
 	bpfMap, err := b.GetBPFMap(mapName)
 	if err != nil {
-		return fmt.Errorf("program %s metrics map %s not found : %v", b.Program.Name, mapName, err)
+		return fmt.Errorf("program %s metrics map %s not found : %w", b.Program.Name, mapName, err)
 	}
 
 	tmpMetricsBPFMap.BPFMap = *bpfMap
@@ -841,7 +842,7 @@ func (b *BPF) MonitorMaps(ifaceName string, intervals int) error {
 		_, ok := b.MetricsBpfMaps[mapKey]
 		if !ok {
 			if err := b.AddMetricsBPFMap(element.Name, element.Aggregator, element.Key, intervals); err != nil {
-				return fmt.Errorf("not able to fetch map %s key %d aggregator %s : %v", element.Name, element.Key, element.Aggregator, err)
+				return fmt.Errorf("not able to fetch map %s key %d aggregator %s : %w", element.Name, element.Key, element.Aggregator, err)
 			}
 		}
 		bpfMap := b.MetricsBpfMaps[mapKey]
@@ -861,19 +862,19 @@ func (b *BPF) PutNextProgFDFromID(progID int) error {
 	log.Info().Msgf("PutNextProgFDFromID : Map Name %s ID %d", b.Program.MapName, progID)
 	ebpfMap, err := ebpf.NewMapFromID(b.ProgMapID)
 	if err != nil {
-		return fmt.Errorf("unable to access pinned next prog map %s %v", b.Program.MapName, err)
+		return fmt.Errorf("unable to access pinned next prog map %s %w", b.Program.MapName, err)
 	}
 	defer ebpfMap.Close()
 
 	bpfProg, err := ebpf.NewProgramFromID(ebpf.ProgramID(progID))
 	if err != nil {
-		return fmt.Errorf("failed to get next prog FD from ID for program %s %v", b.Program.Name, err)
+		return fmt.Errorf("failed to get next prog FD from ID for program %s %w", b.Program.Name, err)
 	}
 	key := 0
 	fd := bpfProg.FD()
 	log.Info().Msgf("PutNextProgFDFromID : Map Name %s FD %d", b.Program.MapName, fd)
 	if err = ebpfMap.Update(unsafe.Pointer(&key), unsafe.Pointer(&fd), 0); err != nil {
-		return fmt.Errorf("unable to update prog next map %s %v", b.Program.MapName, err)
+		return fmt.Errorf("unable to update prog next map %s %w", b.Program.MapName, err)
 	}
 	return nil
 }
@@ -884,7 +885,7 @@ func (b *BPF) GetProgID() (ebpf.ProgramID, error) {
 	ebpfMap, err := ebpf.LoadPinnedMap(b.PrevMapNamePath, &ebpf.LoadPinOptions{ReadOnly: true})
 	if err != nil {
 		log.Error().Err(err).Msgf("unable to access pinned prog map %s", b.PrevMapNamePath)
-		return 0, fmt.Errorf("unable to access pinned prog map %s %v", b.PrevMapNamePath, err)
+		return 0, fmt.Errorf("unable to access pinned prog map %s %w", b.PrevMapNamePath, err)
 	}
 	defer ebpfMap.Close()
 	var value ebpf.ProgramID
@@ -892,14 +893,14 @@ func (b *BPF) GetProgID() (ebpf.ProgramID, error) {
 
 	if err = ebpfMap.Lookup(unsafe.Pointer(&key), unsafe.Pointer(&value)); err != nil {
 		log.Warn().Err(err).Msgf("unable to look up prog map %s", b.PrevMapNamePath)
-		return 0, fmt.Errorf("unable to look up prog map %v", err)
+		return 0, fmt.Errorf("unable to look up prog map %w", err)
 	}
 
 	// verify progID before storing in locally.
 	_, err = ebpf.NewProgramFromID(ebpf.ProgramID(value))
 	if err != nil {
 		log.Warn().Err(err).Msgf("failed to verify program ID %s", b.PrevMapNamePath)
-		return 0, fmt.Errorf("failed to verify program ID %s %v", b.Program.Name, err)
+		return 0, fmt.Errorf("failed to verify program ID %s %w", b.Program.Name, err)
 	}
 
 	log.Info().Msgf("GetProgID - Name %s PrevMapName %s ID %d", b.Program.Name, b.PrevMapNamePath, value)
@@ -916,13 +917,13 @@ func (b *BPF) RemoveNextProgFD() error {
 
 	ebpfMap, err := ebpf.NewMapFromID(b.PrevProgMapID)
 	if err != nil {
-		return fmt.Errorf("unable to access pinned next prog map %s %v", b.Program.MapName, err)
+		return fmt.Errorf("unable to access pinned next prog map %s %w", b.Program.MapName, err)
 	}
 	defer ebpfMap.Close()
 	key := 0
 
 	if err := ebpfMap.Delete(unsafe.Pointer(&key)); err != nil {
-		return fmt.Errorf("failed to delete prog fd entry : %v", err)
+		return fmt.Errorf("failed to delete prog fd entry : %w", err)
 	}
 	return nil
 }
@@ -932,7 +933,7 @@ func (b *BPF) RemovePrevProgFD() error {
 
 	ebpfMap, err := ebpf.NewMapFromID(b.PrevProgMapID)
 	if err != nil {
-		return fmt.Errorf("unable to access pinned prev prog map %s %v", b.PrevMapNamePath, err)
+		return fmt.Errorf("unable to access pinned prev prog map %s %w", b.PrevMapNamePath, err)
 	}
 	defer ebpfMap.Close()
 	key := 0
@@ -973,10 +974,10 @@ func (b *BPF) VerifyPinnedProgMap(chain, exists bool) error {
 		}
 
 		if err != nil && exists {
-			err = fmt.Errorf("VerifyPinnedProgMap creation : failed to find pinned file %s err %v", b.MapNamePath, err)
+			err = fmt.Errorf("VerifyPinnedProgMap creation : failed to find pinned file %s err %w", b.MapNamePath, err)
 			log.Error().Err(err).Msg("")
 		} else if err != nil {
-			err = fmt.Errorf("VerifyPinnedProgMap removal : %s map file was never removed by BPF program %s err %v", b.MapNamePath, b.Program.Name, err)
+			err = fmt.Errorf("VerifyPinnedProgMap removal : %s map file was never removed by BPF program %s err %w", b.MapNamePath, b.Program.Name, err)
 			log.Error().Err(err).Msg("")
 		}
 		return err
@@ -1048,7 +1049,7 @@ func (b *BPF) LoadXDPAttachProgram(ifaceName string) error {
 		Interface: iface.Index,
 	})
 	if err != nil {
-		return fmt.Errorf("could not attach xdp program %s to interface %s : %v", b.Program.Name, ifaceName, err)
+		return fmt.Errorf("could not attach xdp program %s to interface %s : %w", b.Program.Name, ifaceName, err)
 	}
 
 	if b.hostConfig.BpfChainingEnabled {
@@ -1105,7 +1106,7 @@ func (b *BPF) RemoveMapFiles(ifaceName string) error {
 			mapFilename = filepath.Join(b.hostConfig.BpfMapDefaultPath, ifaceName, k)
 		}
 		if err := v.Unpin(); err != nil {
-			return fmt.Errorf("BPF program %s prog type %s ifacename %s map %s:failed to pin the map err - %#v",
+			return fmt.Errorf("BPF program %s prog type %s ifacename %s map %s:failed to pin the map err - %w",
 				b.Program.Name, b.Program.ProgType, ifaceName, mapFilename, err)
 		}
 	}
@@ -1134,7 +1135,7 @@ func (b *BPF) RemoveRootProgMapFile(ifacename string) error {
 	if err := os.Remove(mapFilename); err != nil {
 		if !os.IsNotExist(err) {
 			log.Warn().Msgf("RemoveRootProgMapFile: %s program type %s map file remove unsuccessfully - %s err - %#v", b.Program.ProgType, b.Program.Name, mapFilename, err)
-			return fmt.Errorf("%s - remove failed with error %#v", mapFilename, err)
+			return fmt.Errorf("%s - remove failed with error %w", mapFilename, err)
 		}
 	}
 	return nil
@@ -1145,13 +1146,13 @@ func (b *BPF) VerifyCleanupMaps(chain bool) error {
 	// verify pinned map file is removed.
 	if err := b.VerifyPinnedProgMap(chain, false); err != nil {
 		log.Error().Err(err).Msgf("stop user program - failed to remove pinned file %s", b.Program.Name)
-		return fmt.Errorf("stop user program - failed to remove pinned file %s : %v", b.Program.Name, err)
+		return fmt.Errorf("stop user program - failed to remove pinned file %s : %w", b.Program.Name, err)
 	}
 
 	// Verify all metrics map references are removed from kernel
 	if err := b.VerifyMetricsMapsVanish(); err != nil {
 		log.Error().Err(err).Msgf("stop user program - failed to remove metric map references %s", b.Program.Name)
-		return fmt.Errorf("stop user program - failed to remove metric map references %s : %v", b.Program.Name, err)
+		return fmt.Errorf("stop user program - failed to remove metric map references %s : %w", b.Program.Name, err)
 	}
 
 	return nil
@@ -1178,12 +1179,12 @@ func (b *BPF) LoadBPFProgram(ifaceName string) error {
 	// Allow the current process to lock memory for eBPF resources.
 	if err := rlimit.RemoveMemlock(); err != nil {
 		log.Error().Msgf("failed to remove memory lock limits  %#v", err)
-		return fmt.Errorf("%s: remove rlimit lock failed : %#v", b.Program.Name, err)
+		return fmt.Errorf("%s: remove rlimit lock failed : %w", b.Program.Name, err)
 	}
 
 	objSpec, err := ebpf.LoadCollectionSpec(ObjectFile)
 	if err != nil {
-		return fmt.Errorf("%s: loading collection spec failed - %#v", ObjectFile, err)
+		return fmt.Errorf("%s: loading collection spec failed - %w", ObjectFile, err)
 	}
 
 	if err := b.CreateMapPinDirectory(ifaceName); err != nil {
@@ -1205,7 +1206,7 @@ func (b *BPF) LoadBPFProgram(ifaceName string) error {
 	// Load the BPF program with the updated map options
 	prg, err := ebpf.NewCollectionWithOptions(objSpec, collOptions)
 	if err != nil {
-		return fmt.Errorf("%s: loading of bpf program failed - %#v", b.Program.Name, err)
+		return fmt.Errorf("%s: loading of bpf program failed - %w", b.Program.Name, err)
 	}
 
 	// Persist program handle
@@ -1218,7 +1219,7 @@ func (b *BPF) LoadBPFProgram(ifaceName string) error {
 
 	progInfo, err := bpfProg.Info()
 	if err != nil {
-		return fmt.Errorf("%s: information of bpf program failed : %v", b.Program.Name, err)
+		return fmt.Errorf("%s: information of bpf program failed : %w", b.Program.Name, err)
 	}
 
 	ok := false
@@ -1229,7 +1230,7 @@ func (b *BPF) LoadBPFProgram(ifaceName string) error {
 
 	// Initialise metric maps
 	if err := b.InitialiseMetricMaps(); err != nil {
-		return fmt.Errorf("initialising metric maps failed %#v", err)
+		return fmt.Errorf("initialising metric maps failed %w", err)
 	}
 
 	if err := b.PinBpfMaps(ifaceName); err != nil {
@@ -1353,7 +1354,7 @@ func (b *BPF) StartUserProgram(ifaceName, direction string, chain bool) error {
 	cmd := filepath.Join(b.FilePath, b.Program.CmdStart)
 	// Validate
 	if err := assertExecutable(cmd); err != nil {
-		return fmt.Errorf("no executable permissions on %s - error %v", b.Program.CmdStart, err)
+		return fmt.Errorf("no executable permissions on %s - error %w", b.Program.CmdStart, err)
 	}
 
 	args := make([]string, 0, len(b.Program.StartArgs)<<1)
@@ -1392,7 +1393,7 @@ func (b *BPF) StartUserProgram(ifaceName, direction string, chain bool) error {
 	b.Cmd = execCommand(cmd, args...)
 	if err := b.Cmd.Start(); err != nil {
 		log.Info().Err(err).Msgf("user program failed - %s", b.Program.Name)
-		return fmt.Errorf("failed to start : %s %v with err: %v", cmd, args, err)
+		return fmt.Errorf("failed to start : %s %v with err: %w", cmd, args, err)
 	}
 	if !b.Program.UserProgramDaemon {
 		log.Info().Msgf("no user program - %s No Pid", b.Program.Name)
@@ -1425,7 +1426,7 @@ func (b *BPF) CreateMapPinDirectory(ifaceName string) error {
 		return fmt.Errorf("%s contains relative path is not supported - %s", mapPathDir, b.Program.Name)
 	}
 	if err := os.MkdirAll(mapPathDir, 0750); err != nil {
-		return fmt.Errorf("%s failed to create map dir path of %s program %s with err : %v", mapPathDir, b.Program.ProgType, b.Program.Name, err)
+		return fmt.Errorf("%s failed to create map dir path of %s program %s with err : %w", mapPathDir, b.Program.ProgType, b.Program.Name, err)
 	}
 	return nil
 }
@@ -1434,11 +1435,11 @@ func (b *BPF) CreateMapPinDirectory(ifaceName string) error {
 func (b *BPF) AttachBPFProgram(ifaceName, direction string) error {
 	if b.Program.ProgType == models.XDPType {
 		if err := b.LoadXDPAttachProgram(ifaceName); err != nil {
-			return fmt.Errorf("failed to attach xdp program %s to inferface %s with err: %v", b.Program.Name, ifaceName, err)
+			return fmt.Errorf("failed to attach xdp program %s to inferface %s with err: %w", b.Program.Name, ifaceName, err)
 		}
 	} else if b.Program.ProgType == models.TCType {
 		if err := b.LoadTCAttachProgram(ifaceName, direction); err != nil {
-			return fmt.Errorf("failed to attach tc program %s to inferface %s direction %s with err: %v", b.Program.Name, ifaceName, direction, err)
+			return fmt.Errorf("failed to attach tc program %s to inferface %s direction %s with err: %w", b.Program.Name, ifaceName, direction, err)
 		}
 	}
 	return nil
@@ -1461,7 +1462,7 @@ func (b *BPF) PinBpfMaps(ifaceName string) error {
 		// In case one of the program pins the map then other program will skip
 		if !fileExists(mapFilename) {
 			if err := v.Pin(mapFilename); err != nil {
-				return fmt.Errorf("eBPF program %s map %s:failed to pin the map err - %#v", b.Program.Name, mapFilename, err)
+				return fmt.Errorf("eBPF program %s map %s:failed to pin the map err - %w", b.Program.Name, mapFilename, err)
 			}
 		}
 	}
@@ -1479,13 +1480,13 @@ func (b *BPF) UpdateProgramMap(ifaceName string) error {
 
 	ebpfInfo, err := bpfRootMap.Info()
 	if err != nil {
-		return fmt.Errorf("fetching map info failed for %s program %s to interface %s : %v", b.Program.ProgType, b.Program.Name, ifaceName, err)
+		return fmt.Errorf("fetching map info failed for %s program %s to interface %s : %w", b.Program.ProgType, b.Program.Name, ifaceName, err)
 	}
 
 	var ok bool
 	b.ProgMapID, ok = ebpfInfo.ID()
 	if !ok {
-		return fmt.Errorf("fetching map id failed for %s program %s to interface %s : %v", b.Program.ProgType, b.Program.Name, ifaceName, err)
+		return fmt.Errorf("fetching map id failed for %s program %s to interface %s : %w", b.Program.ProgType, b.Program.Name, ifaceName, err)
 	}
 
 	return nil
@@ -1506,7 +1507,7 @@ func (b *BPF) LoadBPFProgramChain(ifaceName, direction string) error {
 	// Link this program into previous program map
 	ebpfMap, err := ebpf.NewMapFromID(b.PrevProgMapID)
 	if err != nil {
-		return fmt.Errorf("unable to access pinned previous prog map %s %v", b.PrevMapNamePath, err)
+		return fmt.Errorf("unable to access pinned previous prog map %s %w", b.PrevMapNamePath, err)
 	}
 	defer ebpfMap.Close()
 
diff --git a/kf/bpfmap.go b/kf/bpfmap.go
index c7ba1120..74ce084a 100644
--- a/kf/bpfmap.go
+++ b/kf/bpfmap.go
@@ -56,7 +56,7 @@ func (b *BPFMap) Update(value string) error {
 	log.Debug().Msgf("update map name %s ID %d", b.Name, b.MapID)
 	ebpfMap, err := ebpf.NewMapFromID(b.MapID)
 	if err != nil {
-		return fmt.Errorf("access new map from ID failed %v", err)
+		return fmt.Errorf("access new map from ID failed %w", err)
 	}
 	defer ebpfMap.Close()
 
@@ -80,7 +80,7 @@ func (b *BPFMap) Update(value string) error {
 			x := 1
 			log.Info().Msgf("updating map %s key %d mapid %d", b.Name, v, b.MapID)
 			if err := ebpfMap.Update(unsafe.Pointer(&v), unsafe.Pointer(&x), 0); err != nil {
-				return fmt.Errorf("update hash map element failed for key %d error %v", key, err)
+				return fmt.Errorf("update hash map element failed for key %d error %w", key, err)
 			}
 		}
 	} else if b.Type == ebpf.Array {
@@ -88,7 +88,7 @@ func (b *BPFMap) Update(value string) error {
 			v, _ := strconv.ParseInt(val, 10, 64)
 			log.Info().Msgf("updating map %s key %d mapid %d", b.Name, v, b.MapID)
 			if err := ebpfMap.Update(unsafe.Pointer(&key), unsafe.Pointer(&v), 0); err != nil {
-				return fmt.Errorf("update array map index %d %v", key, err)
+				return fmt.Errorf("update array map index %d %w", key, err)
 			}
 		}
 	} else {
diff --git a/kf/kf_unix.go b/kf/kf_unix.go
index 91e7b8c4..729e4665 100644
--- a/kf/kf_unix.go
+++ b/kf/kf_unix.go
@@ -33,7 +33,7 @@ import (
 func DisableLRO(ifaceName string) error {
 	ethHandle, err := ethtool.NewEthtool()
 	if err != nil {
-		err = fmt.Errorf("ethtool failed to get the handle %v", err)
+		err = fmt.Errorf("ethtool failed to get the handle %w", err)
 		log.Error().Err(err).Msg("")
 		return err
 	}
@@ -42,7 +42,7 @@ func DisableLRO(ifaceName string) error {
 	config := make(map[string]bool, 1)
 	config["rx-lro"] = false
 	if err := ethHandle.Change(ifaceName, config); err != nil {
-		err = fmt.Errorf("ethtool failed to disable LRO on %s with err %v", ifaceName, err)
+		err = fmt.Errorf("ethtool failed to disable LRO on %s with err %w", ifaceName, err)
 		log.Error().Err(err).Msg("")
 		return err
 	}
@@ -97,7 +97,7 @@ func (b *BPF) SetPrLimits() error {
 // ProcessTerminate - Send sigterm to the process
 func (b *BPF) ProcessTerminate() error {
 	if err := b.Cmd.Process.Signal(syscall.SIGTERM); err != nil {
-		return fmt.Errorf("BPFProgram %s SIGTERM failed with error: %v", b.Program.Name, err)
+		return fmt.Errorf("BPFProgram %s SIGTERM failed with error: %w", b.Program.Name, err)
 	}
 	return nil
 }
@@ -111,13 +111,13 @@ func VerifyNMountBPFFS() error {
 
 	mnts, err := os.ReadFile("/proc/mounts")
 	if err != nil {
-		return fmt.Errorf("failed to read procfs: %v", err)
+		return fmt.Errorf("failed to read procfs: %w", err)
 	}
 
 	if !strings.Contains(string(mnts), dstPath) {
 		log.Warn().Msg("bpf filesystem is not mounted going to mount")
 		if err = syscall.Mount(srcPath, dstPath, fstype, uintptr(flags), ""); err != nil {
-			return fmt.Errorf("unable to mount %s at %s: %s", srcPath, dstPath, err)
+			return fmt.Errorf("unable to mount %s at %s: %w", srcPath, dstPath, err)
 		}
 	}
 
@@ -133,7 +133,7 @@ func VerifyNMountTraceFS() error {
 
 	mnts, err := os.ReadFile("/proc/self/mounts")
 	if err != nil {
-		return fmt.Errorf("failed to read procfs: %v", err)
+		return fmt.Errorf("failed to read procfs: %w", err)
 	}
 
 	if !strings.Contains(string(mnts), dstPath) {
@@ -141,11 +141,11 @@ func VerifyNMountTraceFS() error {
 		if _, err = os.Stat(dstPath); err != nil {
 			log.Warn().Msgf(" %s directory doesn't exists, creating", dstPath)
 			if err := os.Mkdir(dstPath, 0700); err != nil {
-				return fmt.Errorf("unable to create mount point %s : %s", dstPath, err)
+				return fmt.Errorf("unable to create mount point %s : %w", dstPath, err)
 			}
 		}
 		if err = syscall.Mount(srcPath, dstPath, fstype, uintptr(flags), ""); err != nil {
-			return fmt.Errorf("unable to mount %s at %s: %s", srcPath, dstPath, err)
+			return fmt.Errorf("unable to mount %s at %s: %w", srcPath, dstPath, err)
 		}
 	}
 
@@ -162,7 +162,7 @@ func GetPlatform() (string, error) {
 	linuxDistrib.Stdout = &out
 
 	if err := linuxDistrib.Run(); err != nil {
-		return "", fmt.Errorf("l3afd/nf : Failed to run command with error: %v", err)
+		return "", fmt.Errorf("l3afd/nf : Failed to run command with error: %w", err)
 	}
 
 	return strings.TrimSpace(out.String()), nil
@@ -171,12 +171,12 @@ func GetPlatform() (string, error) {
 func IsProcessRunning(pid int, name string) (bool, error) {
 	procState, err := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid))
 	if err != nil {
-		return false, fmt.Errorf("BPF Program not running %s because of error: %v", name, err)
+		return false, fmt.Errorf("BPF Program not running %s because of error: %w", name, err)
 	}
 	var u1, u2, state string
 	_, err = fmt.Sscanf(string(procState), "%s %s %s", &u1, &u2, &state)
 	if err != nil {
-		return false, fmt.Errorf("failed to scan proc state with error: %v", err)
+		return false, fmt.Errorf("failed to scan proc state with error: %w", err)
 	}
 	if state == "Z" {
 		return false, fmt.Errorf("process %d in Zombie state", pid)
@@ -195,7 +195,7 @@ func VerifyNCreateTCDirs() error {
 	log.Info().Msgf(" %s tc directory doesn't exists, creating", path)
 	err := os.MkdirAll(path, 0700)
 	if err != nil {
-		return fmt.Errorf("unable to create directories to pin tc maps %s : %s", path, err)
+		return fmt.Errorf("unable to create directories to pin tc maps %s : %w", path, err)
 	}
 	return nil
 }
@@ -215,19 +215,19 @@ func (b *BPF) LoadTCAttachProgram(ifaceName, direction string) error {
 	// verify and add attribute clsact
 	tcgo, err := tc.Open(&tc.Config{})
 	if err != nil {
-		return fmt.Errorf("could not open rtnetlink socket for interface %s : %v", ifaceName, err)
+		return fmt.Errorf("could not open rtnetlink socket for interface %s : %w", ifaceName, err)
 	}
 
 	clsactFound := false
 	// get all the qdiscs from all interfaces
 	qdiscs, err := tcgo.Qdisc().Get()
 	if err != nil {
-		return fmt.Errorf("could not get qdiscs for interface %s : %v", ifaceName, err)
+		return fmt.Errorf("could not get qdiscs for interface %s : %w", ifaceName, err)
 	}
 	for _, qdisc := range qdiscs {
 		iface, err := net.InterfaceByIndex(int(qdisc.Ifindex))
 		if err != nil {
-			return fmt.Errorf("could not get interface %s from id %d: %v", ifaceName, qdisc.Ifindex, err)
+			return fmt.Errorf("could not get interface %s from id %d: %w", ifaceName, qdisc.Ifindex, err)
 		}
 		if iface.Name == ifaceName && qdisc.Kind == "clsact" {
 			clsactFound = true
@@ -288,7 +288,7 @@ func (b *BPF) LoadTCAttachProgram(ifaceName, direction string) error {
 
 	// Attaching / Adding as filter
 	if err := b.TCFilter.Add(&filter); err != nil {
-		return fmt.Errorf("could not attach filter to interface %s for eBPF program %s : %v", ifaceName, b.Program.Name, err)
+		return fmt.Errorf("could not attach filter to interface %s for eBPF program %s : %w", ifaceName, b.Program.Name, err)
 	}
 
 	if b.hostConfig.BpfChainingEnabled {
@@ -326,7 +326,7 @@ func (b *BPF) UnloadTCProgram(ifaceName, direction string) error {
 
 	if err != nil {
 		log.Warn().Msgf("Could not get filters for interface \"%s\" direction %s ", ifaceName, direction)
-		return fmt.Errorf("could not get filters for interface %s : %v", ifaceName, err)
+		return fmt.Errorf("could not get filters for interface %s : %w", ifaceName, err)
 	}
 
 	progFD := uint32(bpfRootProg.FD())
@@ -352,7 +352,7 @@ func (b *BPF) UnloadTCProgram(ifaceName, direction string) error {
 
 	// Detaching / Deleting filter
 	if err := b.TCFilter.Delete(&filter); err != nil {
-		return fmt.Errorf("could not dettach tc filter for interface %s : %v", ifaceName, err)
+		return fmt.Errorf("could not dettach tc filter for interface %s : %w", ifaceName, err)
 	}
 
 	return nil
diff --git a/kf/kf_windows.go b/kf/kf_windows.go
index ff1a080c..a7d2f708 100644
--- a/kf/kf_windows.go
+++ b/kf/kf_windows.go
@@ -38,7 +38,7 @@ func GetPlatform() (string, error) {
 func IsProcessRunning(pid int, name string) (bool, error) {
 	_, err := os.FindProcess(pid)
 	if err != nil {
-		return false, fmt.Errorf("BPF Program not running %s because of error: %s", name, err)
+		return false, fmt.Errorf("BPF Program not running %s because of error: %w", name, err)
 	}
 	return true, nil
 }
@@ -46,7 +46,7 @@ func IsProcessRunning(pid int, name string) (bool, error) {
 // ProcessTerminate - Kills the process
 func (b *BPF) ProcessTerminate() error {
 	if err := b.Cmd.Process.Kill(); err != nil {
-		return fmt.Errorf("BPFProgram %s kill failed with error: %v", b.Program.Name, err)
+		return fmt.Errorf("BPFProgram %s kill failed with error: %w", b.Program.Name, err)
 	}
 	return nil
 }
diff --git a/kf/nfconfig.go b/kf/nfconfig.go
index 3b1bde20..2f828fb6 100644
--- a/kf/nfconfig.go
+++ b/kf/nfconfig.go
@@ -58,7 +58,7 @@ func NewNFConfigs(ctx context.Context, host string, hostConf *config.Config, pMo
 
 	var err error
 	if nfConfigs.hostInterfaces, err = getHostInterfaces(); err != nil {
-		errOut := fmt.Errorf("%s failed to get network interfaces %v", host, err)
+		errOut := fmt.Errorf("%s failed to get network interfaces %w", host, err)
 		log.Error().Err(errOut)
 		return nil, errOut
 	}
@@ -134,10 +134,10 @@ func (c *NFConfigs) Close(ctx context.Context) error {
 func (c *NFConfigs) VerifyAndStartXDPRootProgram(ifaceName, direction string) error {
 
 	if err := DisableLRO(ifaceName); err != nil {
-		return fmt.Errorf("failed to disable lro %v", err)
+		return fmt.Errorf("failed to disable lro %w", err)
 	}
 	if err := VerifyNMountBPFFS(); err != nil {
-		return fmt.Errorf("failed to mount bpf file system with err %v", err)
+		return fmt.Errorf("failed to mount bpf file system with err %w", err)
 	}
 
 	// chaining is disabled nothing to do
@@ -148,7 +148,7 @@ func (c *NFConfigs) VerifyAndStartXDPRootProgram(ifaceName, direction string) er
 	if c.IngressXDPBpfs[ifaceName].Len() == 0 {
 		rootBpf, err := LoadRootProgram(ifaceName, direction, models.XDPType, c.HostConfig)
 		if err != nil {
-			return fmt.Errorf("failed to load %s xdp root program: %v", direction, err)
+			return fmt.Errorf("failed to load %s xdp root program: %w", direction, err)
 		}
 		log.Info().Msg("ingress xdp root program attached")
 		c.IngressXDPBpfs[ifaceName].PushFront(rootBpf)
@@ -161,10 +161,10 @@ func (c *NFConfigs) VerifyAndStartXDPRootProgram(ifaceName, direction string) er
 func (c *NFConfigs) VerifyAndStartTCRootProgram(ifaceName, direction string) error {
 
 	if err := VerifyNMountBPFFS(); err != nil {
-		return fmt.Errorf("failed to mount bpf file system with err : %v", err)
+		return fmt.Errorf("failed to mount bpf file system with err : %w", err)
 	}
 	if err := VerifyNCreateTCDirs(); err != nil {
-		return fmt.Errorf("failed to create tc/global diretories with err: %v", err)
+		return fmt.Errorf("failed to create tc/global diretories with err: %w", err)
 	}
 	// Check for chaining flag
 	if !c.HostConfig.BpfChainingEnabled {
@@ -175,7 +175,7 @@ func (c *NFConfigs) VerifyAndStartTCRootProgram(ifaceName, direction string) err
 		if c.IngressTCBpfs[ifaceName].Len() == 0 { //Root program is not running start then
 			rootBpf, err := LoadRootProgram(ifaceName, direction, models.TCType, c.HostConfig)
 			if err != nil {
-				return fmt.Errorf("failed to load %s tc root program: %v", direction, err)
+				return fmt.Errorf("failed to load %s tc root program: %w", direction, err)
 			}
 			log.Info().Msg("ingress tc root program attached")
 			c.IngressTCBpfs[ifaceName].PushFront(rootBpf)
@@ -184,7 +184,7 @@ func (c *NFConfigs) VerifyAndStartTCRootProgram(ifaceName, direction string) err
 		if c.EgressTCBpfs[ifaceName].Len() == 0 { //Root program is not running start then
 			rootBpf, err := LoadRootProgram(ifaceName, direction, models.TCType, c.HostConfig)
 			if err != nil {
-				return fmt.Errorf("failed to load %s tc root program: %v", direction, err)
+				return fmt.Errorf("failed to load %s tc root program: %w", direction, err)
 			}
 			log.Info().Msg("egress tc root program attached")
 			c.EgressTCBpfs[ifaceName].PushFront(rootBpf)
@@ -213,7 +213,7 @@ func (c *NFConfigs) PushBackAndStartBPF(bpfProg *models.BPFProgram, ifaceName, d
 	}
 
 	if err := c.DownloadAndStartBPFProgram(bpfList.PushBack(bpf), ifaceName, direction); err != nil {
-		return fmt.Errorf("failed to download and start the BPF %s iface %s direction %s with err: %v", bpfProg.Name, ifaceName, direction, err)
+		return fmt.Errorf("failed to download and start the BPF %s iface %s direction %s with err: %w", bpfProg.Name, ifaceName, direction, err)
 	}
 
 	return nil
@@ -234,11 +234,11 @@ func (c *NFConfigs) DownloadAndStartBPFProgram(element *list.Element, ifaceName,
 	}
 
 	if err := bpf.VerifyAndGetArtifacts(c.HostConfig); err != nil {
-		return fmt.Errorf("failed to get artifacts %s with error: %v", bpf.Program.Artifact, err)
+		return fmt.Errorf("failed to get artifacts %s with error: %w", bpf.Program.Artifact, err)
 	}
 
 	if err := bpf.Start(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-		return fmt.Errorf("failed to start bpf program %s with error: %v", bpf.Program.Name, err)
+		return fmt.Errorf("failed to start bpf program %s with error: %w", bpf.Program.Name, err)
 	}
 
 	return nil
@@ -271,7 +271,7 @@ func (c *NFConfigs) StopNRemoveAllBPFPrograms(ifaceName, direction string) error
 	for e := bpfList.Front(); e != nil; {
 		data := e.Value.(*BPF)
 		if err := data.Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-			return fmt.Errorf("failed to stop program %s direction %s with err :%v", data.Program.Name, direction, err)
+			return fmt.Errorf("failed to stop program %s direction %s with err :%w", data.Program.Name, direction, err)
 		}
 		nextBPF := e.Next()
 		bpfList.Remove(e)
@@ -323,7 +323,7 @@ func (c *NFConfigs) VerifyNUpdateBPFProgram(bpfProg *models.BPFProgram, ifaceNam
 			log.Info().Msgf("verifyNUpdateBPFProgram :admin_status change detected - disabling the program %s", data.Program.Name)
 			data.Program.AdminStatus = bpfProg.AdminStatus
 			if err := data.Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-				return fmt.Errorf("failed to stop to on admin_status change BPF %s iface %s direction %s admin_status %s with err %v", bpfProg.Name, ifaceName, direction, bpfProg.AdminStatus, err)
+				return fmt.Errorf("failed to stop to on admin_status change BPF %s iface %s direction %s admin_status %s with err %w", bpfProg.Name, ifaceName, direction, bpfProg.AdminStatus, err)
 			}
 			tmpNextBPF := e.Next()
 			tmpPreviousBPF := e.Prev()
@@ -331,7 +331,7 @@ func (c *NFConfigs) VerifyNUpdateBPFProgram(bpfProg *models.BPFProgram, ifaceNam
 			if tmpNextBPF != nil && tmpNextBPF.Prev() != nil { // relink the next element
 				if err := c.LinkBPFPrograms(tmpNextBPF.Prev().Value.(*BPF), tmpNextBPF.Value.(*BPF)); err != nil {
 					log.Error().Err(err).Msg("admin status disabled - failed LinkBPFPrograms")
-					return fmt.Errorf("admin status disabled - failed LinkBPFPrograms %v", err)
+					return fmt.Errorf("admin status disabled - failed LinkBPFPrograms %w", err)
 				}
 			}
 
@@ -355,7 +355,7 @@ func (c *NFConfigs) VerifyNUpdateBPFProgram(bpfProg *models.BPFProgram, ifaceNam
 				log.Info().Msg("no eBPF Programs are running, stopping root program")
 				if c.HostConfig.BpfChainingEnabled {
 					if err := c.StopRootProgram(ifaceName, direction); err != nil {
-						return fmt.Errorf("failed to stop to root program  %s iface %s direction %s with err: %v", bpfProg.Name, ifaceName, direction, err)
+						return fmt.Errorf("failed to stop to root program  %s iface %s direction %s with err: %w", bpfProg.Name, ifaceName, direction, err)
 					}
 				}
 			}
@@ -367,13 +367,13 @@ func (c *NFConfigs) VerifyNUpdateBPFProgram(bpfProg *models.BPFProgram, ifaceNam
 			log.Info().Msgf("VerifyNUpdateBPFProgram : version update initiated - current version %s new version %s", data.Program.Version, bpfProg.Version)
 
 			if err := data.Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-				return fmt.Errorf("failed to stop older version of network function BPF %s iface %s direction %s version %s with err: %v", bpfProg.Name, ifaceName, direction, bpfProg.Version, err)
+				return fmt.Errorf("failed to stop older version of network function BPF %s iface %s direction %s version %s with err: %w", bpfProg.Name, ifaceName, direction, bpfProg.Version, err)
 			}
 
 			data.Program = *bpfProg
 
 			if err := c.DownloadAndStartBPFProgram(e, ifaceName, direction); err != nil {
-				return fmt.Errorf("failed to download and start newer version of network function BPF %s version %s iface %s direction %s with err: %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+				return fmt.Errorf("failed to download and start newer version of network function BPF %s version %s iface %s direction %s with err: %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 			}
 
 			// update if not a last program
@@ -401,7 +401,7 @@ func (c *NFConfigs) VerifyNUpdateBPFProgram(bpfProg *models.BPFProgram, ifaceNam
 			data.Program.SeqID = bpfProg.SeqID
 
 			if err := c.MoveToLocation(e, bpfList); err != nil {
-				return fmt.Errorf("failed to move to new position in the chain BPF %s version %s iface %s direction %s with err: %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+				return fmt.Errorf("failed to move to new position in the chain BPF %s version %s iface %s direction %s with err: %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 			}
 		}
 
@@ -425,7 +425,7 @@ func (c *NFConfigs) VerifyNUpdateBPFProgram(bpfProg *models.BPFProgram, ifaceNam
 	log.Debug().Msgf("Program is not found in the list name %s", bpfProg.Name)
 	// if not found in the list.
 	if err := c.InsertAndStartBPFProgram(bpfProg, ifaceName, direction); err != nil {
-		return fmt.Errorf("failed to insert and start BPFProgram to new location BPF %s version %s iface %s direction %s with err: %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+		return fmt.Errorf("failed to insert and start BPFProgram to new location BPF %s version %s iface %s direction %s with err: %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 	}
 
 	return nil
@@ -450,12 +450,12 @@ func (c *NFConfigs) MoveToLocation(element *list.Element, bpfList *list.List) er
 			if element.Next() != nil && element.Prev() != nil {
 				if err := c.LinkBPFPrograms(element.Prev().Value.(*BPF), element.Next().Value.(*BPF)); err != nil {
 					log.Error().Err(err).Msg("MoveToLocation - failed LinkBPFPrograms before move")
-					return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms before move %v", err)
+					return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms before move %w", err)
 				}
 			} else if element.Next() == nil && element.Prev() != nil {
 				if err := element.Prev().Value.(*BPF).RemoveNextProgFD(); err != nil {
 					log.Error().Err(err).Msg("failed to remove program fd in map")
-					return fmt.Errorf("failed to remove program fd in map %v", err)
+					return fmt.Errorf("failed to remove program fd in map %w", err)
 				}
 			}
 
@@ -463,13 +463,13 @@ func (c *NFConfigs) MoveToLocation(element *list.Element, bpfList *list.List) er
 
 			if err := c.LinkBPFPrograms(element.Prev().Value.(*BPF), element.Value.(*BPF)); err != nil {
 				log.Error().Err(err).Msg("MoveToLocation - failed LinkBPFPrograms after move element to with prev prog")
-				return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms after move element to with prev prog %v", err)
+				return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms after move element to with prev prog %w", err)
 			}
 
 			if element.Next() != nil {
 				if err := c.LinkBPFPrograms(element.Value.(*BPF), element.Next().Value.(*BPF)); err != nil {
 					log.Error().Err(err).Msg("MoveToLocation - failed LinkBPFPrograms after move element to with next prog")
-					return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms after move element to with next prog %v", err)
+					return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms after move element to with next prog %w", err)
 				}
 			}
 			log.Info().Msgf("MoveToLocation : Moved - %s", element.Value.(*BPF).Program.Name)
@@ -481,7 +481,7 @@ func (c *NFConfigs) MoveToLocation(element *list.Element, bpfList *list.List) er
 	if element.Next() != nil && element.Prev() != nil {
 		if err := c.LinkBPFPrograms(element.Prev().Value.(*BPF), element.Next().Value.(*BPF)); err != nil {
 			log.Error().Err(err).Msg("MoveToLocation - failed LinkBPFPrograms before MoveToBack element to with prev prog")
-			return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms before MoveToBack element to with prev prog %v", err)
+			return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms before MoveToBack element to with prev prog %w", err)
 		}
 	}
 
@@ -489,14 +489,14 @@ func (c *NFConfigs) MoveToLocation(element *list.Element, bpfList *list.List) er
 	if element.Prev() != nil {
 		if err := c.LinkBPFPrograms(element.Prev().Value.(*BPF), element.Value.(*BPF)); err != nil {
 			log.Error().Err(err).Msg("MoveToLocation - failed LinkBPFPrograms after MoveToBack element to with prev prog")
-			return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms after MoveToBack element to with prev prog %v", err)
+			return fmt.Errorf("MoveToLocation - failed LinkBPFPrograms after MoveToBack element to with prev prog %w", err)
 		}
 	}
 
 	if element.Next() == nil {
 		if err := element.Value.(*BPF).RemoveNextProgFD(); err != nil {
 			log.Error().Err(err).Msg("failed to remove MoveToBack program fd in map")
-			return fmt.Errorf("failed to remove MoveToBack program fd in map %v", err)
+			return fmt.Errorf("failed to remove MoveToBack program fd in map %w", err)
 		}
 	}
 
@@ -539,13 +539,13 @@ func (c *NFConfigs) InsertAndStartBPFProgram(bpfProg *models.BPFProgram, ifaceNa
 		if data.Program.SeqID >= bpfProg.SeqID {
 			tmpBPF := bpfList.InsertBefore(bpf, e)
 			if err := c.DownloadAndStartBPFProgram(tmpBPF, ifaceName, direction); err != nil {
-				return fmt.Errorf("failed to download and start network function %s version %s iface %s direction %s with err %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+				return fmt.Errorf("failed to download and start network function %s version %s iface %s direction %s with err %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 			}
 
 			if tmpBPF.Next() != nil {
 				if err := c.LinkBPFPrograms(tmpBPF.Value.(*BPF), tmpBPF.Next().Value.(*BPF)); err != nil {
 					log.Error().Err(err).Msg("InsertAndStartBPFProgram - failed LinkBPFPrograms after InsertBefore element to with next prog")
-					return fmt.Errorf("InsertAndStartBPFProgram - failed LinkBPFPrograms after InsertBefore element to with next prog %v", err)
+					return fmt.Errorf("InsertAndStartBPFProgram - failed LinkBPFPrograms after InsertBefore element to with next prog %w", err)
 				}
 			}
 			return nil
@@ -554,7 +554,7 @@ func (c *NFConfigs) InsertAndStartBPFProgram(bpfProg *models.BPFProgram, ifaceNa
 
 	// insert at the end
 	if err := c.PushBackAndStartBPF(bpfProg, ifaceName, direction); err != nil {
-		return fmt.Errorf("failed to push back and start network function %s version %s iface %s direction %s with err: %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+		return fmt.Errorf("failed to push back and start network function %s version %s iface %s direction %s with err: %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 	}
 
 	return nil
@@ -571,7 +571,7 @@ func (c *NFConfigs) StopRootProgram(ifaceName, direction string) error {
 		}
 
 		if err := c.IngressXDPBpfs[ifaceName].Front().Value.(*BPF).Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-			return fmt.Errorf("failed to stop xdp root program iface %s with err %v", ifaceName, err)
+			return fmt.Errorf("failed to stop xdp root program iface %s with err %w", ifaceName, err)
 		}
 		c.IngressXDPBpfs[ifaceName].Remove(c.IngressXDPBpfs[ifaceName].Front())
 		c.IngressXDPBpfs[ifaceName] = nil
@@ -581,7 +581,7 @@ func (c *NFConfigs) StopRootProgram(ifaceName, direction string) error {
 			return nil
 		}
 		if err := c.IngressTCBpfs[ifaceName].Front().Value.(*BPF).Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-			return fmt.Errorf("failed to stop ingress tc root program on interface %s with err %v", ifaceName, err)
+			return fmt.Errorf("failed to stop ingress tc root program on interface %s with err %w", ifaceName, err)
 		}
 		c.IngressTCBpfs[ifaceName].Remove(c.IngressTCBpfs[ifaceName].Front())
 		c.IngressTCBpfs[ifaceName] = nil
@@ -591,7 +591,7 @@ func (c *NFConfigs) StopRootProgram(ifaceName, direction string) error {
 			return nil
 		}
 		if err := c.EgressTCBpfs[ifaceName].Front().Value.(*BPF).Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-			return fmt.Errorf("failed to stop egress tc root program on interface %s with err %v", ifaceName, err)
+			return fmt.Errorf("failed to stop egress tc root program on interface %s with err %w", ifaceName, err)
 		}
 		c.EgressTCBpfs[ifaceName].Remove(c.EgressTCBpfs[ifaceName].Front())
 		c.EgressTCBpfs[ifaceName] = nil
@@ -609,7 +609,7 @@ func (c *NFConfigs) LinkBPFPrograms(leftBPF, rightBPF *BPF) error {
 	rightBPF.PrevProgMapID = leftBPF.PrevProgMapID
 	if err := leftBPF.PutNextProgFDFromID(int(rightBPF.ProgID)); err != nil {
 		log.Error().Err(err).Msgf("LinkBPFPrograms - failed to update program fd in prev prog map before move")
-		return fmt.Errorf("LinkBPFPrograms - failed to update program fd in prev prog prog map before move %v", err)
+		return fmt.Errorf("LinkBPFPrograms - failed to update program fd in prev prog prog map before move %w", err)
 	}
 	return nil
 }
@@ -667,15 +667,15 @@ func (c *NFConfigs) Deploy(ifaceName, HostName string, bpfProgs *models.BPFProgr
 				c.IngressXDPBpfs[ifaceName] = list.New()
 				if err := c.VerifyAndStartXDPRootProgram(ifaceName, models.XDPIngressType); err != nil {
 					c.IngressXDPBpfs[ifaceName] = nil
-					return fmt.Errorf("failed to chain XDP BPF programs: %v", err)
+					return fmt.Errorf("failed to chain XDP BPF programs: %w", err)
 				}
 				log.Info().Msgf("Push Back and Start XDP program : %s seq_id : %d", bpfProg.Name, bpfProg.SeqID)
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.XDPIngressType); err != nil {
-					return fmt.Errorf("failed to update BPF Program: %v", err)
+					return fmt.Errorf("failed to update BPF Program: %w", err)
 				}
 			}
 		} else if err := c.VerifyNUpdateBPFProgram(bpfProg, ifaceName, models.XDPIngressType); err != nil {
-			return fmt.Errorf("failed to update xdp BPF Program: %v", err)
+			return fmt.Errorf("failed to update xdp BPF Program: %w", err)
 		}
 	}
 
@@ -685,14 +685,14 @@ func (c *NFConfigs) Deploy(ifaceName, HostName string, bpfProgs *models.BPFProgr
 				c.IngressTCBpfs[ifaceName] = list.New()
 				if err := c.VerifyAndStartTCRootProgram(ifaceName, models.IngressType); err != nil {
 					c.IngressTCBpfs[ifaceName] = nil
-					return fmt.Errorf("failed to chain ingress tc bpf programs: %v", err)
+					return fmt.Errorf("failed to chain ingress tc bpf programs: %w", err)
 				}
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.IngressType); err != nil {
-					return fmt.Errorf("failed to update BPF Program: %v", err)
+					return fmt.Errorf("failed to update BPF Program: %w", err)
 				}
 			}
 		} else if err := c.VerifyNUpdateBPFProgram(bpfProg, ifaceName, models.IngressType); err != nil {
-			return fmt.Errorf("failed to update BPF Program: %v", err)
+			return fmt.Errorf("failed to update BPF Program: %w", err)
 		}
 	}
 
@@ -702,14 +702,14 @@ func (c *NFConfigs) Deploy(ifaceName, HostName string, bpfProgs *models.BPFProgr
 				c.EgressTCBpfs[ifaceName] = list.New()
 				if err := c.VerifyAndStartTCRootProgram(ifaceName, models.EgressType); err != nil {
 					c.EgressTCBpfs[ifaceName] = nil
-					return fmt.Errorf("failed to chain ingress tc bpf programs: %v", err)
+					return fmt.Errorf("failed to chain ingress tc bpf programs: %w", err)
 				}
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.EgressType); err != nil {
-					return fmt.Errorf("failed to update BPF Program: %v", err)
+					return fmt.Errorf("failed to update BPF Program: %w", err)
 				}
 			}
 		} else if err := c.VerifyNUpdateBPFProgram(bpfProg, ifaceName, models.EgressType); err != nil {
-			return fmt.Errorf("failed to update BPF Program: %v", err)
+			return fmt.Errorf("failed to update BPF Program: %w", err)
 		}
 	}
 
@@ -721,9 +721,9 @@ func (c *NFConfigs) DeployeBPFPrograms(bpfProgs []models.L3afBPFPrograms) error
 	for _, bpfProg := range bpfProgs {
 		if err := c.Deploy(bpfProg.Iface, bpfProg.HostName, bpfProg.BpfPrograms); err != nil {
 			if err := c.SaveConfigsToConfigStore(); err != nil {
-				return fmt.Errorf("deploy eBPF Programs failed to save configs %v", err)
+				return fmt.Errorf("deploy eBPF Programs failed to save configs %w", err)
 			}
-			return fmt.Errorf("failed to deploy BPF program on iface %s with error: %v", bpfProg.Iface, err)
+			return fmt.Errorf("failed to deploy BPF program on iface %s with error: %w", bpfProg.Iface, err)
 		}
 		c.ifaces = map[string]string{bpfProg.Iface: bpfProg.Iface}
 	}
@@ -732,7 +732,7 @@ func (c *NFConfigs) DeployeBPFPrograms(bpfProgs []models.L3afBPFPrograms) error
 		log.Warn().Err(err).Msgf("Remove missing interfaces and BPF programs in the config failed with error ")
 	}
 	if err := c.SaveConfigsToConfigStore(); err != nil {
-		return fmt.Errorf("deploy eBPF Programs failed to save configs %v", err)
+		return fmt.Errorf("deploy eBPF Programs failed to save configs %w", err)
 	}
 	return nil
 }
@@ -751,12 +751,12 @@ func (c *NFConfigs) SaveConfigsToConfigStore() error {
 	file, err := json.MarshalIndent(bpfProgs, "", " ")
 	if err != nil {
 		log.Error().Err(err).Msgf("failed to marshal configs to save")
-		return fmt.Errorf("failed to marshal configs %v", err)
+		return fmt.Errorf("failed to marshal configs %w", err)
 	}
 
 	if err = os.WriteFile(c.HostConfig.L3afConfigStoreFileName, file, 0644); err != nil {
 		log.Error().Err(err).Msgf("failed write to file operation")
-		return fmt.Errorf("failed to save configs %v", err)
+		return fmt.Errorf("failed to save configs %w", err)
 	}
 
 	return nil
@@ -918,7 +918,7 @@ func (c *NFConfigs) RemoveMissingBPFProgramsInConfig(bpfProg models.L3afBPFProgr
 			log.Info().Msgf("eBPF Program not found in config stopping - %s direction %s", prog.Program.Name, direction)
 			prog.Program.AdminStatus = models.Disabled
 			if err := prog.Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-				return fmt.Errorf("failed to stop to on removed config BPF %s iface %s direction %s with err %v", prog.Program.Name, ifaceName, models.XDPIngressType, err)
+				return fmt.Errorf("failed to stop to on removed config BPF %s iface %s direction %s with err %w", prog.Program.Name, ifaceName, models.XDPIngressType, err)
 			}
 			tmpNextBPF := e.Next()
 			tmpPreviousBPF := e.Prev()
@@ -926,7 +926,7 @@ func (c *NFConfigs) RemoveMissingBPFProgramsInConfig(bpfProg models.L3afBPFProgr
 			if tmpNextBPF != nil && tmpNextBPF.Prev() != nil { // relink the next element
 				if err := c.LinkBPFPrograms(tmpNextBPF.Prev().Value.(*BPF), tmpNextBPF.Value.(*BPF)); err != nil {
 					log.Error().Err(err).Msgf("missing config - failed LinkBPFPrograms")
-					return fmt.Errorf("missing config - failed LinkBPFPrograms %v", err)
+					return fmt.Errorf("missing config - failed LinkBPFPrograms %w", err)
 				}
 			}
 			// Check if list contains root program only then stop the root program.
@@ -934,7 +934,7 @@ func (c *NFConfigs) RemoveMissingBPFProgramsInConfig(bpfProg models.L3afBPFProgr
 				log.Info().Msgf("no eBPF Programs are running, stopping root program")
 
 				if err := c.StopRootProgram(ifaceName, direction); err != nil {
-					return fmt.Errorf("failed to stop to root program of iface %s direction XDP Ingress with err %v", ifaceName, err)
+					return fmt.Errorf("failed to stop to root program of iface %s direction XDP Ingress with err %w", ifaceName, err)
 				}
 			}
 		}
@@ -947,7 +947,7 @@ func getHostInterfaces() (map[string]bool, error) {
 	var hostIfaces = make(map[string]bool, 0)
 	ifaces, err := net.Interfaces()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get net interfaces: %v", err)
+		return nil, fmt.Errorf("failed to get net interfaces: %w", err)
 	}
 
 	for _, iface := range ifaces {
@@ -998,13 +998,13 @@ func (c *NFConfigs) AddAndStartBPF(bpfProg *models.BPFProgram, ifaceName string,
 			bpf := NewBpfProgram(c.ctx, *bpfProg, c.HostConfig, ifaceName)
 			tmpBPF := bpfList.InsertBefore(bpf, e)
 			if err := c.DownloadAndStartBPFProgram(tmpBPF, ifaceName, direction); err != nil {
-				return fmt.Errorf("failed to download and start eBPF program %s version %s iface %s direction %s with err %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+				return fmt.Errorf("failed to download and start eBPF program %s version %s iface %s direction %s with err %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 			}
 
 			if tmpBPF.Next() != nil {
 				if err := c.LinkBPFPrograms(tmpBPF.Value.(*BPF), tmpBPF.Next().Value.(*BPF)); err != nil {
 					log.Error().Err(err).Msg("AddAndStartBPF - failed LinkBPFPrograms after InsertBefore element to with next prog")
-					return fmt.Errorf("AddAndStartBPFProg - failed LinkBPFPrograms after InsertBefore element to with next prog %v", err)
+					return fmt.Errorf("AddAndStartBPFProg - failed LinkBPFPrograms after InsertBefore element to with next prog %w", err)
 				}
 			}
 			return nil
@@ -1013,7 +1013,7 @@ func (c *NFConfigs) AddAndStartBPF(bpfProg *models.BPFProgram, ifaceName string,
 
 	// insert at the end
 	if err := c.PushBackAndStartBPF(bpfProg, ifaceName, direction); err != nil {
-		return fmt.Errorf("failed to push back and start eBPF Program %s version %s iface %s direction %s with err %v", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
+		return fmt.Errorf("failed to push back and start eBPF Program %s version %s iface %s direction %s with err %w", bpfProg.Name, bpfProg.Version, ifaceName, direction, err)
 	}
 
 	return nil
@@ -1035,7 +1035,7 @@ func (c *NFConfigs) AddProgramWithoutChaining(ifaceName string, bpfProgs *models
 			if c.IngressXDPBpfs[ifaceName] == nil {
 				c.IngressXDPBpfs[ifaceName] = list.New()
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.XDPIngressType); err != nil {
-					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %v", err)
+					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %w", err)
 				}
 			} else {
 				prog := c.IngressXDPBpfs[ifaceName].Front().Value.(*BPF)
@@ -1050,7 +1050,7 @@ func (c *NFConfigs) AddProgramWithoutChaining(ifaceName string, bpfProgs *models
 			if c.IngressTCBpfs[ifaceName] == nil {
 				c.IngressTCBpfs[ifaceName] = list.New()
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.IngressType); err != nil {
-					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %v", err)
+					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %w", err)
 				}
 			} else {
 				prog := c.IngressTCBpfs[ifaceName].Front().Value.(*BPF)
@@ -1065,7 +1065,7 @@ func (c *NFConfigs) AddProgramWithoutChaining(ifaceName string, bpfProgs *models
 			if c.EgressTCBpfs[ifaceName] == nil {
 				c.EgressTCBpfs[ifaceName] = list.New()
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.EgressType); err != nil {
-					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %v", err)
+					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %w", err)
 				}
 			} else {
 				prog := c.EgressTCBpfs[ifaceName].Front().Value.(*BPF)
@@ -1114,16 +1114,16 @@ func (c *NFConfigs) AddProgramsOnInterface(ifaceName, HostName string, bpfProgs
 				c.IngressXDPBpfs[ifaceName] = list.New()
 				if err := c.VerifyAndStartXDPRootProgram(ifaceName, models.XDPIngressType); err != nil {
 					c.IngressXDPBpfs[ifaceName] = nil
-					return fmt.Errorf("failed to chain XDP BPF programs: %v", err)
+					return fmt.Errorf("failed to chain XDP BPF programs: %w", err)
 				}
 
 				log.Info().Msgf("Push Back and Start XDP program : %s seq_id : %d", bpfProg.Name, bpfProg.SeqID)
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.XDPIngressType); err != nil {
-					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %v", err)
+					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %w", err)
 				}
 			}
 		} else if err := c.AddAndStartBPF(bpfProg, ifaceName, models.XDPIngressType); err != nil {
-			return fmt.Errorf("failed to AddAndStartBPF xdp BPF Program: %v", err)
+			return fmt.Errorf("failed to AddAndStartBPF xdp BPF Program: %w", err)
 		}
 	}
 
@@ -1133,15 +1133,15 @@ func (c *NFConfigs) AddProgramsOnInterface(ifaceName, HostName string, bpfProgs
 				c.IngressTCBpfs[ifaceName] = list.New()
 				if err := c.VerifyAndStartTCRootProgram(ifaceName, models.IngressType); err != nil {
 					c.IngressTCBpfs[ifaceName] = nil
-					return fmt.Errorf("failed to chain ingress tc bpf programs: %v", err)
+					return fmt.Errorf("failed to chain ingress tc bpf programs: %w", err)
 				}
 
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.IngressType); err != nil {
-					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %v", err)
+					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %w", err)
 				}
 			}
 		} else if err := c.AddAndStartBPF(bpfProg, ifaceName, models.IngressType); err != nil {
-			return fmt.Errorf("failed to AddAndStartBPF tcingress BPF Program: %v", err)
+			return fmt.Errorf("failed to AddAndStartBPF tcingress BPF Program: %w", err)
 		}
 	}
 
@@ -1151,14 +1151,14 @@ func (c *NFConfigs) AddProgramsOnInterface(ifaceName, HostName string, bpfProgs
 				c.EgressTCBpfs[ifaceName] = list.New()
 				if err := c.VerifyAndStartTCRootProgram(ifaceName, models.EgressType); err != nil {
 					c.EgressTCBpfs[ifaceName] = nil
-					return fmt.Errorf("failed to chain ingress tc bpf programs: %v", err)
+					return fmt.Errorf("failed to chain ingress tc bpf programs: %w", err)
 				}
 				if err := c.PushBackAndStartBPF(bpfProg, ifaceName, models.EgressType); err != nil {
-					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %v", err)
+					return fmt.Errorf("failed to PushBackAndStartBPF BPF Program: %w", err)
 				}
 			}
 		} else if err := c.AddAndStartBPF(bpfProg, ifaceName, models.EgressType); err != nil {
-			return fmt.Errorf("failed to AddAndStartBPF tcegress BPF Program: %v", err)
+			return fmt.Errorf("failed to AddAndStartBPF tcegress BPF Program: %w", err)
 		}
 	}
 
@@ -1170,14 +1170,14 @@ func (c *NFConfigs) AddeBPFPrograms(bpfProgs []models.L3afBPFPrograms) error {
 	for _, bpfProg := range bpfProgs {
 		if err := c.AddProgramsOnInterface(bpfProg.Iface, bpfProg.HostName, bpfProg.BpfPrograms); err != nil {
 			if err := c.SaveConfigsToConfigStore(); err != nil {
-				return fmt.Errorf("add eBPF Programs failed to save configs %v", err)
+				return fmt.Errorf("add eBPF Programs failed to save configs %w", err)
 			}
-			return fmt.Errorf("failed to Add BPF program on iface %s with error: %v", bpfProg.Iface, err)
+			return fmt.Errorf("failed to Add BPF program on iface %s with error: %w", bpfProg.Iface, err)
 		}
 		c.ifaces = map[string]string{bpfProg.Iface: bpfProg.Iface}
 	}
 	if err := c.SaveConfigsToConfigStore(); err != nil {
-		return fmt.Errorf("AddeBPFPrograms failed to save configs %v", err)
+		return fmt.Errorf("AddeBPFPrograms failed to save configs %w", err)
 	}
 	return nil
 }
@@ -1214,7 +1214,7 @@ func (c *NFConfigs) DeleteProgramsOnInterface(ifaceName, HostName string, bpfPro
 			if BinarySearch(bpfProgs.XDPIngress, data.Program.Name) {
 				err := c.DeleteProgramsOnInterfaceHelper(e, ifaceName, models.XDPIngressType, bpfList)
 				if err != nil {
-					return fmt.Errorf("DeleteProgramsOnInterfaceHelper function failed : %v", err)
+					return fmt.Errorf("DeleteProgramsOnInterfaceHelper function failed : %w", err)
 				}
 			}
 			e = next
@@ -1232,7 +1232,7 @@ func (c *NFConfigs) DeleteProgramsOnInterface(ifaceName, HostName string, bpfPro
 			if BinarySearch(bpfProgs.TCIngress, data.Program.Name) {
 				err := c.DeleteProgramsOnInterfaceHelper(e, ifaceName, models.IngressType, bpfList)
 				if err != nil {
-					return fmt.Errorf("DeleteProgramsOnInterfaceHelper function failed : %v", err)
+					return fmt.Errorf("DeleteProgramsOnInterfaceHelper function failed : %w", err)
 				}
 			}
 			e = next
@@ -1251,7 +1251,7 @@ func (c *NFConfigs) DeleteProgramsOnInterface(ifaceName, HostName string, bpfPro
 			if BinarySearch(bpfProgs.TCEgress, data.Program.Name) {
 				err := c.DeleteProgramsOnInterfaceHelper(e, ifaceName, models.EgressType, bpfList)
 				if err != nil {
-					return fmt.Errorf("DeleteProgramsOnInterfaceHelper function failed : %v", err)
+					return fmt.Errorf("DeleteProgramsOnInterfaceHelper function failed : %w", err)
 				}
 			}
 			e = next
@@ -1271,7 +1271,7 @@ func (c *NFConfigs) DeleteProgramsOnInterfaceHelper(e *list.Element, ifaceName s
 	prog := e.Value.(*BPF)
 	prog.Program.AdminStatus = models.Disabled
 	if err := prog.Stop(ifaceName, direction, c.HostConfig.BpfChainingEnabled); err != nil {
-		return fmt.Errorf("failed to stop %s iface %s direction %s with err %v", prog.Program.Name, ifaceName, direction, err)
+		return fmt.Errorf("failed to stop %s iface %s direction %s with err %w", prog.Program.Name, ifaceName, direction, err)
 	}
 	tmpNextBPF := e.Next()
 	tmpPreviousBPF := e.Prev()
@@ -1283,7 +1283,7 @@ func (c *NFConfigs) DeleteProgramsOnInterfaceHelper(e *list.Element, ifaceName s
 	if tmpNextBPF != nil && tmpNextBPF.Prev() != nil { // relink the next element
 		if err := c.LinkBPFPrograms(tmpNextBPF.Prev().Value.(*BPF), tmpNextBPF.Value.(*BPF)); err != nil {
 			log.Error().Err(err).Msgf("DeleteProgramsOnInterfaceHelper - failed LinkBPFPrograms")
-			return fmt.Errorf("DeleteProgramsOnInterfaceHelper - failed LinkBPFPrograms %v", err)
+			return fmt.Errorf("DeleteProgramsOnInterfaceHelper - failed LinkBPFPrograms %w", err)
 		}
 	}
 	// Check if list contains root program only then stop the root program.
@@ -1291,7 +1291,7 @@ func (c *NFConfigs) DeleteProgramsOnInterfaceHelper(e *list.Element, ifaceName s
 		log.Info().Msgf("no ebpf programs are running, stopping root program")
 
 		if err := c.StopRootProgram(ifaceName, direction); err != nil {
-			return fmt.Errorf("failed to stop to root program of iface %s direction %v with err %v", ifaceName, direction, err)
+			return fmt.Errorf("failed to stop to root program of iface %s direction %v with err %w", ifaceName, direction, err)
 		}
 	}
 	return nil
@@ -1302,14 +1302,14 @@ func (c *NFConfigs) DeleteEbpfPrograms(bpfProgs []models.L3afBPFProgramNames) er
 	for _, bpfProg := range bpfProgs {
 		if err := c.DeleteProgramsOnInterface(bpfProg.Iface, bpfProg.HostName, bpfProg.BpfProgramNames); err != nil {
 			if err := c.SaveConfigsToConfigStore(); err != nil {
-				return fmt.Errorf("SaveConfigsToConfigStore failed to save configs %v", err)
+				return fmt.Errorf("SaveConfigsToConfigStore failed to save configs %w", err)
 			}
-			return fmt.Errorf("failed to Remove eBPF program on iface %s with error: %v", bpfProg.Iface, err)
+			return fmt.Errorf("failed to Remove eBPF program on iface %s with error: %w", bpfProg.Iface, err)
 		}
 		c.ifaces = map[string]string{bpfProg.Iface: bpfProg.Iface}
 	}
 	if err := c.SaveConfigsToConfigStore(); err != nil {
-		return fmt.Errorf("DeleteEbpfPrograms failed to save configs %v", err)
+		return fmt.Errorf("DeleteEbpfPrograms failed to save configs %w", err)
 	}
 	return nil
 }