🔨 Move cli folder contents into project root (#1253)

* Remove `logger` module

* Remove `shared` module

* Move `cli` folder contents into project root

* Fix linter

* Change the module name from `github.com/kubeshark/kubeshark/cli` to `github.com/kubeshark/kubeshark`

* Set the default `Makefile` rule to `build`

* Add `lint` rule

* Fix the linter errors

.github/workflows/linter.yml

@@ -24,22 +24,8 @@ jobs:
         with:
           go-version: '^1.17'
 
-      - name: Go lint - shared
+      - name: Go lint
         uses: golangci/golangci-lint-action@v2
         with:
           version: latest
-          working-directory: shared
           args: --timeout=10m
-
-      - name: Go lint - CLI
-        uses: golangci/golangci-lint-action@v2
-        with:
-          version: latest
-          working-directory: cli
-          args: --timeout=10m
-
-      - name: Go lint - logger
-        uses: golangci/golangci-lint-action@v2
-        with:
-          version: latest
-          working-directory: logger

.gitignore

@@ -56,4 +56,4 @@ cypress.env.json
 # Object files
 *.o
 
-hub
+bin

Makefile

@@ -1,40 +1,58 @@
-C_Y=\033[1;33m
-C_C=\033[0;36m
-C_M=\033[0;35m
-C_R=\033[0;41m
-C_N=\033[0m
 SHELL=/bin/bash
 
-# HELP
+.PHONY: help
-# This will output the help for each task
+.DEFAULT_GOAL := build
-# thanks to https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
+.ONESHELL:
-.PHONY: help cli
+
+SUFFIX=$(GOOS)_$(GOARCH)
+COMMIT_HASH=$(shell git rev-parse HEAD)
+GIT_BRANCH=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
+GIT_VERSION=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
+BUILD_TIMESTAMP=$(shell date +%s)
+export VER?=0.0
 
 help: ## This help.
 	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
 
-.DEFAULT_GOAL := help
+install:
+	go install kubeshark.go
 
-cli: ## Build CLI.
+build-debug:  ## Build kubeshark CLI for debug
-	@echo "building cli"; cd cli && $(MAKE) build
+	export GCLFAGS='-gcflags="all=-N -l"'
+	${MAKE} build-base
 
-cli-debug: ## Build CLI.
+build:
-	@echo "building cli"; cd cli && $(MAKE) build-debug
+	export LDFLAGS_EXT='-s -w'
+	${MAKE} build-base
 
-clean: clean-ui clean-cli ## Clean all build artifacts.
+build-base: ## Build kubeshark CLI binary (select platform via GOOS / GOARCH env variables).
+	go build ${GCLFAGS} -ldflags="${LDFLAGS_EXT} \
+					-X 'github.com/kubeshark/kubeshark/kubeshark.GitCommitHash=$(COMMIT_HASH)' \
+					-X 'github.com/kubeshark/kubeshark/kubeshark.Branch=$(GIT_BRANCH)' \
+					-X 'github.com/kubeshark/kubeshark/kubeshark.BuildTimestamp=$(BUILD_TIMESTAMP)' \
+					-X 'github.com/kubeshark/kubeshark/kubeshark.Platform=$(SUFFIX)' \
+					-X 'github.com/kubeshark/kubeshark/kubeshark.Ver=$(VER)'" \
+					-o bin/kubeshark_$(SUFFIX) kubeshark.go
+	(cd bin && shasum -a 256 kubeshark_${SUFFIX} > kubeshark_${SUFFIX}.sha256)
 
-clean-cli:  ## Clean CLI.
+build-all: ## Build for all supported platforms.
-	@(cd cli; make clean ; echo "CLI cleanup done" )
+	echo "Compiling for every OS and Platform" && \
+	mkdir -p bin && sed s/_VER_/$(VER)/g README.md.TEMPLATE >  bin/README.md && \
+	$(MAKE) build GOOS=linux GOARCH=amd64 && \
+	$(MAKE) build GOOS=linux GOARCH=arm64 && \
+	$(MAKE) build GOOS=darwin GOARCH=amd64 && \
+	$(MAKE) build GOOS=darwin GOARCH=arm64 && \
+	$(MAKE) build GOOS=windows GOARCH=amd64 && \
+	mv ./bin/kubeshark_windows_amd64 ./bin/kubeshark.exe && \
+	echo "---------" && \
+	find ./bin -ls
 
+clean: ## Clean all build artifacts.
+	go clean
+	rm -rf ./bin/*
 
-lint:  ## Run lint on all modules
+test: ## Run cli tests.
-	cd shared && golangci-lint run
+	@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic
-	cd cli && golangci-lint run
 
-test: test-cli test-shared
+lint: ## Run linter
-
+	golangci-lint run
-test-cli:  ## Run cli tests
-	@echo "running cli tests"; cd cli && $(MAKE) test
-
-test-shared:  ## Run shared tests
-	@echo "running shared tests"; cd shared && $(MAKE) test

apiserver/provider.go

@@ -4,14 +4,14 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"log"
 	"net/http"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/utils"
+	"github.com/kubeshark/kubeshark/utils"
+	"github.com/kubeshark/worker/models"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared"
 	core "k8s.io/api/core/v1"
 )
 
@@ -38,9 +38,9 @@ func (provider *Provider) TestConnection(path string) error {
 	retriesLeft := provider.retries
 	for retriesLeft > 0 {
 		if isReachable, err := provider.isReachable(path); err != nil || !isReachable {
-			logger.Log.Debugf("api server not ready yet %v", err)
+			log.Printf("api server not ready yet %v", err)
 		} else {
-			logger.Log.Debugf("connection test to api server passed successfully")
+			log.Printf("connection test to api server passed successfully")
 			break
 		}
 		retriesLeft -= 1
@@ -62,7 +62,7 @@ func (provider *Provider) isReachable(path string) (bool, error) {
 	}
 }
 
-func (provider *Provider) ReportTapperStatus(tapperStatus shared.TapperStatus) error {
+func (provider *Provider) ReportTapperStatus(tapperStatus models.TapperStatus) error {
 	tapperStatusUrl := fmt.Sprintf("%s/status/tapperStatus", provider.url)
 
 	if jsonValue, err := json.Marshal(tapperStatus); err != nil {
@@ -71,7 +71,7 @@ func (provider *Provider) ReportTapperStatus(tapperStatus shared.TapperStatus) e
 		if _, err := utils.Post(tapperStatusUrl, "application/json", bytes.NewBuffer(jsonValue), provider.client); err != nil {
 			return fmt.Errorf("failed sending to API server the tapped pods %w", err)
 		} else {
-			logger.Log.Debugf("Reported to server API about tapper status: %v", tapperStatus)
+			log.Printf("Reported to server API about tapper status: %v", tapperStatus)
 			return nil
 		}
 	}
@@ -86,7 +86,7 @@ func (provider *Provider) ReportTappedPods(pods []core.Pod) error {
 		if _, err := utils.Post(tappedPodsUrl, "application/json", bytes.NewBuffer(jsonValue), provider.client); err != nil {
 			return fmt.Errorf("failed sending to API server the tapped pods %w", err)
 		} else {
-			logger.Log.Debugf("Reported to server API about %d taped pods successfully", len(pods))
+			log.Printf("Reported to server API about %d taped pods successfully", len(pods))
 			return nil
 		}
 	}

bucket/provider.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/utils"
+	"github.com/kubeshark/kubeshark/utils"
 )
 
 type Provider struct {

cli/.gitignore

@@ -1 +0,0 @@
-bin

cli/Makefile

@@ -1,55 +0,0 @@
-SHELL=/bin/bash
-
-.PHONY: help
-.DEFAULT_GOAL := help
-.ONESHELL:
-
-SUFFIX=$(GOOS)_$(GOARCH)
-COMMIT_HASH=$(shell git rev-parse HEAD)
-GIT_BRANCH=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
-GIT_VERSION=$(shell git branch --show-current | tr '[:upper:]' '[:lower:]')
-BUILD_TIMESTAMP=$(shell date +%s)
-export VER?=0.0
-
-help: ## This help.
-	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
-
-install:
-	go install kubeshark.go
-
-build-debug:  ## Build kubeshark CLI for debug
-	export GCLFAGS='-gcflags="all=-N -l"'
-	${MAKE} build-base
-
-build:
-	export LDFLAGS_EXT='-s -w'
-	${MAKE} build-base
-
-build-base: ## Build kubeshark CLI binary (select platform via GOOS / GOARCH env variables).
-	go build ${GCLFAGS} -ldflags="${LDFLAGS_EXT} \
-					-X 'github.com/kubeshark/kubeshark/cli/kubeshark.GitCommitHash=$(COMMIT_HASH)' \
-					-X 'github.com/kubeshark/kubeshark/cli/kubeshark.Branch=$(GIT_BRANCH)' \
-					-X 'github.com/kubeshark/kubeshark/cli/kubeshark.BuildTimestamp=$(BUILD_TIMESTAMP)' \
-					-X 'github.com/kubeshark/kubeshark/cli/kubeshark.Platform=$(SUFFIX)' \
-					-X 'github.com/kubeshark/kubeshark/cli/kubeshark.Ver=$(VER)'" \
-					-o bin/kubeshark_$(SUFFIX) kubeshark.go
-	(cd bin && shasum -a 256 kubeshark_${SUFFIX} > kubeshark_${SUFFIX}.sha256)
-
-build-all: ## Build for all supported platforms.
-	echo "Compiling for every OS and Platform" && \
-	mkdir -p bin && sed s/_VER_/$(VER)/g README.md.TEMPLATE >  bin/README.md && \
-	$(MAKE) build GOOS=linux GOARCH=amd64 && \
-	$(MAKE) build GOOS=linux GOARCH=arm64 && \
-	$(MAKE) build GOOS=darwin GOARCH=amd64 && \
-	$(MAKE) build GOOS=darwin GOARCH=arm64 && \
-	$(MAKE) build GOOS=windows GOARCH=amd64 && \
-	mv ./bin/kubeshark_windows_amd64 ./bin/kubeshark.exe && \
-	echo "---------" && \
-	find ./bin -ls
-
-clean: ## Clean all build artifacts.
-	go clean
-	rm -rf ./bin/*
-
-test: ## Run cli tests.
-	@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic

cli/cmd/check/kubernetesApi.go

@@ -1,31 +0,0 @@
-package check
-
-import (
-	"fmt"
-
-	"github.com/kubeshark/kubeshark/cli/config"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
-	"github.com/kubeshark/kubeshark/shared/semver"
-)
-
-func KubernetesApi() (*kubernetes.Provider, *semver.SemVersion, bool) {
-	logger.Log.Infof("\nkubernetes-api\n--------------------")
-
-	kubernetesProvider, err := kubernetes.NewProvider(config.Config.KubeConfigPath(), config.Config.KubeContext)
-	if err != nil {
-		logger.Log.Errorf("%v can't initialize the client, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
-		return nil, nil, false
-	}
-	logger.Log.Infof("%v can initialize the client", fmt.Sprintf(uiUtils.Green, "√"))
-
-	kubernetesVersion, err := kubernetesProvider.GetKubernetesVersion()
-	if err != nil {
-		logger.Log.Errorf("%v can't query the Kubernetes API, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
-		return nil, nil, false
-	}
-	logger.Log.Infof("%v can query the Kubernetes API", fmt.Sprintf(uiUtils.Green, "√"))
-
-	return kubernetesProvider, kubernetesVersion, true
-}

cli/cmd/check/kubernetesVersion.go

@@ -1,22 +0,0 @@
-package check
-
-import (
-	"fmt"
-
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
-	"github.com/kubeshark/kubeshark/shared/semver"
-)
-
-func KubernetesVersion(kubernetesVersion *semver.SemVersion) bool {
-	logger.Log.Infof("\nkubernetes-version\n--------------------")
-
-	if err := kubernetes.ValidateKubernetesVersion(kubernetesVersion); err != nil {
-		logger.Log.Errorf("%v not running the minimum Kubernetes API version, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
-		return false
-	}
-
-	logger.Log.Infof("%v is running the minimum Kubernetes API version", fmt.Sprintf(uiUtils.Green, "√"))
-	return true
-}

cli/kubeshark.go

@@ -1,10 +0,0 @@
-package main
-
-import (
-	"github.com/kubeshark/kubeshark/cli/cmd"
-	"github.com/kubeshark/kubeshark/cli/cmd/goUtils"
-)
-
-func main() {
-	goUtils.HandleExcWrapper(cmd.Execute)
-}

cmd/check.go

@@ -1,9 +1,10 @@
 package cmd
 
 import (
+	"log"
+
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -21,7 +22,7 @@ func init() {
 
 	defaultCheckConfig := configStructs.CheckConfig{}
 	if err := defaults.Set(&defaultCheckConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	checkCmd.Flags().Bool(configStructs.PreTapCheckName, defaultCheckConfig.PreTap, "Check pre-tap Kubeshark installation for potential problems")

cmd/check/imagePullInCluster.go

@@ -3,39 +3,39 @@ package check
 import (
 	"context"
 	"fmt"
+	"log"
 	"regexp"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 	core "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
 func ImagePullInCluster(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
-	logger.Log.Infof("\nimage-pull-in-cluster\n--------------------")
+	log.Printf("\nimage-pull-in-cluster\n--------------------")
 
 	namespace := "default"
 	podName := "kubeshark-test"
 
 	defer func() {
 		if err := kubernetesProvider.RemovePod(ctx, namespace, podName); err != nil {
-			logger.Log.Errorf("%v error while removing test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+			log.Printf("%v error while removing test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 		}
 	}()
 
 	if err := createImagePullInClusterPod(ctx, kubernetesProvider, namespace, podName); err != nil {
-		logger.Log.Errorf("%v error while creating test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v error while creating test pod in cluster, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 		return false
 	}
 
 	if err := checkImagePulled(ctx, kubernetesProvider, namespace, podName); err != nil {
-		logger.Log.Errorf("%v cluster is not able to pull kubeshark containers from docker hub, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v cluster is not able to pull kubeshark containers from docker hub, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 		return false
 	}
 
-	logger.Log.Infof("%v cluster is able to pull kubeshark containers from docker hub", fmt.Sprintf(uiUtils.Green, "√"))
+	log.Printf("%v cluster is able to pull kubeshark containers from docker hub", fmt.Sprintf(uiUtils.Green, "√"))
 	return true
 }
 

cmd/check/kubernetesApi.go

@@ -0,0 +1,31 @@
+package check
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/kubeshark/kubeshark/config"
+	"github.com/kubeshark/kubeshark/kubernetes"
+	"github.com/kubeshark/kubeshark/semver"
+	"github.com/kubeshark/kubeshark/uiUtils"
+)
+
+func KubernetesApi() (*kubernetes.Provider, *semver.SemVersion, bool) {
+	log.Printf("\nkubernetes-api\n--------------------")
+
+	kubernetesProvider, err := kubernetes.NewProvider(config.Config.KubeConfigPath(), config.Config.KubeContext)
+	if err != nil {
+		log.Printf("%v can't initialize the client, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		return nil, nil, false
+	}
+	log.Printf("%v can initialize the client", fmt.Sprintf(uiUtils.Green, "√"))
+
+	kubernetesVersion, err := kubernetesProvider.GetKubernetesVersion()
+	if err != nil {
+		log.Printf("%v can't query the Kubernetes API, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		return nil, nil, false
+	}
+	log.Printf("%v can query the Kubernetes API", fmt.Sprintf(uiUtils.Green, "√"))
+
+	return kubernetesProvider, kubernetesVersion, true
+}

cmd/check/kubernetesPermissions.go

@@ -4,20 +4,20 @@ import (
 	"context"
 	"embed"
 	"fmt"
+	"log"
 	"strings"
 
-	"github.com/kubeshark/kubeshark/cli/bucket"
+	"github.com/kubeshark/kubeshark/bucket"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 	rbac "k8s.io/api/rbac/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/scheme"
 )
 
 func TapKubernetesPermissions(ctx context.Context, embedFS embed.FS, kubernetesProvider *kubernetes.Provider) bool {
-	logger.Log.Infof("\nkubernetes-permissions\n--------------------")
+	log.Printf("\nkubernetes-permissions\n--------------------")
 
 	var filePath string
 	if config.Config.IsNsRestrictedMode() {
@@ -28,14 +28,14 @@ func TapKubernetesPermissions(ctx context.Context, embedFS embed.FS, kubernetesP
 
 	data, err := embedFS.ReadFile(filePath)
 	if err != nil {
-		logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 		return false
 	}
 
 	decode := scheme.Codecs.UniversalDeserializer().Decode
 	obj, _, err := decode(data, nil, nil)
 	if err != nil {
-		logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 		return false
 	}
 
@@ -46,17 +46,17 @@ func TapKubernetesPermissions(ctx context.Context, embedFS embed.FS, kubernetesP
 		return checkRulesPermissions(ctx, kubernetesProvider, resource.Rules, "")
 	}
 
-	logger.Log.Errorf("%v error while checking kubernetes permissions, err: resource of type 'Role' or 'ClusterRole' not found in permission files", fmt.Sprintf(uiUtils.Red, "✗"))
+	log.Printf("%v error while checking kubernetes permissions, err: resource of type 'Role' or 'ClusterRole' not found in permission files", fmt.Sprintf(uiUtils.Red, "✗"))
 	return false
 }
 
 func InstallKubernetesPermissions(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
-	logger.Log.Infof("\nkubernetes-permissions\n--------------------")
+	log.Printf("\nkubernetes-permissions\n--------------------")
 
 	bucketProvider := bucket.NewProvider(config.Config.Install.TemplateUrl, bucket.DefaultTimeout)
 	installTemplate, err := bucketProvider.GetInstallTemplate(config.Config.Install.TemplateName)
 	if err != nil {
-		logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 		return false
 	}
 
@@ -68,7 +68,7 @@ func InstallKubernetesPermissions(ctx context.Context, kubernetesProvider *kuber
 	for _, resourceTemplate := range resourcesTemplate {
 		obj, _, err := decode([]byte(resourceTemplate), nil, nil)
 		if err != nil {
-			logger.Log.Errorf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+			log.Printf("%v error while checking kubernetes permissions, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 			return false
 		}
 
@@ -120,13 +120,13 @@ func checkPermissionExist(group string, resource string, verb string, namespace
 	}
 
 	if err != nil {
-		logger.Log.Errorf("%v error checking permission for %v %v %v, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace, err)
+		log.Printf("%v error checking permission for %v %v %v, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace, err)
 		return false
 	} else if !exist {
-		logger.Log.Errorf("%v can't %v %v %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace)
+		log.Printf("%v can't %v %v %v", fmt.Sprintf(uiUtils.Red, "✗"), verb, resource, groupAndNamespace)
 		return false
 	}
 
-	logger.Log.Infof("%v can %v %v %v", fmt.Sprintf(uiUtils.Green, "√"), verb, resource, groupAndNamespace)
+	log.Printf("%v can %v %v %v", fmt.Sprintf(uiUtils.Green, "√"), verb, resource, groupAndNamespace)
 	return true
 }

cmd/check/kubernetesResources.go

@@ -3,15 +3,15 @@ package check
 import (
 	"context"
 	"fmt"
+	"log"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 )
 
 func KubernetesResources(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
-	logger.Log.Infof("\nk8s-components\n--------------------")
+	log.Printf("\nk8s-components\n--------------------")
 
 	exist, err := kubernetesProvider.DoesNamespaceExist(ctx, config.Config.KubesharkResourcesNamespace)
 	allResourcesExist := checkResourceExist(config.Config.KubesharkResourcesNamespace, "namespace", exist, err)
@@ -46,20 +46,20 @@ func KubernetesResources(ctx context.Context, kubernetesProvider *kubernetes.Pro
 
 func checkPodResourcesExist(ctx context.Context, kubernetesProvider *kubernetes.Provider) bool {
 	if pods, err := kubernetesProvider.ListPodsByAppLabel(ctx, config.Config.KubesharkResourcesNamespace, kubernetes.ApiServerPodName); err != nil {
-		logger.Log.Errorf("%v error checking if '%v' pod is running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName, err)
+		log.Printf("%v error checking if '%v' pod is running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName, err)
 		return false
 	} else if len(pods) == 0 {
-		logger.Log.Errorf("%v '%v' pod doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
+		log.Printf("%v '%v' pod doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
 		return false
 	} else if !kubernetes.IsPodRunning(&pods[0]) {
-		logger.Log.Errorf("%v '%v' pod not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
+		log.Printf("%v '%v' pod not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.ApiServerPodName)
 		return false
 	}
 
-	logger.Log.Infof("%v '%v' pod running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.ApiServerPodName)
+	log.Printf("%v '%v' pod running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.ApiServerPodName)
 
 	if pods, err := kubernetesProvider.ListPodsByAppLabel(ctx, config.Config.KubesharkResourcesNamespace, kubernetes.TapperPodName); err != nil {
-		logger.Log.Errorf("%v error checking if '%v' pods are running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, err)
+		log.Printf("%v error checking if '%v' pods are running, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, err)
 		return false
 	} else {
 		tappers := 0
@@ -73,24 +73,24 @@ func checkPodResourcesExist(ctx context.Context, kubernetesProvider *kubernetes.
 		}
 
 		if notRunningTappers > 0 {
-			logger.Log.Errorf("%v '%v' %v/%v pods are not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, notRunningTappers, tappers)
+			log.Printf("%v '%v' %v/%v pods are not running", fmt.Sprintf(uiUtils.Red, "✗"), kubernetes.TapperPodName, notRunningTappers, tappers)
 			return false
 		}
 
-		logger.Log.Infof("%v '%v' %v pods running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.TapperPodName, tappers)
+		log.Printf("%v '%v' %v pods running", fmt.Sprintf(uiUtils.Green, "√"), kubernetes.TapperPodName, tappers)
 		return true
 	}
 }
 
 func checkResourceExist(resourceName string, resourceType string, exist bool, err error) bool {
 	if err != nil {
-		logger.Log.Errorf("%v error checking if '%v' %v exists, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType, err)
+		log.Printf("%v error checking if '%v' %v exists, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType, err)
 		return false
 	} else if !exist {
-		logger.Log.Errorf("%v '%v' %v doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType)
+		log.Printf("%v '%v' %v doesn't exist", fmt.Sprintf(uiUtils.Red, "✗"), resourceName, resourceType)
 		return false
 	}
 
-	logger.Log.Infof("%v '%v' %v exists", fmt.Sprintf(uiUtils.Green, "√"), resourceName, resourceType)
+	log.Printf("%v '%v' %v exists", fmt.Sprintf(uiUtils.Green, "√"), resourceName, resourceType)
 	return true
 }

cmd/check/kubernetesVersion.go

@@ -0,0 +1,22 @@
+package check
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/kubeshark/kubeshark/kubernetes"
+	"github.com/kubeshark/kubeshark/semver"
+	"github.com/kubeshark/kubeshark/uiUtils"
+)
+
+func KubernetesVersion(kubernetesVersion *semver.SemVersion) bool {
+	log.Printf("\nkubernetes-version\n--------------------")
+
+	if err := kubernetes.ValidateKubernetesVersion(kubernetesVersion); err != nil {
+		log.Printf("%v not running the minimum Kubernetes API version, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		return false
+	}
+
+	log.Printf("%v is running the minimum Kubernetes API version", fmt.Sprintf(uiUtils.Green, "√"))
+	return true
+}

cmd/check/serverConnection.go

@@ -3,40 +3,40 @@ package check
 import (
 	"context"
 	"fmt"
+	"log"
 	"regexp"
 
-	"github.com/kubeshark/kubeshark/cli/apiserver"
+	"github.com/kubeshark/kubeshark/apiserver"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 )
 
 func ServerConnection(kubernetesProvider *kubernetes.Provider) bool {
-	logger.Log.Infof("\nAPI-server-connectivity\n--------------------")
+	log.Printf("\nAPI-server-connectivity\n--------------------")
 
 	serverUrl := kubernetes.GetLocalhostOnPort(config.Config.Hub.PortForward.SrcPort)
 
 	apiServerProvider := apiserver.NewProvider(serverUrl, 1, apiserver.DefaultTimeout)
 	if err := apiServerProvider.TestConnection(""); err == nil {
-		logger.Log.Infof("%v found Kubeshark server tunnel available and connected successfully to API server", fmt.Sprintf(uiUtils.Green, "√"))
+		log.Printf("%v found Kubeshark server tunnel available and connected successfully to API server", fmt.Sprintf(uiUtils.Green, "√"))
 		return true
 	}
 
 	connectedToApiServer := false
 
 	if err := checkProxy(serverUrl, kubernetesProvider); err != nil {
-		logger.Log.Errorf("%v couldn't connect to API server using proxy, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v couldn't connect to API server using proxy, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 	} else {
 		connectedToApiServer = true
-		logger.Log.Infof("%v connected successfully to API server using proxy", fmt.Sprintf(uiUtils.Green, "√"))
+		log.Printf("%v connected successfully to API server using proxy", fmt.Sprintf(uiUtils.Green, "√"))
 	}
 
 	if err := checkPortForward(serverUrl, kubernetesProvider); err != nil {
-		logger.Log.Errorf("%v couldn't connect to API server using port-forward, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
+		log.Printf("%v couldn't connect to API server using port-forward, err: %v", fmt.Sprintf(uiUtils.Red, "✗"), err)
 	} else {
 		connectedToApiServer = true
-		logger.Log.Infof("%v connected successfully to API server using port-forward", fmt.Sprintf(uiUtils.Green, "√"))
+		log.Printf("%v connected successfully to API server using port-forward", fmt.Sprintf(uiUtils.Green, "√"))
 	}
 
 	return connectedToApiServer
@@ -57,7 +57,7 @@ func checkProxy(serverUrl string, kubernetesProvider *kubernetes.Provider) error
 	}
 
 	if err := httpServer.Shutdown(ctx); err != nil {
-		logger.Log.Debugf("Error occurred while stopping proxy, err: %v", err)
+		log.Printf("Error occurred while stopping proxy, err: %v", err)
 	}
 
 	return nil

cmd/checkRunner.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"embed"
 	"fmt"
+	"log"
 
-	"github.com/kubeshark/kubeshark/cli/cmd/check"
+	"github.com/kubeshark/kubeshark/cmd/check"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/logger"
 )
 
 var (
@@ -17,7 +17,7 @@ var (
 )
 
 func runKubesharkCheck() {
-	logger.Log.Infof("Kubeshark checks\n===================")
+	log.Printf("Kubeshark checks\n===================")
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel() // cancel will be called when this function exits
@@ -55,8 +55,8 @@ func runKubesharkCheck() {
 	}
 
 	if checkPassed {
-		logger.Log.Infof("\nStatus check results are %v", fmt.Sprintf(uiUtils.Green, "√"))
+		log.Printf("\nStatus check results are %v", fmt.Sprintf(uiUtils.Green, "√"))
 	} else {
-		logger.Log.Errorf("\nStatus check results are %v", fmt.Sprintf(uiUtils.Red, "✗"))
+		log.Printf("\nStatus check results are %v", fmt.Sprintf(uiUtils.Red, "✗"))
 	}
 }

cmd/cleanRunner.go

@@ -1,7 +1,7 @@
 package cmd
 
 import (
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
 )
 
 func performCleanCommand() {

cmd/common.go

@@ -5,28 +5,28 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"log"
 	"path"
 	"regexp"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/apiserver"
+	"github.com/kubeshark/kubeshark/apiserver"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/cli/errormessage"
+	"github.com/kubeshark/kubeshark/errormessage"
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubeshark"
-	"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
+	"github.com/kubeshark/kubeshark/kubeshark/fsUtils"
-	"github.com/kubeshark/kubeshark/cli/resources"
+	"github.com/kubeshark/kubeshark/resources"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/worker/models"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 )
 
 func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, ctx context.Context, cancel context.CancelFunc, serviceName string, srcPort uint16, dstPort uint16, healthCheck string) {
 	httpServer, err := kubernetes.StartProxy(kubernetesProvider, config.Config.Tap.ProxyHost, srcPort, dstPort, config.Config.KubesharkResourcesNamespace, serviceName, cancel)
 	if err != nil {
-		logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error occured while running k8s proxy %v\n"+
+		log.Printf(uiUtils.Error, fmt.Sprintf("Error occured while running k8s proxy %v\n"+
 			"Try setting different port by using --%s", errormessage.FormatError(err), configStructs.GuiPortTapName))
 		cancel()
 		return
@@ -34,14 +34,14 @@ func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, ctx con
 
 	provider := apiserver.NewProvider(kubernetes.GetLocalhostOnPort(srcPort), apiserver.DefaultRetries, apiserver.DefaultTimeout)
 	if err := provider.TestConnection(healthCheck); err != nil {
-		logger.Log.Debugf("Couldn't connect using proxy, stopping proxy and trying to create port-forward")
+		log.Printf("Couldn't connect using proxy, stopping proxy and trying to create port-forward")
 		if err := httpServer.Shutdown(ctx); err != nil {
-			logger.Log.Debugf("Error occurred while stopping proxy %v", errormessage.FormatError(err))
+			log.Printf("Error occurred while stopping proxy %v", errormessage.FormatError(err))
 		}
 
 		podRegex, _ := regexp.Compile(kubernetes.ApiServerPodName)
 		if _, err := kubernetes.NewPortForward(kubernetesProvider, config.Config.KubesharkResourcesNamespace, podRegex, srcPort, dstPort, ctx, cancel); err != nil {
-			logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error occured while running port forward [%s] %v\n"+
+			log.Printf(uiUtils.Error, fmt.Sprintf("Error occured while running port forward [%s] %v\n"+
 				"Try setting different port by using --%s", podRegex, errormessage.FormatError(err), configStructs.GuiPortTapName))
 			cancel()
 			return
@@ -49,7 +49,7 @@ func startProxyReportErrorIfAny(kubernetesProvider *kubernetes.Provider, ctx con
 
 		provider = apiserver.NewProvider(kubernetes.GetLocalhostOnPort(srcPort), apiserver.DefaultRetries, apiserver.DefaultTimeout)
 		if err := provider.TestConnection(healthCheck); err != nil {
-			logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Couldn't connect to [%s], for more info check logs at %s", serviceName, fsUtils.GetLogFilePath()))
+			log.Printf(uiUtils.Error, "Couldn't connect to [%s].")
 			// cancel()
 			return
 		}
@@ -85,9 +85,9 @@ func getKubernetesProviderForCli() (*kubernetes.Provider, error) {
 func handleKubernetesProviderError(err error) {
 	var clusterBehindProxyErr *kubernetes.ClusterBehindProxyError
 	if ok := errors.As(err, &clusterBehindProxyErr); ok {
-		logger.Log.Errorf("cannot establish http-proxy connection to the Kubernetes cluster. If you’re using Lens or similar tool, please run kubeshark with regular kubectl config using --%v %v=$HOME/.kube/config flag", config.SetCommandName, config.KubeConfigPathConfigName)
+		log.Printf("cannot establish http-proxy connection to the Kubernetes cluster. If you’re using Lens or similar tool, please run kubeshark with regular kubectl config using --%v %v=$HOME/.kube/config flag", config.SetCommandName, config.KubeConfigPathConfigName)
 	} else {
-		logger.Log.Error(err)
+		log.Print(err)
 	}
 }
 
@@ -105,11 +105,11 @@ func dumpLogsIfNeeded(ctx context.Context, kubernetesProvider *kubernetes.Provid
 	kubesharkDir := kubeshark.GetKubesharkFolderPath()
 	filePath := path.Join(kubesharkDir, fmt.Sprintf("kubeshark_logs_%s.zip", time.Now().Format("2006_01_02__15_04_05")))
 	if err := fsUtils.DumpLogs(ctx, kubernetesProvider, filePath); err != nil {
-		logger.Log.Errorf("Failed dump logs %v", err)
+		log.Printf("Failed dump logs %v", err)
 	}
 }
 
-func getSerializedKubesharkAgentConfig(kubesharkAgentConfig *shared.KubesharkAgentConfig) (string, error) {
+func getSerializedKubesharkAgentConfig(kubesharkAgentConfig *models.Config) (string, error) {
 	serializedConfig, err := json.Marshal(kubesharkAgentConfig)
 	if err != nil {
 		return "", err

cmd/config.go

@@ -2,12 +2,12 @@ package cmd
 
 import (
 	"fmt"
+	"log"
 
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -17,25 +17,25 @@ var configCmd = &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) error {
 		configWithDefaults, err := config.GetConfigWithDefaults()
 		if err != nil {
-			logger.Log.Errorf("Failed generating config with defaults, err: %v", err)
+			log.Printf("Failed generating config with defaults, err: %v", err)
 			return nil
 		}
 
 		if config.Config.Config.Regenerate {
 			if err := config.WriteConfig(configWithDefaults); err != nil {
-				logger.Log.Errorf("Failed writing config with defaults, err: %v", err)
+				log.Printf("Failed writing config with defaults, err: %v", err)
 				return nil
 			}
 
-			logger.Log.Infof(fmt.Sprintf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, config.Config.ConfigFilePath)))
+			log.Printf("Template File written to %s", fmt.Sprintf(uiUtils.Purple, config.Config.ConfigFilePath))
 		} else {
 			template, err := uiUtils.PrettyYaml(configWithDefaults)
 			if err != nil {
-				logger.Log.Errorf("Failed converting config with defaults to yaml, err: %v", err)
+				log.Printf("Failed converting config with defaults to yaml, err: %v", err)
 				return nil
 			}
 
-			logger.Log.Debugf("Writing template config.\n%v", template)
+			log.Printf("Writing template config.\n%v", template)
 			fmt.Printf("%v", template)
 		}
 
@@ -48,7 +48,7 @@ func init() {
 
 	defaultConfig := config.CreateDefaultConfig()
 	if err := defaults.Set(&defaultConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	configCmd.Flags().BoolP(configStructs.RegenerateConfigName, "r", defaultConfig.Config.Regenerate, fmt.Sprintf("Regenerate the config file with default values to path %s or to chosen path using --%s", defaultConfig.ConfigFilePath, config.ConfigFilePathCommandName))

cmd/goUtils/funcWrappers.go

@@ -1,17 +1,16 @@
 package goUtils
 
 import (
+	"log"
 	"reflect"
 	"runtime/debug"
-
-	"github.com/kubeshark/kubeshark/logger"
 )
 
 func HandleExcWrapper(fn interface{}, params ...interface{}) (result []reflect.Value) {
 	defer func() {
 		if panicMessage := recover(); panicMessage != nil {
 			stack := debug.Stack()
-			logger.Log.Fatalf("Unhandled panic: %v\n stack: %s", panicMessage, stack)
+			log.Fatalf("Unhandled panic: %v\n stack: %s", panicMessage, stack)
 		}
 	}()
 	f := reflect.ValueOf(fn)

cmd/install.go

@@ -1,9 +1,10 @@
 package cmd
 
 import (
+	"log"
+
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -21,7 +22,7 @@ func init() {
 
 	defaultInstallConfig := configStructs.InstallConfig{}
 	if err := defaults.Set(&defaultInstallConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	installCmd.Flags().BoolP(configStructs.OutInstallName, "o", defaultInstallConfig.Out, "print (to stdout) Kubernetes manifest used to install Kubeshark Pro edition")

cmd/installRunner.go

@@ -2,11 +2,11 @@ package cmd
 
 import (
 	"fmt"
+	"log"
 	"strings"
 
-	"github.com/kubeshark/kubeshark/cli/bucket"
+	"github.com/kubeshark/kubeshark/bucket"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/logger"
 )
 
 func runKubesharkInstall() {
@@ -15,7 +15,7 @@ func runKubesharkInstall() {
 		bucketProvider := bucket.NewProvider(config.Config.Install.TemplateUrl, bucket.DefaultTimeout)
 		installTemplate, err := bucketProvider.GetInstallTemplate(config.Config.Install.TemplateName)
 		if err != nil {
-			logger.Log.Errorf("Failed getting install template, err: %v", err)
+			log.Printf("Failed getting install template, err: %v", err)
 			return
 		}
 

cmd/logs.go

@@ -2,13 +2,13 @@ package cmd
 
 import (
 	"context"
+	"log"
 
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/cli/errormessage"
+	"github.com/kubeshark/kubeshark/errormessage"
-	"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
+	"github.com/kubeshark/kubeshark/kubeshark/fsUtils"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -26,10 +26,10 @@ var logsCmd = &cobra.Command{
 			return errormessage.FormatError(validationErr)
 		}
 
-		logger.Log.Debugf("Using file path %s", config.Config.Logs.FilePath())
+		log.Printf("Using file path %s", config.Config.Logs.FilePath())
 
 		if dumpLogsErr := fsUtils.DumpLogs(ctx, kubernetesProvider, config.Config.Logs.FilePath()); dumpLogsErr != nil {
-			logger.Log.Errorf("Failed dump logs %v", dumpLogsErr)
+			log.Printf("Failed dump logs %v", dumpLogsErr)
 		}
 
 		return nil
@@ -41,7 +41,7 @@ func init() {
 
 	defaultLogsConfig := configStructs.LogsConfig{}
 	if err := defaults.Set(&defaultLogsConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	logsCmd.Flags().StringP(configStructs.FileLogsName, "f", defaultLogsConfig.FileStr, "Path for zip file (default current <pwd>\\kubeshark_logs.zip)")

cmd/root.go

@@ -2,15 +2,13 @@ package cmd
 
 import (
 	"fmt"
+	"log"
 	"time"
 
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubeshark/version"
-	"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/cli/kubeshark/version"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -21,7 +19,7 @@ var rootCmd = &cobra.Command{
 Further info is available at https://github.com/kubeshark/kubeshark`,
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
 		if err := config.InitConfig(cmd); err != nil {
-			logger.Log.Fatal(err)
+			log.Fatal(err)
 		}
 
 		return nil
@@ -31,7 +29,7 @@ Further info is available at https://github.com/kubeshark/kubeshark`,
 func init() {
 	defaultConfig := config.CreateDefaultConfig()
 	if err := defaults.Set(&defaultConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	rootCmd.PersistentFlags().StringSlice(config.SetCommandName, []string{}, fmt.Sprintf("Override values using --%s", config.SetCommandName))
@@ -42,7 +40,7 @@ func printNewVersionIfNeeded(versionChan chan string) {
 	select {
 	case versionMsg := <-versionChan:
 		if versionMsg != "" {
-			logger.Log.Infof(uiUtils.Yellow, versionMsg)
+			log.Printf(uiUtils.Yellow, versionMsg)
 		}
 	case <-time.After(2 * time.Second):
 	}
@@ -51,11 +49,6 @@ func printNewVersionIfNeeded(versionChan chan string) {
 // Execute adds all child commands to the root command and sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the tapCmd.
 func Execute() {
-	if err := fsUtils.EnsureDir(kubeshark.GetKubesharkFolderPath()); err != nil {
-		logger.Log.Errorf("Failed to use kubeshark folder, %v", err)
-	}
-	logger.InitLogger(fsUtils.GetLogFilePath())
-
 	versionChan := make(chan string)
 	defer printNewVersionIfNeeded(versionChan)
 	go version.CheckNewerVersion(versionChan)

cmd/tap.go

@@ -2,12 +2,12 @@ package cmd
 
 import (
 	"errors"
+	"log"
 
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/cli/errormessage"
+	"github.com/kubeshark/kubeshark/errormessage"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -31,7 +31,7 @@ Supported protocols are HTTP and gRPC.`,
 			return errormessage.FormatError(err)
 		}
 
-		logger.Log.Infof("Kubeshark will store up to %s of traffic, old traffic will be cleared once the limit is reached.", config.Config.Tap.HumanMaxEntriesDBSize)
+		log.Printf("Kubeshark will store up to %s of traffic, old traffic will be cleared once the limit is reached.", config.Config.Tap.HumanMaxEntriesDBSize)
 
 		return nil
 	},
@@ -42,7 +42,7 @@ func init() {
 
 	defaultTapConfig := configStructs.TapConfig{}
 	if err := defaults.Set(&defaultTapConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	tapCmd.Flags().Uint16P(configStructs.GuiPortTapName, "p", defaultTapConfig.GuiPort, "Provide a custom port for the web interface webserver")

cmd/tapRunner.go

@@ -4,27 +4,27 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
 	"regexp"
 	"strings"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/resources"
+	"github.com/kubeshark/kubeshark/resources"
-	"github.com/kubeshark/kubeshark/cli/utils"
+	"github.com/kubeshark/kubeshark/utils"
 
 	core "k8s.io/api/core/v1"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-	"github.com/kubeshark/kubeshark/cli/apiserver"
+	"github.com/kubeshark/kubeshark/apiserver"
-	"github.com/kubeshark/kubeshark/cli/cmd/goUtils"
+	"github.com/kubeshark/kubeshark/cmd/goUtils"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/cli/errormessage"
+	"github.com/kubeshark/kubeshark/errormessage"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 	"github.com/kubeshark/worker/api"
+	"github.com/kubeshark/worker/models"
 )
 
 const cleanupTimeout = time.Minute
@@ -59,43 +59,43 @@ func RunKubesharkTap() {
 	kubesharkAgentConfig := getTapKubesharkAgentConfig()
 	serializedKubesharkConfig, err := getSerializedKubesharkAgentConfig(kubesharkAgentConfig)
 	if err != nil {
-		logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error serializing kubeshark config: %v", errormessage.FormatError(err)))
+		log.Printf(uiUtils.Error, fmt.Sprintf("Error serializing kubeshark config: %v", errormessage.FormatError(err)))
 		return
 	}
 
 	if config.Config.IsNsRestrictedMode() {
-		if len(state.targetNamespaces) != 1 || !shared.Contains(state.targetNamespaces, config.Config.KubesharkResourcesNamespace) {
+		if len(state.targetNamespaces) != 1 || !utils.Contains(state.targetNamespaces, config.Config.KubesharkResourcesNamespace) {
-			logger.Log.Errorf("Not supported mode. Kubeshark can't resolve IPs in other namespaces when running in namespace restricted mode.\n"+
+			log.Printf("Not supported mode. Kubeshark can't resolve IPs in other namespaces when running in namespace restricted mode.\n"+
 				"You can use the same namespace for --%s and --%s", configStructs.NamespacesTapName, config.KubesharkResourcesNamespaceConfigName)
 			return
 		}
 	}
 
 	var namespacesStr string
-	if !shared.Contains(state.targetNamespaces, kubernetes.K8sAllNamespaces) {
+	if !utils.Contains(state.targetNamespaces, kubernetes.K8sAllNamespaces) {
 		namespacesStr = fmt.Sprintf("namespaces \"%s\"", strings.Join(state.targetNamespaces, "\", \""))
 	} else {
 		namespacesStr = "all namespaces"
 	}
 
-	logger.Log.Infof("Tapping pods in %s", namespacesStr)
+	log.Printf("Tapping pods in %s", namespacesStr)
 
 	if err := printTappedPodsPreview(ctx, kubernetesProvider, state.targetNamespaces); err != nil {
-		logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error listing pods: %v", errormessage.FormatError(err)))
+		log.Printf(uiUtils.Error, fmt.Sprintf("Error listing pods: %v", errormessage.FormatError(err)))
 	}
 
 	if config.Config.Tap.DryRun {
 		return
 	}
 
-	logger.Log.Infof("Waiting for Kubeshark Agent to start...")
+	log.Printf("Waiting for Kubeshark Agent to start...")
 	if state.kubesharkServiceAccountExists, err = resources.CreateTapKubesharkResources(ctx, kubernetesProvider, serializedKubesharkConfig, config.Config.IsNsRestrictedMode(), config.Config.KubesharkResourcesNamespace, config.Config.AgentImage, config.Config.Tap.MaxEntriesDBSizeBytes(), config.Config.Tap.ApiServerResources, config.Config.ImagePullPolicy(), config.Config.LogLevel(), config.Config.Tap.Profiler); err != nil {
 		var statusError *k8serrors.StatusError
 		if errors.As(err, &statusError) && (statusError.ErrStatus.Reason == metav1.StatusReasonAlreadyExists) {
-			logger.Log.Info("Kubeshark is already running in this namespace, change the `kubeshark-resources-namespace` configuration or run `kubeshark clean` to remove the currently running Kubeshark instance")
+			log.Print("Kubeshark is already running in this namespace, change the `kubeshark-resources-namespace` configuration or run `kubeshark clean` to remove the currently running Kubeshark instance")
 		} else {
 			defer resources.CleanUpKubesharkResources(ctx, cancel, kubernetesProvider, config.Config.IsNsRestrictedMode(), config.Config.KubesharkResourcesNamespace)
-			logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error creating resources: %v", errormessage.FormatError(err)))
+			log.Printf(uiUtils.Error, fmt.Sprintf("Error creating resources: %v", errormessage.FormatError(err)))
 		}
 
 		return
@@ -115,8 +115,8 @@ func finishTapExecution(kubernetesProvider *kubernetes.Provider) {
 	finishKubesharkExecution(kubernetesProvider, config.Config.IsNsRestrictedMode(), config.Config.KubesharkResourcesNamespace)
 }
 
-func getTapKubesharkAgentConfig() *shared.KubesharkAgentConfig {
+func getTapKubesharkAgentConfig() *models.Config {
-	kubesharkAgentConfig := shared.KubesharkAgentConfig{
+	kubesharkAgentConfig := models.Config{
 		MaxDBSizeBytes:              config.Config.Tap.MaxEntriesDBSizeBytes(),
 		InsertionFilter:             config.Config.Tap.GetInsertionFilter(),
 		AgentImage:                  config.Config.AgentImage,
@@ -124,7 +124,7 @@ func getTapKubesharkAgentConfig() *shared.KubesharkAgentConfig {
 		LogLevel:                    config.Config.LogLevel(),
 		TapperResources:             config.Config.Tap.TapperResources,
 		KubesharkResourcesNamespace: config.Config.KubesharkResourcesNamespace,
-		AgentDatabasePath:           shared.DataDirPath,
+		AgentDatabasePath:           models.DataDirPath,
 		ServiceMap:                  config.Config.ServiceMap,
 		OAS:                         config.Config.OAS,
 	}
@@ -145,7 +145,7 @@ func printTappedPodsPreview(ctx context.Context, kubernetesProvider *kubernetes.
 			printNoPodsFoundSuggestion(namespaces)
 		}
 		for _, tappedPod := range matchingPods {
-			logger.Log.Infof(uiUtils.Green, fmt.Sprintf("+%s", tappedPod.Name))
+			log.Printf(uiUtils.Green, fmt.Sprintf("+%s", tappedPod.Name))
 		}
 		return nil
 	}
@@ -178,29 +178,29 @@ func startTapperSyncer(ctx context.Context, cancel context.CancelFunc, provider
 			select {
 			case syncerErr, ok := <-tapperSyncer.ErrorOut:
 				if !ok {
-					logger.Log.Debug("kubesharkTapperSyncer err channel closed, ending listener loop")
+					log.Print("kubesharkTapperSyncer err channel closed, ending listener loop")
 					return
 				}
-				logger.Log.Errorf(uiUtils.Error, getErrorDisplayTextForK8sTapManagerError(syncerErr))
+				log.Printf(uiUtils.Error, getErrorDisplayTextForK8sTapManagerError(syncerErr))
 				cancel()
 			case _, ok := <-tapperSyncer.TapPodChangesOut:
 				if !ok {
-					logger.Log.Debug("kubesharkTapperSyncer pod changes channel closed, ending listener loop")
+					log.Print("kubesharkTapperSyncer pod changes channel closed, ending listener loop")
 					return
 				}
 				if err := apiProvider.ReportTappedPods(tapperSyncer.CurrentlyTappedPods); err != nil {
-					logger.Log.Debugf("[Error] failed update tapped pods %v", err)
+					log.Printf("[Error] failed update tapped pods %v", err)
 				}
 			case tapperStatus, ok := <-tapperSyncer.TapperStatusChangedOut:
 				if !ok {
-					logger.Log.Debug("kubesharkTapperSyncer tapper status changed channel closed, ending listener loop")
+					log.Print("kubesharkTapperSyncer tapper status changed channel closed, ending listener loop")
 					return
 				}
 				if err := apiProvider.ReportTapperStatus(tapperStatus); err != nil {
-					logger.Log.Debugf("[Error] failed update tapper status %v", err)
+					log.Printf("[Error] failed update tapper status %v", err)
 				}
 			case <-ctx.Done():
-				logger.Log.Debug("kubesharkTapperSyncer event listener loop exiting due to context done")
+				log.Print("kubesharkTapperSyncer event listener loop exiting due to context done")
 				return
 			}
 		}
@@ -211,10 +211,10 @@ func startTapperSyncer(ctx context.Context, cancel context.CancelFunc, provider
 
 func printNoPodsFoundSuggestion(targetNamespaces []string) {
 	var suggestionStr string
-	if !shared.Contains(targetNamespaces, kubernetes.K8sAllNamespaces) {
+	if !utils.Contains(targetNamespaces, kubernetes.K8sAllNamespaces) {
 		suggestionStr = ". You can also try selecting a different namespace with -n or tap all namespaces with -A"
 	}
-	logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Did not find any currently running pods that match the regex argument, kubeshark will automatically tap matching pods if any are created later%s", suggestionStr))
+	log.Printf(uiUtils.Warning, fmt.Sprintf("Did not find any currently running pods that match the regex argument, kubeshark will automatically tap matching pods if any are created later%s", suggestionStr))
 }
 
 func getErrorDisplayTextForK8sTapManagerError(err kubernetes.K8sTapManagerError) string {
@@ -248,20 +248,20 @@ func watchApiServerPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 
 			switch wEvent.Type {
 			case kubernetes.EventAdded:
-				logger.Log.Debugf("Watching API Server pod loop, added")
+				log.Printf("Watching API Server pod loop, added")
 			case kubernetes.EventDeleted:
-				logger.Log.Infof("%s removed", kubernetes.ApiServerPodName)
+				log.Printf("%s removed", kubernetes.ApiServerPodName)
 				cancel()
 				return
 			case kubernetes.EventModified:
 				modifiedPod, err := wEvent.ToPod()
 				if err != nil {
-					logger.Log.Errorf(uiUtils.Error, err)
+					log.Printf(uiUtils.Error, err)
 					cancel()
 					continue
 				}
 
-				logger.Log.Debugf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
+				log.Printf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
 
 				if modifiedPod.Status.Phase == core.PodRunning && !isPodReady {
 					isPodReady = true
@@ -284,16 +284,16 @@ func watchApiServerPod(ctx context.Context, kubernetesProvider *kubernetes.Provi
 				continue
 			}
 
-			logger.Log.Errorf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
+			log.Printf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
 			cancel()
 
 		case <-timeAfter:
 			if !isPodReady {
-				logger.Log.Errorf(uiUtils.Error, "Kubeshark API server was not ready in time")
+				log.Printf(uiUtils.Error, "Kubeshark API server was not ready in time")
 				cancel()
 			}
 		case <-ctx.Done():
-			logger.Log.Debugf("Watching API Server pod loop, ctx done")
+			log.Printf("Watching API Server pod loop, ctx done")
 			return
 		}
 	}
@@ -317,20 +317,20 @@ func watchFrontPod(ctx context.Context, kubernetesProvider *kubernetes.Provider,
 
 			switch wEvent.Type {
 			case kubernetes.EventAdded:
-				logger.Log.Debugf("Watching API Server pod loop, added")
+				log.Printf("Watching API Server pod loop, added")
 			case kubernetes.EventDeleted:
-				logger.Log.Infof("%s removed", "front")
+				log.Printf("%s removed", "front")
 				cancel()
 				return
 			case kubernetes.EventModified:
 				modifiedPod, err := wEvent.ToPod()
 				if err != nil {
-					logger.Log.Errorf(uiUtils.Error, err)
+					log.Printf(uiUtils.Error, err)
 					cancel()
 					continue
 				}
 
-				logger.Log.Debugf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
+				log.Printf("Watching API Server pod loop, modified: %v, containers statuses: %v", modifiedPod.Status.Phase, modifiedPod.Status.ContainerStatuses)
 
 				if modifiedPod.Status.Phase == core.PodRunning && !isPodReady {
 					isPodReady = true
@@ -352,16 +352,16 @@ func watchFrontPod(ctx context.Context, kubernetesProvider *kubernetes.Provider,
 				continue
 			}
 
-			logger.Log.Errorf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
+			log.Printf("[ERROR] Agent creation, watching %v namespace, error: %v", config.Config.KubesharkResourcesNamespace, err)
 			cancel()
 
 		case <-timeAfter:
 			if !isPodReady {
-				logger.Log.Errorf(uiUtils.Error, "Kubeshark API server was not ready in time")
+				log.Printf(uiUtils.Error, "Kubeshark API server was not ready in time")
 				cancel()
 			}
 		case <-ctx.Done():
-			logger.Log.Debugf("Watching API Server pod loop, ctx done")
+			log.Printf("Watching API Server pod loop, ctx done")
 			return
 		}
 	}
@@ -381,7 +381,7 @@ func watchApiServerEvents(ctx context.Context, kubernetesProvider *kubernetes.Pr
 
 			event, err := wEvent.ToEvent()
 			if err != nil {
-				logger.Log.Debugf("[ERROR] parsing Kubeshark resource event: %+v", err)
+				log.Printf("[ERROR] parsing Kubeshark resource event: %+v", err)
 				continue
 			}
 
@@ -389,18 +389,19 @@ func watchApiServerEvents(ctx context.Context, kubernetesProvider *kubernetes.Pr
 				continue
 			}
 
-			logger.Log.Debugf(
+			log.Printf(
-				fmt.Sprintf("Watching API server events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
+				"Watching API server events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
-					event.Name,
+				event.Name,
-					event.CreationTimestamp.Time,
+				event.CreationTimestamp.Time,
-					event.Regarding.Name,
+				event.Regarding.Name,
-					event.Regarding.Kind,
+				event.Regarding.Kind,
-					event.Reason,
+				event.Reason,
-					event.Note))
+				event.Note,
+			)
 
 			switch event.Reason {
 			case "FailedScheduling", "Failed":
-				logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Kubeshark API Server status: %s - %s", event.Reason, event.Note))
+				log.Printf(uiUtils.Error, fmt.Sprintf("Kubeshark API Server status: %s - %s", event.Reason, event.Note))
 				cancel()
 
 			}
@@ -410,9 +411,9 @@ func watchApiServerEvents(ctx context.Context, kubernetesProvider *kubernetes.Pr
 				continue
 			}
 
-			logger.Log.Debugf("[Error] Watching API server events loop, error: %+v", err)
+			log.Printf("[Error] Watching API server events loop, error: %+v", err)
 		case <-ctx.Done():
-			logger.Log.Debugf("Watching API server events loop, ctx done")
+			log.Printf("Watching API server events loop, ctx done")
 			return
 		}
 	}
@@ -422,19 +423,19 @@ func postApiServerStarted(ctx context.Context, kubernetesProvider *kubernetes.Pr
 	startProxyReportErrorIfAny(kubernetesProvider, ctx, cancel, "kubeshark-api-server", config.Config.Hub.PortForward.SrcPort, config.Config.Hub.PortForward.DstPort, "/echo")
 
 	if err := startTapperSyncer(ctx, cancel, kubernetesProvider, state.targetNamespaces, state.startTime); err != nil {
-		logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error starting kubeshark tapper syncer: %v", errormessage.FormatError(err)))
+		log.Printf(uiUtils.Error, fmt.Sprintf("Error starting kubeshark tapper syncer: %v", errormessage.FormatError(err)))
 		cancel()
 	}
 
 	url := kubernetes.GetLocalhostOnPort(config.Config.Hub.PortForward.SrcPort)
-	logger.Log.Infof("API Server is available at %s", url)
+	log.Printf("API Server is available at %s", url)
 }
 
 func postFrontStarted(ctx context.Context, kubernetesProvider *kubernetes.Provider, cancel context.CancelFunc) {
 	startProxyReportErrorIfAny(kubernetesProvider, ctx, cancel, "front", config.Config.Front.PortForward.SrcPort, config.Config.Front.PortForward.DstPort, "")
 
 	url := kubernetes.GetLocalhostOnPort(config.Config.Front.PortForward.SrcPort)
-	logger.Log.Infof("Kubeshark is available at %s", url)
+	log.Printf("Kubeshark is available at %s", url)
 	if !config.Config.HeadlessMode {
 		uiUtils.OpenBrowser(url)
 	}
@@ -444,11 +445,11 @@ func getNamespaces(kubernetesProvider *kubernetes.Provider) []string {
 	if config.Config.Tap.AllNamespaces {
 		return []string{kubernetes.K8sAllNamespaces}
 	} else if len(config.Config.Tap.Namespaces) > 0 {
-		return shared.Unique(config.Config.Tap.Namespaces)
+		return utils.Unique(config.Config.Tap.Namespaces)
 	} else {
 		currentNamespace, err := kubernetesProvider.CurrentNamespace()
 		if err != nil {
-			logger.Log.Fatalf(uiUtils.Red, fmt.Sprintf("error getting current namespace: %+v", err))
+			log.Fatalf(uiUtils.Red, fmt.Sprintf("error getting current namespace: %+v", err))
 		}
 		return []string{currentNamespace}
 	}

cmd/version.go

@@ -1,15 +1,15 @@
 package cmd
 
 import (
+	"log"
 	"strconv"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/logger"
 
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubeshark"
 	"github.com/spf13/cobra"
 )
 
@@ -19,11 +19,11 @@ var versionCmd = &cobra.Command{
 	RunE: func(cmd *cobra.Command, args []string) error {
 		if config.Config.Version.DebugInfo {
 			timeStampInt, _ := strconv.ParseInt(kubeshark.BuildTimestamp, 10, 0)
-			logger.Log.Infof("Version: %s \nBranch: %s (%s)", kubeshark.Ver, kubeshark.Branch, kubeshark.GitCommitHash)
+			log.Printf("Version: %s \nBranch: %s (%s)", kubeshark.Ver, kubeshark.Branch, kubeshark.GitCommitHash)
-			logger.Log.Infof("Build Time: %s (%s)", kubeshark.BuildTimestamp, time.Unix(timeStampInt, 0))
+			log.Printf("Build Time: %s (%s)", kubeshark.BuildTimestamp, time.Unix(timeStampInt, 0))
 
 		} else {
-			logger.Log.Infof("Version: %s (%s)", kubeshark.Ver, kubeshark.Branch)
+			log.Printf("Version: %s (%s)", kubeshark.Ver, kubeshark.Branch)
 		}
 		return nil
 	},
@@ -34,7 +34,7 @@ func init() {
 
 	defaultVersionConfig := configStructs.VersionConfig{}
 	if err := defaults.Set(&defaultVersionConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	versionCmd.Flags().BoolP(configStructs.DebugInfoVersionName, "d", defaultVersionConfig.DebugInfo, "Provide all information about version")

cmd/view.go

@@ -1,9 +1,10 @@
 package cmd
 
 import (
+	"log"
+
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -21,13 +22,13 @@ func init() {
 
 	defaultViewConfig := configStructs.ViewConfig{}
 	if err := defaults.Set(&defaultViewConfig); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 
 	viewCmd.Flags().Uint16P(configStructs.GuiPortViewName, "p", defaultViewConfig.GuiPort, "Provide a custom port for the web interface webserver")
 	viewCmd.Flags().StringP(configStructs.UrlViewName, "u", defaultViewConfig.Url, "Provide a custom host")
 
 	if err := viewCmd.Flags().MarkHidden(configStructs.UrlViewName); err != nil {
-		logger.Log.Debug(err)
+		log.Print(err)
 	}
 }

cmd/viewRunner.go

@@ -3,16 +3,15 @@ package cmd
 import (
 	"context"
 	"fmt"
+	"log"
 	"net/http"
 
-	"github.com/kubeshark/kubeshark/cli/utils"
+	"github.com/kubeshark/kubeshark/utils"
 
-	"github.com/kubeshark/kubeshark/cli/apiserver"
+	"github.com/kubeshark/kubeshark/apiserver"
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 )
 
 func runKubesharkView() {
@@ -29,12 +28,12 @@ func runKubesharkView() {
 	if url == "" {
 		exists, err := kubernetesProvider.DoesServiceExist(ctx, config.Config.KubesharkResourcesNamespace, kubernetes.ApiServerPodName)
 		if err != nil {
-			logger.Log.Errorf("Failed to found kubeshark service %v", err)
+			log.Printf("Failed to found kubeshark service %v", err)
 			cancel()
 			return
 		}
 		if !exists {
-			logger.Log.Infof("%s service not found, you should run `kubeshark tap` command first", kubernetes.ApiServerPodName)
+			log.Printf("%s service not found, you should run `kubeshark tap` command first", kubernetes.ApiServerPodName)
 			cancel()
 			return
 		}
@@ -43,20 +42,20 @@ func runKubesharkView() {
 
 		response, err := http.Get(fmt.Sprintf("%s/", url))
 		if err == nil && response.StatusCode == 200 {
-			logger.Log.Infof("Found a running service %s and open port %d", kubernetes.ApiServerPodName, config.Config.Front.PortForward.SrcPort)
+			log.Printf("Found a running service %s and open port %d", kubernetes.ApiServerPodName, config.Config.Front.PortForward.SrcPort)
 			return
 		}
-		logger.Log.Infof("Establishing connection to k8s cluster...")
+		log.Printf("Establishing connection to k8s cluster...")
 		startProxyReportErrorIfAny(kubernetesProvider, ctx, cancel, "front", config.Config.Front.PortForward.SrcPort, config.Config.Front.PortForward.DstPort, "")
 	}
 
 	apiServerProvider := apiserver.NewProvider(url, apiserver.DefaultRetries, apiserver.DefaultTimeout)
 	if err := apiServerProvider.TestConnection(""); err != nil {
-		logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Couldn't connect to API server, for more info check logs at %s", fsUtils.GetLogFilePath()))
+		log.Printf(uiUtils.Error, "Couldn't connect to API server.")
 		return
 	}
 
-	logger.Log.Infof("Kubeshark is available at %s", url)
+	log.Printf("Kubeshark is available at %s", url)
 
 	if !config.Config.HeadlessMode {
 		uiUtils.OpenBrowser(url)

config/config.go

@@ -4,16 +4,15 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"reflect"
 	"strconv"
 	"strings"
 
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared"
-
 	"github.com/creasty/defaults"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
+	"github.com/kubeshark/kubeshark/utils"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 	"gopkg.in/yaml.v3"
@@ -67,7 +66,7 @@ func InitConfig(cmd *cobra.Command) error {
 	}
 
 	finalConfigPrettified, _ := uiUtils.PrettyJson(Config)
-	logger.Log.Debugf("Init config finished\n Final config: %v", finalConfigPrettified)
+	log.Printf("Init config finished\n Final config: %v", finalConfigPrettified)
 
 	return nil
 }
@@ -113,7 +112,7 @@ func loadConfigFile(configFilePath string, config *ConfigStruct) error {
 		return err
 	}
 
-	logger.Log.Debugf("Found config file, config path: %s", configFilePath)
+	log.Printf("Found config file, config path: %s", configFilePath)
 
 	return nil
 }
@@ -122,7 +121,7 @@ func initFlag(f *pflag.Flag) {
 	configElemValue := reflect.ValueOf(&Config).Elem()
 
 	var flagPath []string
-	if shared.Contains([]string{ConfigFilePathCommandName}, f.Name) {
+	if utils.Contains([]string{ConfigFilePathCommandName}, f.Name) {
 		flagPath = []string{f.Name}
 	} else {
 		flagPath = []string{cmdName, f.Name}
@@ -131,20 +130,20 @@ func initFlag(f *pflag.Flag) {
 	sliceValue, isSliceValue := f.Value.(pflag.SliceValue)
 	if !isSliceValue {
 		if err := mergeFlagValue(configElemValue, flagPath, strings.Join(flagPath, "."), f.Value.String()); err != nil {
-			logger.Log.Warningf(uiUtils.Warning, err)
+			log.Printf(uiUtils.Warning, err)
 		}
 		return
 	}
 
 	if f.Name == SetCommandName {
 		if err := mergeSetFlag(configElemValue, sliceValue.GetSlice()); err != nil {
-			logger.Log.Warningf(uiUtils.Warning, err)
+			log.Printf(uiUtils.Warning, err)
 		}
 		return
 	}
 
 	if err := mergeFlagValues(configElemValue, flagPath, strings.Join(flagPath, "."), sliceValue.GetSlice()); err != nil {
-		logger.Log.Warningf(uiUtils.Warning, err)
+		log.Printf(uiUtils.Warning, err)
 	}
 }
 

config/configStruct.go

@@ -6,9 +6,10 @@ import (
 	"path"
 	"path/filepath"
 
-	"github.com/kubeshark/kubeshark/cli/config/configStructs"
+	"github.com/kubeshark/kubeshark/config/configStructs"
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubeshark"
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/kubeshark/utils"
+	"github.com/kubeshark/worker/models"
 	"github.com/op/go-logging"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/util/homedir"
@@ -73,7 +74,7 @@ type ConfigStruct struct {
 	HeadlessMode                bool                        `yaml:"headless" default:"false"`
 	LogLevelStr                 string                      `yaml:"log-level,omitempty" default:"INFO" readonly:""`
 	ServiceMap                  bool                        `yaml:"service-map" default:"true"`
-	OAS                         shared.OASConfig            `yaml:"oas"`
+	OAS                         models.OASConfig            `yaml:"oas"`
 }
 
 func (config *ConfigStruct) validate() error {
@@ -85,7 +86,7 @@ func (config *ConfigStruct) validate() error {
 }
 
 func (config *ConfigStruct) SetDefaults() {
-	config.AgentImage = fmt.Sprintf("%s:%s", shared.KubesharkAgentImageRepo, kubeshark.Ver)
+	config.AgentImage = fmt.Sprintf("%s:%s", utils.KubesharkAgentImageRepo, kubeshark.Ver)
 	config.ConfigFilePath = path.Join(kubeshark.GetKubesharkFolderPath(), "config.yaml")
 }
 

config/configStructs/tapConfig.go

@@ -3,15 +3,15 @@ package configStructs
 import (
 	"fmt"
 	"io/fs"
+	"log"
 	"os"
 	"regexp"
 	"strings"
 
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/worker/models"
 
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/units"
-	"github.com/kubeshark/kubeshark/shared/units"
 )
 
 const (
@@ -46,8 +46,8 @@ type TapConfig struct {
 	HumanMaxEntriesDBSize string           `yaml:"max-entries-db-size" default:"200MB"`
 	InsertionFilter       string           `yaml:"insertion-filter" default:""`
 	DryRun                bool             `yaml:"dry-run" default:"false"`
-	ApiServerResources    shared.Resources `yaml:"api-server-resources"`
+	ApiServerResources    models.Resources `yaml:"api-server-resources"`
-	TapperResources       shared.Resources `yaml:"tapper-resources"`
+	TapperResources       models.Resources `yaml:"tapper-resources"`
 	ServiceMesh           bool             `yaml:"service-mesh" default:"false"`
 	Tls                   bool             `yaml:"tls" default:"false"`
 	PacketCapture         string           `yaml:"packet-capture" default:"libpcap"`
@@ -71,7 +71,7 @@ func (config *TapConfig) GetInsertionFilter() string {
 		if _, err := os.Stat(insertionFilter); err == nil {
 			b, err := os.ReadFile(insertionFilter)
 			if err != nil {
-				logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Couldn't read the file on path: %s, err: %v", insertionFilter, err))
+				log.Printf(uiUtils.Warning, fmt.Sprintf("Couldn't read the file on path: %s, err: %v", insertionFilter, err))
 			} else {
 				insertionFilter = string(b)
 			}

config/config_test.go

@@ -2,11 +2,12 @@ package config_test
 
 import (
 	"fmt"
-	"github.com/kubeshark/kubeshark/cli/config"
-	"gopkg.in/yaml.v3"
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/kubeshark/kubeshark/config"
+	"gopkg.in/yaml.v3"
 )
 
 func TestConfigWriteIgnoresReadonlyFields(t *testing.T) {

errormessage/errormessage.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	regexpsyntax "regexp/syntax"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
 
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 )

go.mod

@@ -1,13 +1,12 @@
-module github.com/kubeshark/kubeshark/cli
+module github.com/kubeshark/kubeshark
 
 go 1.17
 
 require (
 	github.com/creasty/defaults v1.5.2
+	github.com/docker/go-units v0.4.0
 	github.com/google/go-github/v37 v37.0.0
-	github.com/kubeshark/kubeshark/logger v0.0.0
+	github.com/kubeshark/worker v0.1.4
-	github.com/kubeshark/kubeshark/shared v0.0.0
-	github.com/kubeshark/worker v0.1.1
 	github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
 	github.com/spf13/cobra v1.3.0
 	github.com/spf13/pflag v1.0.5
@@ -15,6 +14,7 @@ require (
 	k8s.io/api v0.23.3
 	k8s.io/apimachinery v0.23.3
 	k8s.io/client-go v0.23.3
+	k8s.io/kubectl v0.23.3
 )
 
 require (
@@ -31,7 +31,6 @@ require (
 	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
 	github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/docker/go-units v0.4.0 // indirect
 	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
 	github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
 	github.com/fvbommel/sortorder v1.0.2 // indirect
@@ -69,6 +68,7 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday v1.6.0 // indirect
 	github.com/stretchr/testify v1.7.0 // indirect
+	github.com/up9inc/basenine/client/go v0.0.0-20220612112747-3b28eeac9c51 // indirect
 	github.com/xlab/treeprint v1.1.0 // indirect
 	go.starlark.net v0.0.0-20220203230714-bb14e151c28f // indirect
 	golang.org/x/crypto v0.0.0-20220208050332-20e1d8d225ab // indirect
@@ -86,7 +86,6 @@ require (
 	k8s.io/component-base v0.23.3 // indirect
 	k8s.io/klog/v2 v2.40.1 // indirect
 	k8s.io/kube-openapi v0.0.0-20220124234850-424119656bbf // indirect
-	k8s.io/kubectl v0.23.3 // indirect
 	k8s.io/utils v0.0.0-20220127004650-9b3446523e65 // indirect
 	sigs.k8s.io/json v0.0.0-20211208200746-9f7c6b3444d2 // indirect
 	sigs.k8s.io/kustomize/api v0.11.1 // indirect
@@ -94,7 +93,3 @@ require (
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
 )
-
-replace github.com/kubeshark/kubeshark/logger v0.0.0 => ../logger
-
-replace github.com/kubeshark/kubeshark/shared v0.0.0 => ../shared

go.sum

@@ -423,8 +423,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kubeshark/worker v0.1.1 h1:asXRzJWZHVlbanihsk8ycCwnEJDmr611VQtA/KVDeDg=
+github.com/kubeshark/worker v0.1.4 h1:N6Lfy74efzsVK9MqHNqRtJv+iHUH/8/ri2drDgC7HsA=
-github.com/kubeshark/worker v0.1.1/go.mod h1:tvLnSvCKq7D8KB1RTYXybvHGkusBaHEFpv1ya4sgUAw=
+github.com/kubeshark/worker v0.1.4/go.mod h1:VuTJRuOuercnTyYZCwuW/+f4BSjqh6CnBWqsRwY4Xic=
 github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de h1:9TO3cAIGXtEhnIaL+V+BEER86oLrvS+kWobKpbJuye0=
 github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de/go.mod h1:zAbeS9B/r2mtpb6U+EI2rYA5OAXxsYw6wTamcNW+zcE=
 github.com/lithammer/dedent v1.1.0/go.mod h1:jrXYCQtgg0nJiN+StA2KgR7w6CiQNv9Fd/Z9BP0jIOc=
@@ -614,6 +614,7 @@ github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hM
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/up9inc/basenine/client/go v0.0.0-20220612112747-3b28eeac9c51 h1:6op+PUYmTlxze3V3f30lWKix3sWqv1M9rvRhyaxbsdQ=
 github.com/up9inc/basenine/client/go v0.0.0-20220612112747-3b28eeac9c51/go.mod h1:SvJGPoa/6erhUQV7kvHBwM/0x5LyO6XaG2lUaCaKiUI=
 github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=

kubernetes/kubesharkTapperSyncer.go

@@ -3,13 +3,14 @@ package kubernetes
 import (
 	"context"
 	"fmt"
+	"log"
 	"regexp"
 	"time"
 
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/debounce"
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/kubeshark/utils"
-	"github.com/kubeshark/kubeshark/shared/debounce"
 	"github.com/kubeshark/worker/api"
+	"github.com/kubeshark/worker/models"
 	"github.com/op/go-logging"
 	core "k8s.io/api/core/v1"
 )
@@ -29,9 +30,9 @@ type KubesharkTapperSyncer struct {
 	config                 TapperSyncerConfig
 	kubernetesProvider     *Provider
 	TapPodChangesOut       chan TappedPodChangeEvent
-	TapperStatusChangedOut chan shared.TapperStatus
+	TapperStatusChangedOut chan models.TapperStatus
 	ErrorOut               chan K8sTapManagerError
-	nodeToTappedPodMap     shared.NodeToPodsMap
+	nodeToTappedPodMap     models.NodeToPodsMap
 	tappedNodes            []string
 }
 
@@ -40,7 +41,7 @@ type TapperSyncerConfig struct {
 	PodFilterRegex                regexp.Regexp
 	KubesharkResourcesNamespace   string
 	AgentImage                    string
-	TapperResources               shared.Resources
+	TapperResources               models.Resources
 	ImagePullPolicy               core.PullPolicy
 	LogLevel                      logging.Level
 	KubesharkApiFilteringOptions  api.TrafficFilteringOptions
@@ -58,7 +59,7 @@ func CreateAndStartKubesharkTapperSyncer(ctx context.Context, kubernetesProvider
 		config:                 config,
 		kubernetesProvider:     kubernetesProvider,
 		TapPodChangesOut:       make(chan TappedPodChangeEvent, 100),
-		TapperStatusChangedOut: make(chan shared.TapperStatus, 100),
+		TapperStatusChangedOut: make(chan models.TapperStatus, 100),
 		ErrorOut:               make(chan K8sTapManagerError, 100),
 	}
 
@@ -91,13 +92,13 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperPods() {
 
 			pod, err := wEvent.ToPod()
 			if err != nil {
-				logger.Log.Debugf("[ERROR] parsing Kubeshark resource pod: %+v", err)
+				log.Printf("[ERROR] parsing Kubeshark resource pod: %+v", err)
 				continue
 			}
 
-			logger.Log.Debugf("Watching tapper pods loop, tapper: %v, node: %v, status: %v", pod.Name, pod.Spec.NodeName, pod.Status.Phase)
+			log.Printf("Watching tapper pods loop, tapper: %v, node: %v, status: %v", pod.Name, pod.Spec.NodeName, pod.Status.Phase)
 			if pod.Spec.NodeName != "" {
-				tapperStatus := shared.TapperStatus{TapperName: pod.Name, NodeName: pod.Spec.NodeName, Status: string(pod.Status.Phase)}
+				tapperStatus := models.TapperStatus{TapperName: pod.Name, NodeName: pod.Spec.NodeName, Status: string(pod.Status.Phase)}
 				tapperSyncer.TapperStatusChangedOut <- tapperStatus
 			}
 
@@ -106,10 +107,10 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperPods() {
 				errorChan = nil
 				continue
 			}
-			logger.Log.Debugf("[ERROR] Watching tapper pods loop, error: %+v", err)
+			log.Printf("[ERROR] Watching tapper pods loop, error: %+v", err)
 
 		case <-tapperSyncer.context.Done():
-			logger.Log.Debugf("Watching tapper pods loop, ctx done")
+			log.Printf("Watching tapper pods loop, ctx done")
 			return
 		}
 	}
@@ -130,22 +131,23 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperEvents() {
 
 			event, err := wEvent.ToEvent()
 			if err != nil {
-				logger.Log.Debugf("[ERROR] parsing Kubeshark resource event: %+v", err)
+				log.Printf("[ERROR] parsing Kubeshark resource event: %+v", err)
 				continue
 			}
 
-			logger.Log.Debugf(
+			log.Printf(
-				fmt.Sprintf("Watching tapper events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
+				"Watching tapper events loop, event %s, time: %v, resource: %s (%s), reason: %s, note: %s",
-					event.Name,
+				event.Name,
-					event.CreationTimestamp.Time,
+				event.CreationTimestamp.Time,
-					event.Regarding.Name,
+				event.Regarding.Name,
-					event.Regarding.Kind,
+				event.Regarding.Kind,
-					event.Reason,
+				event.Reason,
-					event.Note))
+				event.Note,
+			)
 
 			pod, err1 := tapperSyncer.kubernetesProvider.GetPod(tapperSyncer.context, tapperSyncer.config.KubesharkResourcesNamespace, event.Regarding.Name)
 			if err1 != nil {
-				logger.Log.Debugf(fmt.Sprintf("Couldn't get tapper pod %s", event.Regarding.Name))
+				log.Printf("Couldn't get tapper pod %s", event.Regarding.Name)
 				continue
 			}
 
@@ -156,7 +158,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperEvents() {
 				nodeName = pod.Spec.Affinity.NodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms[0].MatchFields[0].Values[0]
 			}
 
-			tapperStatus := shared.TapperStatus{TapperName: pod.Name, NodeName: nodeName, Status: string(pod.Status.Phase)}
+			tapperStatus := models.TapperStatus{TapperName: pod.Name, NodeName: nodeName, Status: string(pod.Status.Phase)}
 			tapperSyncer.TapperStatusChangedOut <- tapperStatus
 
 		case err, ok := <-errorChan:
@@ -165,10 +167,10 @@ func (tapperSyncer *KubesharkTapperSyncer) watchTapperEvents() {
 				continue
 			}
 
-			logger.Log.Debugf("[ERROR] Watching tapper events loop, error: %+v", err)
+			log.Printf("[ERROR] Watching tapper events loop, error: %+v", err)
 
 		case <-tapperSyncer.context.Done():
-			logger.Log.Debugf("Watching tapper events loop, ctx done")
+			log.Printf("Watching tapper events loop, ctx done")
 			return
 		}
 	}
@@ -188,7 +190,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
 		}
 
 		if !changeFound {
-			logger.Log.Debugf("Nothing changed update tappers not needed")
+			log.Printf("Nothing changed update tappers not needed")
 			return
 		}
 		if err := tapperSyncer.updateKubesharkTappers(); err != nil {
@@ -216,17 +218,17 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
 
 			switch wEvent.Type {
 			case EventAdded:
-				logger.Log.Debugf("Added matching pod %s, ns: %s", pod.Name, pod.Namespace)
+				log.Printf("Added matching pod %s, ns: %s", pod.Name, pod.Namespace)
 				if err := restartTappersDebouncer.SetOn(); err != nil {
-					logger.Log.Error(err)
+					log.Print(err)
 				}
 			case EventDeleted:
-				logger.Log.Debugf("Removed matching pod %s, ns: %s", pod.Name, pod.Namespace)
+				log.Printf("Removed matching pod %s, ns: %s", pod.Name, pod.Namespace)
 				if err := restartTappersDebouncer.SetOn(); err != nil {
-					logger.Log.Error(err)
+					log.Print(err)
 				}
 			case EventModified:
-				logger.Log.Debugf("Modified matching pod %s, ns: %s, phase: %s, ip: %s", pod.Name, pod.Namespace, pod.Status.Phase, pod.Status.PodIP)
+				log.Printf("Modified matching pod %s, ns: %s, phase: %s, ip: %s", pod.Name, pod.Namespace, pod.Status.Phase, pod.Status.PodIP)
 				// Act only if the modified pod has already obtained an IP address.
 				// After filtering for IPs, on a normal pod restart this includes the following events:
 				// - Pod deletion
@@ -235,7 +237,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
 				// Ready/unready transitions might also trigger this event.
 				if pod.Status.PodIP != "" {
 					if err := restartTappersDebouncer.SetOn(); err != nil {
-						logger.Log.Error(err)
+						log.Print(err)
 					}
 				}
 			case EventBookmark:
@@ -253,7 +255,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
 			continue
 
 		case <-tapperSyncer.context.Done():
-			logger.Log.Debugf("Watching pods loop, context done, stopping `restart tappers debouncer`")
+			log.Printf("Watching pods loop, context done, stopping `restart tappers debouncer`")
 			restartTappersDebouncer.Cancel()
 			// TODO: Does this also perform cleanup?
 			return
@@ -262,7 +264,7 @@ func (tapperSyncer *KubesharkTapperSyncer) watchPodsForTapping() {
 }
 
 func (tapperSyncer *KubesharkTapperSyncer) handleErrorInWatchLoop(err error, restartTappersDebouncer *debounce.Debouncer) {
-	logger.Log.Debugf("Watching pods loop, got error %v, stopping `restart tappers debouncer`", err)
+	log.Printf("Watching pods loop, got error %v, stopping `restart tappers debouncer`", err)
 	restartTappersDebouncer.Cancel()
 	tapperSyncer.ErrorOut <- K8sTapManagerError{
 		OriginalError:    err,
@@ -277,10 +279,10 @@ func (tapperSyncer *KubesharkTapperSyncer) updateCurrentlyTappedPods() (err erro
 		podsToTap := excludeKubesharkPods(matchingPods)
 		addedPods, removedPods := getPodArrayDiff(tapperSyncer.CurrentlyTappedPods, podsToTap)
 		for _, addedPod := range addedPods {
-			logger.Log.Debugf("tapping new pod %s", addedPod.Name)
+			log.Printf("tapping new pod %s", addedPod.Name)
 		}
 		for _, removedPod := range removedPods {
-			logger.Log.Debugf("pod %s is no longer running, tapping for it stopped", removedPod.Name)
+			log.Printf("pod %s is no longer running, tapping for it stopped", removedPod.Name)
 		}
 		if len(addedPods) > 0 || len(removedPods) > 0 {
 			tapperSyncer.CurrentlyTappedPods = podsToTap
@@ -303,12 +305,12 @@ func (tapperSyncer *KubesharkTapperSyncer) updateKubesharkTappers() error {
 		i++
 	}
 
-	if shared.EqualStringSlices(nodesToTap, tapperSyncer.tappedNodes) {
+	if utils.EqualStringSlices(nodesToTap, tapperSyncer.tappedNodes) {
-		logger.Log.Debug("Skipping apply, DaemonSet is up to date")
+		log.Print("Skipping apply, DaemonSet is up to date")
 		return nil
 	}
 
-	logger.Log.Debugf("Updating DaemonSet to run on nodes: %v", nodesToTap)
+	log.Printf("Updating DaemonSet to run on nodes: %v", nodesToTap)
 
 	if len(tapperSyncer.nodeToTappedPodMap) > 0 {
 		var serviceAccountName string
@@ -342,7 +344,7 @@ func (tapperSyncer *KubesharkTapperSyncer) updateKubesharkTappers() error {
 			return err
 		}
 
-		logger.Log.Debugf("Successfully created %v tappers", len(tapperSyncer.nodeToTappedPodMap))
+		log.Printf("Successfully created %v tappers", len(tapperSyncer.nodeToTappedPodMap))
 	} else {
 		if err := tapperSyncer.kubernetesProvider.ResetKubesharkTapperDaemonSet(
 			tapperSyncer.context,
@@ -353,7 +355,7 @@ func (tapperSyncer *KubesharkTapperSyncer) updateKubesharkTappers() error {
 			return err
 		}
 
-		logger.Log.Debugf("Successfully reset tapper daemon set")
+		log.Printf("Successfully reset tapper daemon set")
 	}
 
 	tapperSyncer.tappedNodes = nodesToTap

kubernetes/provider.go

@@ -7,15 +7,16 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log"
 	"net/url"
 	"path/filepath"
 	"regexp"
 	"strconv"
 
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/semver"
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/kubeshark/utils"
-	"github.com/kubeshark/kubeshark/shared/semver"
 	"github.com/kubeshark/worker/api"
+	"github.com/kubeshark/worker/models"
 	"github.com/op/go-logging"
 	auth "k8s.io/api/authorization/v1"
 	core "k8s.io/api/core/v1"
@@ -77,7 +78,7 @@ func NewProvider(kubeConfigPath string, contextName string) (*Provider, error) {
 			"you can set alternative kube config file path by adding the kube-config-path field to the kubeshark config file, err:  %w", kubeConfigPath, err)
 	}
 
-	logger.Log.Debugf("K8s client config, host: %s, api path: %s, user agent: %s", restClientConfig.Host, restClientConfig.APIPath, restClientConfig.UserAgent)
+	log.Printf("K8s client config, host: %s, api path: %s, user agent: %s", restClientConfig.Host, restClientConfig.APIPath, restClientConfig.UserAgent)
 
 	return &Provider{
 		clientSet:        clientSet,
@@ -178,7 +179,7 @@ type ApiServerOptions struct {
 	ServiceAccountName    string
 	IsNamespaceRestricted bool
 	MaxEntriesDBSizeBytes int64
-	Resources             shared.Resources
+	Resources             models.Resources
 	ImagePullPolicy       core.PullPolicy
 	LogLevel              logging.Level
 	Profiler              bool
@@ -220,7 +221,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
 	volumeMounts := []core.VolumeMount{
 		{
 			Name:      ConfigMapName,
-			MountPath: shared.ConfigDirPath,
+			MountPath: models.ConfigDirPath,
 		},
 	}
 	volumes := []core.Volume{
@@ -243,7 +244,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
 		})
 		volumeMounts = append(volumeMounts, core.VolumeMount{
 			Name:      volumeClaimName,
-			MountPath: shared.DataDirPath,
+			MountPath: models.DataDirPath,
 		})
 	}
 
@@ -256,7 +257,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
 			Command:         command,
 			Env: []core.EnvVar{
 				{
-					Name:  shared.LogLevelEnvVar,
+					Name:  utils.LogLevelEnvVar,
 					Value: opts.LogLevel.String(),
 				},
 			},
@@ -280,7 +281,7 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
 				FailureThreshold: 3,
 				ProbeHandler: core.ProbeHandler{
 					TCPSocket: &core.TCPSocketAction{
-						Port: intstr.Parse(shared.BaseninePort),
+						Port: intstr.Parse(utils.BaseninePort),
 					},
 				},
 				PeriodSeconds:    1,
@@ -298,8 +299,8 @@ func (provider *Provider) BuildApiServerPod(opts *ApiServerOptions, mountVolumeC
 				},
 			},
 			Command:    []string{"basenine"},
-			Args:       []string{"-addr", "0.0.0.0", "-port", shared.BaseninePort, "-persistent"},
+			Args:       []string{"-addr", "0.0.0.0", "-port", utils.BaseninePort, "-persistent"},
-			WorkingDir: shared.DataDirPath,
+			WorkingDir: models.DataDirPath,
 		},
 	}
 
@@ -452,7 +453,7 @@ func (provider *Provider) BuildFrontPod(opts *ApiServerOptions, mountVolumeClaim
 			},
 			Command:    []string{"nginx"},
 			Args:       []string{"-g", "daemon off;"},
-			WorkingDir: shared.DataDirPath,
+			WorkingDir: models.DataDirPath,
 		},
 	}
 
@@ -783,7 +784,7 @@ func (provider *Provider) handleRemovalError(err error) error {
 
 func (provider *Provider) CreateConfigMap(ctx context.Context, namespace string, configMapName string, serializedKubesharkConfig string) error {
 	configMapData := make(map[string]string)
-	configMapData[shared.ConfigFileName] = serializedKubesharkConfig
+	configMapData[models.ConfigFileName] = serializedKubesharkConfig
 
 	configMap := &core.ConfigMap{
 		TypeMeta: metav1.TypeMeta{
@@ -805,8 +806,8 @@ func (provider *Provider) CreateConfigMap(ctx context.Context, namespace string,
 	return nil
 }
 
-func (provider *Provider) ApplyKubesharkTapperDaemonSet(ctx context.Context, namespace string, daemonSetName string, podImage string, tapperPodName string, apiServerPodIp string, nodeNames []string, serviceAccountName string, resources shared.Resources, imagePullPolicy core.PullPolicy, kubesharkApiFilteringOptions api.TrafficFilteringOptions, logLevel logging.Level, serviceMesh bool, tls bool, maxLiveStreams int) error {
+func (provider *Provider) ApplyKubesharkTapperDaemonSet(ctx context.Context, namespace string, daemonSetName string, podImage string, tapperPodName string, apiServerPodIp string, nodeNames []string, serviceAccountName string, resources models.Resources, imagePullPolicy core.PullPolicy, kubesharkApiFilteringOptions api.TrafficFilteringOptions, logLevel logging.Level, serviceMesh bool, tls bool, maxLiveStreams int) error {
-	logger.Log.Debugf("Applying %d tapper daemon sets, ns: %s, daemonSetName: %s, podImage: %s, tapperPodName: %s", len(nodeNames), namespace, daemonSetName, podImage, tapperPodName)
+	log.Printf("Applying %d tapper daemon sets, ns: %s, daemonSetName: %s, podImage: %s, tapperPodName: %s", len(nodeNames), namespace, daemonSetName, podImage, tapperPodName)
 
 	if len(nodeNames) == 0 {
 		return fmt.Errorf("daemon set %s must tap at least 1 pod", daemonSetName)
@@ -863,12 +864,12 @@ func (provider *Provider) ApplyKubesharkTapperDaemonSet(ctx context.Context, nam
 
 	agentContainer.WithCommand(kubesharkCmd...)
 	agentContainer.WithEnv(
-		applyconfcore.EnvVar().WithName(shared.LogLevelEnvVar).WithValue(logLevel.String()),
+		applyconfcore.EnvVar().WithName(utils.LogLevelEnvVar).WithValue(logLevel.String()),
-		applyconfcore.EnvVar().WithName(shared.HostModeEnvVar).WithValue("1"),
+		applyconfcore.EnvVar().WithName(utils.HostModeEnvVar).WithValue("1"),
-		applyconfcore.EnvVar().WithName(shared.KubesharkFilteringOptionsEnvVar).WithValue(string(kubesharkApiFilteringOptionsJsonStr)),
+		applyconfcore.EnvVar().WithName(utils.KubesharkFilteringOptionsEnvVar).WithValue(string(kubesharkApiFilteringOptionsJsonStr)),
 	)
 	agentContainer.WithEnv(
-		applyconfcore.EnvVar().WithName(shared.NodeNameEnvVar).WithValueFrom(
+		applyconfcore.EnvVar().WithName(utils.NodeNameEnvVar).WithValueFrom(
 			applyconfcore.EnvVarSource().WithFieldRef(
 				applyconfcore.ObjectFieldSelector().WithAPIVersion("v1").WithFieldPath("spec.nodeName"),
 			),
@@ -1158,7 +1159,7 @@ func (provider *Provider) ListManagedRoleBindings(ctx context.Context, namespace
 func (provider *Provider) ValidateNotProxy() error {
 	kubernetesUrl, err := url.Parse(provider.clientConfig.Host)
 	if err != nil {
-		logger.Log.Debugf("ValidateNotProxy - error while parsing kubernetes host, err: %v", err)
+		log.Printf("ValidateNotProxy - error while parsing kubernetes host, err: %v", err)
 		return nil
 	}
 
@@ -1183,7 +1184,7 @@ func (provider *Provider) ValidateNotProxy() error {
 func (provider *Provider) GetKubernetesVersion() (*semver.SemVersion, error) {
 	serverVersion, err := provider.clientSet.ServerVersion()
 	if err != nil {
-		logger.Log.Debugf("error while getting kubernetes server version, err: %v", err)
+		log.Printf("error while getting kubernetes server version, err: %v", err)
 		return nil, err
 	}
 
@@ -1210,7 +1211,7 @@ func ValidateKubernetesVersion(serverVersionSemVer *semver.SemVersion) error {
 }
 
 func loadKubernetesConfiguration(kubeConfigPath string, context string) clientcmd.ClientConfig {
-	logger.Log.Debugf("Using kube config %s", kubeConfigPath)
+	log.Printf("Using kube config %s", kubeConfigPath)
 	configPathList := filepath.SplitList(kubeConfigPath)
 	configLoadingRules := &clientcmd.ClientConfigLoadingRules{}
 	if len(configPathList) <= 1 {

kubernetes/proxy.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"log"
 	"net"
 	"net/http"
 	"net/url"
@@ -15,7 +16,6 @@ import (
 	"k8s.io/client-go/tools/portforward"
 	"k8s.io/client-go/transport/spdy"
 
-	"github.com/kubeshark/kubeshark/logger"
 	"k8s.io/kubectl/pkg/proxy"
 )
 
@@ -23,7 +23,7 @@ const k8sProxyApiPrefix = "/"
 const kubesharkServicePort = 80
 
 func StartProxy(kubernetesProvider *Provider, proxyHost string, srcPort uint16, dstPort uint16, kubesharkNamespace string, kubesharkServiceName string, cancel context.CancelFunc) (*http.Server, error) {
-	logger.Log.Infof("Starting proxy - namespace: [%v], service name: [%s], port: [%d:%d]\n", kubesharkNamespace, kubesharkServiceName, srcPort, dstPort)
+	log.Printf("Starting proxy - namespace: [%v], service name: [%s], port: [%d:%d]\n", kubesharkNamespace, kubesharkServiceName, srcPort, dstPort)
 	filter := &proxy.FilterServer{
 		AcceptPaths:   proxy.MakeRegexpArrayOrDie(proxy.DefaultPathAcceptRE),
 		RejectPaths:   proxy.MakeRegexpArrayOrDie(proxy.DefaultPathRejectRE),
@@ -50,7 +50,7 @@ func StartProxy(kubernetesProvider *Provider, proxyHost string, srcPort uint16,
 
 	go func() {
 		if err := server.Serve(l); err != nil && err != http.ErrServerClosed {
-			logger.Log.Errorf("Error creating proxy, %v", err)
+			log.Printf("Error creating proxy, %v", err)
 			cancel()
 		}
 	}()
@@ -105,7 +105,7 @@ func NewPortForward(kubernetesProvider *Provider, namespace string, podRegex *re
 
 	podName := pods[0].Name
 
-	logger.Log.Debugf("Starting proxy using port-forward method. namespace: [%v], pod name: [%s], %d:%d", namespace, podName, srcPort, dstPort)
+	log.Printf("Starting proxy using port-forward method. namespace: [%v], pod name: [%s], %d:%d", namespace, podName, srcPort, dstPort)
 
 	dialer, err := getHttpDialer(kubernetesProvider, namespace, podName)
 	if err != nil {
@@ -122,7 +122,7 @@ func NewPortForward(kubernetesProvider *Provider, namespace string, podRegex *re
 
 	go func() {
 		if err = forwarder.ForwardPorts(); err != nil {
-			logger.Log.Errorf("kubernetes port-forwarding error: %v", err)
+			log.Printf("kubernetes port-forwarding error: %v", err)
 			cancel()
 		}
 	}()
@@ -133,7 +133,7 @@ func NewPortForward(kubernetesProvider *Provider, namespace string, podRegex *re
 func getHttpDialer(kubernetesProvider *Provider, namespace string, podName string) (httpstream.Dialer, error) {
 	roundTripper, upgrader, err := spdy.RoundTripperFor(&kubernetesProvider.clientConfig)
 	if err != nil {
-		logger.Log.Errorf("Error creating http dialer")
+		log.Printf("Error creating http dialer")
 		return nil, err
 	}
 
@@ -144,7 +144,7 @@ func getHttpDialer(kubernetesProvider *Provider, namespace string, podName strin
 	path := fmt.Sprintf("%s/api/v1/namespaces/%s/pods/%s/portforward", clientConfigHostUrl.Path, namespace, podName)
 
 	serverURL := url.URL{Scheme: "https", Path: path, Host: clientConfigHostUrl.Host}
-	logger.Log.Debugf("Http dialer url %v", serverURL)
+	log.Printf("Http dialer url %v", serverURL)
 
 	return spdy.NewDialer(upgrader, &http.Client{Transport: roundTripper}, http.MethodPost, &serverURL), nil
 }

kubernetes/utils.go

@@ -3,13 +3,13 @@ package kubernetes
 import (
 	"regexp"
 
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/worker/models"
 	core "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-func GetNodeHostToTappedPodsMap(tappedPods []core.Pod) shared.NodeToPodsMap {
+func GetNodeHostToTappedPodsMap(tappedPods []core.Pod) models.NodeToPodsMap {
-	nodeToTappedPodMap := make(shared.NodeToPodsMap)
+	nodeToTappedPodMap := make(models.NodeToPodsMap)
 	for _, pod := range tappedPods {
 		minimizedPod := getMinimizedPod(pod)
 
@@ -86,10 +86,10 @@ func getMissingPods(pods1 []core.Pod, pods2 []core.Pod) []core.Pod {
 	return missingPods
 }
 
-func GetPodInfosForPods(pods []core.Pod) []*shared.PodInfo {
+func GetPodInfosForPods(pods []core.Pod) []*models.PodInfo {
-	podInfos := make([]*shared.PodInfo, 0)
+	podInfos := make([]*models.PodInfo, 0)
 	for _, pod := range pods {
-		podInfos = append(podInfos, &shared.PodInfo{Name: pod.Name, Namespace: pod.Namespace, NodeName: pod.Spec.NodeName})
+		podInfos = append(podInfos, &models.PodInfo{Name: pod.Name, Namespace: pod.Namespace, NodeName: pod.Spec.NodeName})
 	}
 	return podInfos
 }

kubernetes/watch.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"log"
 	"sync"
 	"time"
 
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/debounce"
-	"github.com/kubeshark/kubeshark/shared/debounce"
 
 	"k8s.io/apimachinery/pkg/watch"
 )
@@ -57,9 +57,9 @@ func FilteredWatch(ctx context.Context, watcherCreator WatchCreator, targetNames
 				} else {
 					if !watchRestartDebouncer.IsOn() {
 						if err := watchRestartDebouncer.SetOn(); err != nil {
-							logger.Log.Error(err)
+							log.Print(err)
 						}
-						logger.Log.Debug("k8s watch channel closed, restarting watcher")
+						log.Print("k8s watch channel closed, restarting watcher")
 						time.Sleep(time.Second * 5)
 						continue
 					} else {

kubeshark.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	"github.com/kubeshark/kubeshark/cmd"
+	"github.com/kubeshark/kubeshark/cmd/goUtils"
+)
+
+func main() {
+	goUtils.HandleExcWrapper(cmd.Execute)
+}

kubeshark/fsUtils/kubesharkLogsUtils.go

@@ -4,20 +4,14 @@ import (
 	"archive/zip"
 	"context"
 	"fmt"
+	"log"
 	"os"
-	"path"
 	"regexp"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 )
 
-func GetLogFilePath() string {
-	return path.Join(kubeshark.GetKubesharkFolderPath(), "kubeshark_cli.log")
-}
-
 func DumpLogs(ctx context.Context, provider *kubernetes.Provider, filePath string) error {
 	podExactRegex := regexp.MustCompile("^" + kubernetes.KubesharkResourcesPrefix)
 	pods, err := provider.ListAllPodsMatchingRegex(ctx, podExactRegex, []string{config.Config.KubesharkResourcesNamespace})
@@ -41,45 +35,39 @@ func DumpLogs(ctx context.Context, provider *kubernetes.Provider, filePath strin
 		for _, container := range pod.Spec.Containers {
 			logs, err := provider.GetPodLogs(ctx, pod.Namespace, pod.Name, container.Name)
 			if err != nil {
-				logger.Log.Errorf("Failed to get logs, %v", err)
+				log.Printf("Failed to get logs, %v", err)
 				continue
 			} else {
-				logger.Log.Debugf("Successfully read log length %d for pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
+				log.Printf("Successfully read log length %d for pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
 			}
 
 			if err := AddStrToZip(zipWriter, logs, fmt.Sprintf("%s.%s.%s.log", pod.Namespace, pod.Name, container.Name)); err != nil {
-				logger.Log.Errorf("Failed write logs, %v", err)
+				log.Printf("Failed write logs, %v", err)
 			} else {
-				logger.Log.Debugf("Successfully added log length %d from pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
+				log.Printf("Successfully added log length %d from pod: %s.%s.%s", len(logs), pod.Namespace, pod.Name, container.Name)
 			}
 		}
 	}
 
 	events, err := provider.GetNamespaceEvents(ctx, config.Config.KubesharkResourcesNamespace)
 	if err != nil {
-		logger.Log.Debugf("Failed to get k8b events, %v", err)
+		log.Printf("Failed to get k8b events, %v", err)
 	} else {
-		logger.Log.Debugf("Successfully read events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
+		log.Printf("Successfully read events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
 	}
 
 	if err := AddStrToZip(zipWriter, events, fmt.Sprintf("%s_events.log", config.Config.KubesharkResourcesNamespace)); err != nil {
-		logger.Log.Debugf("Failed write logs, %v", err)
+		log.Printf("Failed write logs, %v", err)
 	} else {
-		logger.Log.Debugf("Successfully added events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
+		log.Printf("Successfully added events for k8b namespace: %s", config.Config.KubesharkResourcesNamespace)
 	}
 
 	if err := AddFileToZip(zipWriter, config.Config.ConfigFilePath); err != nil {
-		logger.Log.Debugf("Failed write file, %v", err)
+		log.Printf("Failed write file, %v", err)
 	} else {
-		logger.Log.Debugf("Successfully added file %s", config.Config.ConfigFilePath)
+		log.Printf("Successfully added file %s", config.Config.ConfigFilePath)
 	}
 
-	if err := AddFileToZip(zipWriter, GetLogFilePath()); err != nil {
+	log.Printf("You can find the zip file with all logs in %s", filePath)
-		logger.Log.Debugf("Failed write file, %v", err)
-	} else {
-		logger.Log.Debugf("Successfully added file %s", GetLogFilePath())
-	}
-
-	logger.Log.Infof("You can find the zip file with all logs in %s", filePath)
 	return nil
 }

kubeshark/fsUtils/zipUtils.go

@@ -4,11 +4,10 @@ import (
 	"archive/zip"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"path/filepath"
 	"strings"
-
-	"github.com/kubeshark/kubeshark/logger"
 )
 
 func AddFileToZip(zipWriter *zip.Writer, filename string) error {
@@ -84,7 +83,7 @@ func Unzip(reader *zip.Reader, dest string) error {
 			_ = os.MkdirAll(path, f.Mode())
 		} else {
 			_ = os.MkdirAll(filepath.Dir(path), f.Mode())
-			logger.Log.Infof("writing HAR file [ %v ]", path)
+			log.Printf("writing HAR file [ %v ]", path)
 			f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
 			if err != nil {
 				return err
@@ -93,7 +92,7 @@ func Unzip(reader *zip.Reader, dest string) error {
 				if err := f.Close(); err != nil {
 					panic(err)
 				}
-				logger.Log.Info(" done")
+				log.Print(" done")
 			}()
 
 			_, err = io.Copy(f, rc)

kubeshark/version/versionCheck.go

@@ -4,25 +4,25 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"runtime"
 	"strings"
 	"time"
 
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubeshark"
-	"github.com/kubeshark/kubeshark/cli/pkg/version"
+	"github.com/kubeshark/kubeshark/pkg/version"
-	"github.com/kubeshark/kubeshark/logger"
 
 	"github.com/google/go-github/v37/github"
 )
 
 func CheckNewerVersion(versionChan chan string) {
-	logger.Log.Debugf("Checking for newer version...")
+	log.Printf("Checking for newer version...")
 	start := time.Now()
 	client := github.NewClient(nil)
 	latestRelease, _, err := client.Repositories.GetLatestRelease(context.Background(), "kubeshark", "kubeshark")
 	if err != nil {
-		logger.Log.Debugf("[ERROR] Failed to get latest release")
+		log.Printf("[ERROR] Failed to get latest release")
 		versionChan <- ""
 		return
 	}
@@ -35,14 +35,14 @@ func CheckNewerVersion(versionChan chan string) {
 		}
 	}
 	if versionFileUrl == "" {
-		logger.Log.Debugf("[ERROR] Version file not found in the latest release")
+		log.Printf("[ERROR] Version file not found in the latest release")
 		versionChan <- ""
 		return
 	}
 
 	res, err := http.Get(versionFileUrl)
 	if err != nil {
-		logger.Log.Debugf("[ERROR] Failed to get the version file %v", err)
+		log.Printf("[ERROR] Failed to get the version file %v", err)
 		versionChan <- ""
 		return
 	}
@@ -50,7 +50,7 @@ func CheckNewerVersion(versionChan chan string) {
 	data, err := io.ReadAll(res.Body)
 	res.Body.Close()
 	if err != nil {
-		logger.Log.Debugf("[ERROR] Failed to read the version file -> %v", err)
+		log.Printf("[ERROR] Failed to read the version file -> %v", err)
 		versionChan <- ""
 		return
 	}
@@ -59,12 +59,12 @@ func CheckNewerVersion(versionChan chan string) {
 
 	greater, err := version.GreaterThen(gitHubVersion, kubeshark.Ver)
 	if err != nil {
-		logger.Log.Debugf("[ERROR] Ver version is not valid, github version %v, current version %v", gitHubVersion, kubeshark.Ver)
+		log.Printf("[ERROR] Ver version is not valid, github version %v, current version %v", gitHubVersion, kubeshark.Ver)
 		versionChan <- ""
 		return
 	}
 
-	logger.Log.Debugf("Finished version validation, github version %v, current version %v, took %v", gitHubVersion, kubeshark.Ver, time.Since(start))
+	log.Printf("Finished version validation, github version %v, current version %v, took %v", gitHubVersion, kubeshark.Ver, time.Since(start))
 
 	if greater {
 		var downloadMessage string

logger/go.mod

@@ -1,5 +0,0 @@
-module github.com/kubeshark/kubeshark/logger
-
-go 1.17
-
-require github.com/op/go-logging v0.0.0-20160315200505-970db520ece7

logger/go.sum

@@ -1,2 +0,0 @@
-github.com/op/go-logging v0.0.0-20160315200505-970db520ece7 h1:lDH9UUVJtmYCjyT0CI4q8xvlXPxeZ0gYCVvWbmPlp88=
-github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=

logger/logger.go

@@ -1,49 +0,0 @@
-package logger
-
-import (
-	"os"
-
-	"github.com/op/go-logging"
-)
-
-var Log = logging.MustGetLogger("kubeshark")
-
-var format = logging.MustStringFormatter(
-	`[%{time:2006-01-02T15:04:05.000-0700}] %{level:-5s} ▶ %{message} ▶ [%{pid} %{shortfile} %{shortfunc}]`,
-)
-
-func InitLogger(logPath string) {
-	f, err := os.OpenFile(logPath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
-	if err != nil {
-		Log.Infof("Failed to open kubeshark log file: %v, err %v", logPath, err)
-	}
-
-	fileLog := logging.NewLogBackend(f, "", 0)
-	consoleLog := logging.NewLogBackend(os.Stderr, "", 0)
-
-	backend2Formatter := logging.NewBackendFormatter(fileLog, format)
-
-	backend1Leveled := logging.AddModuleLevel(consoleLog)
-	backend1Leveled.SetLevel(logging.INFO, "")
-
-	logging.SetBackend(backend1Leveled, backend2Formatter)
-}
-
-func InitLoggerStd(level logging.Level) {
-	var backends []logging.Backend
-
-	stderrBackend := logging.NewLogBackend(os.Stderr, "", 0)
-	stderrFormater := logging.NewBackendFormatter(stderrBackend, format)
-	stderrLeveled := logging.AddModuleLevel(stderrFormater)
-	stderrLeveled.SetLevel(logging.ERROR, "")
-	backends = append(backends, stderrLeveled)
-
-	if level >= logging.WARNING {
-		stdoutBackend := logging.NewLogBackend(os.Stdout, "", 0)
-		stdoutFormater := logging.NewBackendFormatter(stdoutBackend, format)
-		stdoutLeveled := logging.AddModuleLevel(stdoutFormater)
-		stdoutLeveled.SetLevel(level, "")
-		backends = append(backends, stdoutLeveled)
-	}
-	logging.SetBackend(backends...)
-}

resources/cleanResources.go

@@ -3,18 +3,17 @@ package resources
 import (
 	"context"
 	"fmt"
+	"log"
 
-	"github.com/kubeshark/kubeshark/cli/errormessage"
+	"github.com/kubeshark/kubeshark/errormessage"
-	"github.com/kubeshark/kubeshark/cli/kubeshark/fsUtils"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/cli/utils"
+	"github.com/kubeshark/kubeshark/utils"
-	"github.com/kubeshark/kubeshark/logger"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 	"k8s.io/apimachinery/pkg/util/wait"
 )
 
 func CleanUpKubesharkResources(ctx context.Context, cancel context.CancelFunc, kubernetesProvider *kubernetes.Provider, isNsRestrictedMode bool, kubesharkResourcesNamespace string) {
-	logger.Log.Infof("\nRemoving kubeshark resources")
+	log.Printf("\nRemoving kubeshark resources")
 
 	var leftoverResources []string
 
@@ -25,11 +24,11 @@ func CleanUpKubesharkResources(ctx context.Context, cancel context.CancelFunc, k
 	}
 
 	if len(leftoverResources) > 0 {
-		errMsg := fmt.Sprintf("Failed to remove the following resources, for more info check logs at %s:", fsUtils.GetLogFilePath())
+		errMsg := "Failed to remove the following resources."
 		for _, resource := range leftoverResources {
 			errMsg += "\n- " + resource
 		}
-		logger.Log.Errorf(uiUtils.Error, errMsg)
+		log.Printf(uiUtils.Error, errMsg)
 	}
 }
 
@@ -79,11 +78,11 @@ func waitUntilNamespaceDeleted(ctx context.Context, cancel context.CancelFunc, k
 	if err := kubernetesProvider.WaitUtilNamespaceDeleted(ctx, kubesharkResourcesNamespace); err != nil {
 		switch {
 		case ctx.Err() == context.Canceled:
-			logger.Log.Debugf("Do nothing. User interrupted the wait")
+			log.Printf("Do nothing. User interrupted the wait")
 		case err == wait.ErrWaitTimeout:
-			logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Timeout while removing Namespace %s", kubesharkResourcesNamespace))
+			log.Printf(uiUtils.Error, fmt.Sprintf("Timeout while removing Namespace %s", kubesharkResourcesNamespace))
 		default:
-			logger.Log.Errorf(uiUtils.Error, fmt.Sprintf("Error while waiting for Namespace %s to be deleted: %v", kubesharkResourcesNamespace, errormessage.FormatError(err)))
+			log.Printf(uiUtils.Error, fmt.Sprintf("Error while waiting for Namespace %s to be deleted: %v", kubesharkResourcesNamespace, errormessage.FormatError(err)))
 		}
 	}
 }
@@ -151,6 +150,6 @@ func cleanUpRestrictedMode(ctx context.Context, kubernetesProvider *kubernetes.P
 }
 
 func handleDeletionError(err error, resourceDesc string, leftoverResources *[]string) {
-	logger.Log.Debugf("Error removing %s: %v", resourceDesc, errormessage.FormatError(err))
+	log.Printf("Error removing %s: %v", resourceDesc, errormessage.FormatError(err))
 	*leftoverResources = append(*leftoverResources, resourceDesc)
 }

resources/createResources.go

@@ -3,19 +3,19 @@ package resources
 import (
 	"context"
 	"fmt"
+	"log"
 
-	"github.com/kubeshark/kubeshark/cli/config"
+	"github.com/kubeshark/kubeshark/config"
-	"github.com/kubeshark/kubeshark/cli/errormessage"
+	"github.com/kubeshark/kubeshark/errormessage"
-	"github.com/kubeshark/kubeshark/cli/kubeshark"
+	"github.com/kubeshark/kubeshark/kubernetes"
-	"github.com/kubeshark/kubeshark/cli/uiUtils"
+	"github.com/kubeshark/kubeshark/kubeshark"
-	"github.com/kubeshark/kubeshark/logger"
+	"github.com/kubeshark/kubeshark/uiUtils"
-	"github.com/kubeshark/kubeshark/shared"
+	"github.com/kubeshark/worker/models"
-	"github.com/kubeshark/kubeshark/shared/kubernetes"
 	"github.com/op/go-logging"
 	core "k8s.io/api/core/v1"
 )
 
-func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubernetes.Provider, serializedKubesharkConfig string, isNsRestrictedMode bool, kubesharkResourcesNamespace string, agentImage string, maxEntriesDBSizeBytes int64, apiServerResources shared.Resources, imagePullPolicy core.PullPolicy, logLevel logging.Level, profiler bool) (bool, error) {
+func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubernetes.Provider, serializedKubesharkConfig string, isNsRestrictedMode bool, kubesharkResourcesNamespace string, agentImage string, maxEntriesDBSizeBytes int64, apiServerResources models.Resources, imagePullPolicy core.PullPolicy, logLevel logging.Level, profiler bool) (bool, error) {
 	if !isNsRestrictedMode {
 		if err := createKubesharkNamespace(ctx, kubernetesProvider, kubesharkResourcesNamespace); err != nil {
 			return false, err
@@ -28,7 +28,7 @@ func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubern
 
 	kubesharkServiceAccountExists, err := createRBACIfNecessary(ctx, kubernetesProvider, isNsRestrictedMode, kubesharkResourcesNamespace, []string{"pods", "services", "endpoints"})
 	if err != nil {
-		logger.Log.Warningf(uiUtils.Warning, fmt.Sprintf("Failed to ensure the resources required for IP resolving. Kubeshark will not resolve target IPs to names. error: %v", errormessage.FormatError(err)))
+		log.Printf(uiUtils.Warning, fmt.Sprintf("Failed to ensure the resources required for IP resolving. Kubeshark will not resolve target IPs to names. error: %v", errormessage.FormatError(err)))
 	}
 
 	var serviceAccountName string
@@ -71,7 +71,7 @@ func CreateTapKubesharkResources(ctx context.Context, kubernetesProvider *kubern
 		return kubesharkServiceAccountExists, err
 	}
 
-	logger.Log.Debugf("Successfully created service: %s", kubernetes.ApiServerPodName)
+	log.Printf("Successfully created service: %s", kubernetes.ApiServerPodName)
 
 	return kubesharkServiceAccountExists, nil
 }
@@ -108,7 +108,7 @@ func createKubesharkApiServerPod(ctx context.Context, kubernetesProvider *kubern
 	if _, err = kubernetesProvider.CreatePod(ctx, opts.Namespace, pod); err != nil {
 		return err
 	}
-	logger.Log.Infof("Successfully created pod: [%s]", pod.Name)
+	log.Printf("Successfully created pod: [%s]", pod.Name)
 	return nil
 }
 
@@ -120,6 +120,6 @@ func createFrontPod(ctx context.Context, kubernetesProvider *kubernetes.Provider
 	if _, err = kubernetesProvider.CreatePod(ctx, opts.Namespace, pod); err != nil {
 		return err
 	}
-	logger.Log.Infof("Successfully created pod: [%s]", pod.Name)
+	log.Printf("Successfully created pod: [%s]", pod.Name)
 	return nil
 }

shared/Makefile

@@ -1,2 +0,0 @@
-test: ## Run shared tests.
-	@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic

shared/go.mod

@@ -1,94 +0,0 @@
-module github.com/kubeshark/kubeshark/shared
-
-go 1.17
-
-require (
-	github.com/docker/go-units v0.4.0
-	github.com/kubeshark/kubeshark/logger v0.0.0
-	github.com/kubeshark/worker v0.1.1
-	github.com/op/go-logging v0.0.0-20160315200505-970db520ece7
-	k8s.io/api v0.23.3
-	k8s.io/apimachinery v0.23.3
-	k8s.io/client-go v0.23.3
-	k8s.io/kubectl v0.23.3
-)
-
-require (
-	cloud.google.com/go/compute v1.2.0 // indirect
-	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
-	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
-	github.com/Azure/go-autorest/autorest v0.11.24 // indirect
-	github.com/Azure/go-autorest/autorest/adal v0.9.18 // indirect
-	github.com/Azure/go-autorest/autorest/date v0.3.0 // indirect
-	github.com/Azure/go-autorest/logger v0.2.1 // indirect
-	github.com/Azure/go-autorest/tracing v0.6.0 // indirect
-	github.com/MakeNowJust/heredoc v1.0.0 // indirect
-	github.com/PuerkitoBio/purell v1.1.1 // indirect
-	github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect
-	github.com/chai2010/gettext-go v0.0.0-20160711120539-c6fed771bfd5 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
-	github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
-	github.com/fvbommel/sortorder v1.0.2 // indirect
-	github.com/go-errors/errors v1.4.2 // indirect
-	github.com/go-logr/logr v1.2.2 // indirect
-	github.com/go-openapi/jsonpointer v0.19.5 // indirect
-	github.com/go-openapi/jsonreference v0.19.6 // indirect
-	github.com/go-openapi/swag v0.21.1 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang-jwt/jwt/v4 v4.2.0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/google/btree v1.0.1 // indirect
-	github.com/google/go-cmp v0.5.7 // indirect
-	github.com/google/gofuzz v1.2.0 // indirect
-	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/googleapis/gnostic v0.5.5 // indirect
-	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
-	github.com/imdario/mergo v0.3.12 // indirect
-	github.com/inconshreveable/mousetrap v1.0.0 // indirect
-	github.com/josharian/intern v1.0.0 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
-	github.com/moby/spdystream v0.2.0 // indirect
-	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
-	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect
-	github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect
-	github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/russross/blackfriday v1.6.0 // indirect
-	github.com/spf13/cobra v1.3.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/stretchr/testify v1.7.0 // indirect
-	github.com/xlab/treeprint v1.1.0 // indirect
-	go.starlark.net v0.0.0-20220203230714-bb14e151c28f // indirect
-	golang.org/x/crypto v0.0.0-20220208050332-20e1d8d225ab // indirect
-	golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd // indirect
-	golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect
-	golang.org/x/sys v0.0.0-20220207234003-57398862261d // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
-	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11 // indirect
-	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/protobuf v1.27.1 // indirect
-	gopkg.in/inf.v0 v0.9.1 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
-	k8s.io/cli-runtime v0.23.3 // indirect
-	k8s.io/component-base v0.23.3 // indirect
-	k8s.io/klog/v2 v2.40.1 // indirect
-	k8s.io/kube-openapi v0.0.0-20220124234850-424119656bbf // indirect
-	k8s.io/utils v0.0.0-20220127004650-9b3446523e65 // indirect
-	sigs.k8s.io/json v0.0.0-20211208200746-9f7c6b3444d2 // indirect
-	sigs.k8s.io/kustomize/api v0.11.1 // indirect
-	sigs.k8s.io/kustomize/kyaml v0.13.3 // indirect
-	sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
-	sigs.k8s.io/yaml v1.3.0 // indirect
-)
-
-replace github.com/kubeshark/kubeshark/logger v0.0.0 => ../logger

shared/models.go

@@ -1,131 +0,0 @@
-package shared
-
-import (
-	"github.com/op/go-logging"
-
-	v1 "k8s.io/api/core/v1"
-)
-
-type WebSocketMessageType string
-
-const (
-	WebSocketMessageTypeEntry            WebSocketMessageType = "entry"
-	WebSocketMessageTypeFullEntry        WebSocketMessageType = "fullEntry"
-	WebSocketMessageTypeTappedEntry      WebSocketMessageType = "tappedEntry"
-	WebSocketMessageTypeUpdateStatus     WebSocketMessageType = "status"
-	WebSocketMessageTypeUpdateTappedPods WebSocketMessageType = "tappedPods"
-	WebSocketMessageTypeToast            WebSocketMessageType = "toast"
-	WebSocketMessageTypeQueryMetadata    WebSocketMessageType = "queryMetadata"
-	WebSocketMessageTypeStartTime        WebSocketMessageType = "startTime"
-	WebSocketMessageTypeTapConfig        WebSocketMessageType = "tapConfig"
-)
-
-type Resources struct {
-	CpuLimit       string `yaml:"cpu-limit" default:"750m"`
-	MemoryLimit    string `yaml:"memory-limit" default:"1Gi"`
-	CpuRequests    string `yaml:"cpu-requests" default:"50m"`
-	MemoryRequests string `yaml:"memory-requests" default:"50Mi"`
-}
-
-type OASConfig struct {
-	Enable        bool `yaml:"enabled" default:"true"`
-	MaxExampleLen int  `yaml:"max-example-len" default:"10240"`
-}
-
-type KubesharkAgentConfig struct {
-	MaxDBSizeBytes              int64         `json:"maxDBSizeBytes"`
-	InsertionFilter             string        `json:"insertionFilter"`
-	AgentImage                  string        `json:"agentImage"`
-	PullPolicy                  string        `json:"pullPolicy"`
-	LogLevel                    logging.Level `json:"logLevel"`
-	TapperResources             Resources     `json:"tapperResources"`
-	KubesharkResourcesNamespace string        `json:"kubesharkResourceNamespace"`
-	AgentDatabasePath           string        `json:"agentDatabasePath"`
-	ServiceMap                  bool          `json:"serviceMap"`
-	OAS                         OASConfig     `json:"oas"`
-}
-
-type WebSocketMessageMetadata struct {
-	MessageType WebSocketMessageType `json:"messageType,omitempty"`
-}
-
-type WebSocketStatusMessage struct {
-	*WebSocketMessageMetadata
-	TappingStatus []TappedPodStatus `json:"tappingStatus"`
-}
-
-type WebSocketTappedPodsMessage struct {
-	*WebSocketMessageMetadata
-	NodeToTappedPodMap NodeToPodsMap `json:"nodeToTappedPodMap"`
-}
-
-type WebSocketTapConfigMessage struct {
-	*WebSocketMessageMetadata
-	TapTargets []v1.Pod `json:"pods"`
-}
-
-type NodeToPodsMap map[string][]v1.Pod
-
-func (np NodeToPodsMap) Summary() map[string][]string {
-	summary := make(map[string][]string)
-	for node, pods := range np {
-		for _, pod := range pods {
-			summary[node] = append(summary[node], pod.Namespace+"/"+pod.Name)
-		}
-	}
-
-	return summary
-}
-
-type TapperStatus struct {
-	TapperName string `json:"tapperName"`
-	NodeName   string `json:"nodeName"`
-	Status     string `json:"status"`
-}
-
-type TappedPodStatus struct {
-	Name      string `json:"name"`
-	Namespace string `json:"namespace"`
-	IsTapped  bool   `json:"isTapped"`
-}
-
-type PodInfo struct {
-	Namespace string `json:"namespace"`
-	Name      string `json:"name"`
-	NodeName  string `json:"nodeName"`
-}
-
-type TLSLinkInfo struct {
-	SourceIP                string `json:"sourceIP"`
-	DestinationAddress      string `json:"destinationAddress"`
-	ResolvedDestinationName string `json:"resolvedDestinationName"`
-	ResolvedSourceName      string `json:"resolvedSourceName"`
-}
-
-func CreateWebSocketStatusMessage(tappedPodsStatus []TappedPodStatus) WebSocketStatusMessage {
-	return WebSocketStatusMessage{
-		WebSocketMessageMetadata: &WebSocketMessageMetadata{
-			MessageType: WebSocketMessageTypeUpdateStatus,
-		},
-		TappingStatus: tappedPodsStatus,
-	}
-}
-
-func CreateWebSocketTappedPodsMessage(nodeToTappedPodMap NodeToPodsMap) WebSocketTappedPodsMessage {
-	return WebSocketTappedPodsMessage{
-		WebSocketMessageMetadata: &WebSocketMessageMetadata{
-			MessageType: WebSocketMessageTypeUpdateTappedPods,
-		},
-		NodeToTappedPodMap: nodeToTappedPodMap,
-	}
-}
-
-type HealthResponse struct {
-	TappedPods            []*PodInfo      `json:"tappedPods"`
-	ConnectedTappersCount int             `json:"connectedTappersCount"`
-	TappersStatus         []*TapperStatus `json:"tappersStatus"`
-}
-
-type VersionResponse struct {
-	Ver string `json:"ver"`
-}

shared/sliceUtils_test.go

@@ -1,130 +0,0 @@
-package shared_test
-
-import (
-	"fmt"
-	"github.com/kubeshark/kubeshark/shared"
-	"reflect"
-	"testing"
-)
-
-func TestContainsExists(t *testing.T) {
-	tests := []struct {
-		Slice         []string
-		ContainsValue string
-		Expected      bool
-	}{
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "apple", Expected: true},
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "orange", Expected: true},
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "banana", Expected: true},
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "grapes", Expected: true},
-	}
-
-	for _, test := range tests {
-		t.Run(test.ContainsValue, func(t *testing.T) {
-			actual := shared.Contains(test.Slice, test.ContainsValue)
-			if actual != test.Expected {
-				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
-			}
-		})
-	}
-}
-
-func TestContainsNotExists(t *testing.T) {
-	tests := []struct {
-		Slice         []string
-		ContainsValue string
-		Expected      bool
-	}{
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "cat", Expected: false},
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "dog", Expected: false},
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "apples", Expected: false},
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "rapes", Expected: false},
-	}
-
-	for _, test := range tests {
-		t.Run(test.ContainsValue, func(t *testing.T) {
-			actual := shared.Contains(test.Slice, test.ContainsValue)
-			if actual != test.Expected {
-				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
-			}
-		})
-	}
-}
-
-func TestContainsEmptySlice(t *testing.T) {
-	tests := []struct {
-		Slice         []string
-		ContainsValue string
-		Expected      bool
-	}{
-		{Slice: []string{}, ContainsValue: "cat", Expected: false},
-		{Slice: []string{}, ContainsValue: "dog", Expected: false},
-	}
-
-	for _, test := range tests {
-		t.Run(test.ContainsValue, func(t *testing.T) {
-			actual := shared.Contains(test.Slice, test.ContainsValue)
-			if actual != test.Expected {
-				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
-			}
-		})
-	}
-}
-
-func TestContainsNilSlice(t *testing.T) {
-	tests := []struct {
-		Slice         []string
-		ContainsValue string
-		Expected      bool
-	}{
-		{Slice: nil, ContainsValue: "cat", Expected: false},
-		{Slice: nil, ContainsValue: "dog", Expected: false},
-	}
-
-	for _, test := range tests {
-		t.Run(test.ContainsValue, func(t *testing.T) {
-			actual := shared.Contains(test.Slice, test.ContainsValue)
-			if actual != test.Expected {
-				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
-			}
-		})
-	}
-}
-
-func TestUniqueNoDuplicateValues(t *testing.T) {
-	tests := []struct {
-		Slice    []string
-		Expected []string
-	}{
-		{Slice: []string{"apple", "orange", "banana", "grapes"}, Expected: []string{"apple", "orange", "banana", "grapes"}},
-		{Slice: []string{"dog", "cat", "mouse"}, Expected: []string{"dog", "cat", "mouse"}},
-	}
-
-	for index, test := range tests {
-		t.Run(fmt.Sprintf("%v", index), func(t *testing.T) {
-			actual := shared.Unique(test.Slice)
-			if !reflect.DeepEqual(test.Expected, actual) {
-				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
-			}
-		})
-	}
-}
-
-func TestUniqueDuplicateValues(t *testing.T) {
-	tests := []struct {
-		Slice    []string
-		Expected []string
-	}{
-		{Slice: []string{"apple", "apple", "orange", "orange", "banana", "banana", "grapes", "grapes"}, Expected: []string{"apple", "orange", "banana", "grapes"}},
-		{Slice: []string{"dog", "cat", "cat", "mouse"}, Expected: []string{"dog", "cat", "mouse"}},
-	}
-
-	for index, test := range tests {
-		t.Run(fmt.Sprintf("%v", index), func(t *testing.T) {
-			actual := shared.Unique(test.Slice)
-			if !reflect.DeepEqual(test.Expected, actual) {
-				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
-			}
-		})
-	}
-}

uiUtils/openBrowser.go

@@ -2,10 +2,9 @@ package uiUtils
 
 import (
 	"fmt"
+	"log"
 	"os/exec"
 	"runtime"
-
-	"github.com/kubeshark/kubeshark/logger"
 )
 
 func OpenBrowser(url string) {
@@ -23,6 +22,6 @@ func OpenBrowser(url string) {
 	}
 
 	if err != nil {
-		logger.Log.Errorf("error while opening browser, %v", err)
+		log.Printf("error while opening browser, %v", err)
 	}
 }

utils/consts.go

@@ -1,15 +1,10 @@
-package shared
+package utils
 
 const (
 	KubesharkFilteringOptionsEnvVar = "SENSITIVE_DATA_FILTERING_OPTIONS"
+	KubesharkAgentImageRepo         = "docker.io/kubeshark/hub"
+	LogLevelEnvVar                  = "LOG_LEVEL"
+	BaseninePort                    = "9099"
 	HostModeEnvVar                  = "HOST_MODE"
 	NodeNameEnvVar                  = "NODE_NAME"
-	ConfigDirPath                   = "/app/config/"
-	DataDirPath                     = "/app/data/"
-	ConfigFileName                  = "kubeshark-config.json"
-	LogLevelEnvVar                  = "LOG_LEVEL"
-	KubesharkAgentImageRepo         = "docker.io/kubeshark/hub"
-	BasenineHost                    = "127.0.0.1"
-	BaseninePort                    = "9099"
-	BasenineReconnectInterval       = 3
 )

utils/sliceUtils.go

@@ -1,4 +1,4 @@
-package shared
+package utils
 
 func Contains(slice []string, containsValue string) bool {
 	for _, sliceValue := range slice {

utils/waitUtils.go

@@ -2,25 +2,24 @@ package utils
 
 import (
 	"context"
+	"log"
 	"os"
 	"os/signal"
 	"syscall"
-
-	"github.com/kubeshark/kubeshark/logger"
 )
 
 func WaitForFinish(ctx context.Context, cancel context.CancelFunc) {
-	logger.Log.Debugf("waiting for finish...")
+	log.Printf("waiting for finish...")
 	sigChan := make(chan os.Signal, 1)
 	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
 
 	// block until ctx cancel is called or termination signal is received
 	select {
 	case <-ctx.Done():
-		logger.Log.Debugf("ctx done")
+		log.Printf("ctx done")
 		break
 	case <-sigChan:
-		logger.Log.Debugf("Got termination signal, canceling execution...")
+		log.Printf("Got termination signal, canceling execution...")
 		cancel()
 	}
 }