another test

Signed-off-by: Thomas Schuetz <thomas.schuetz@t-sc.eu>

.github/workflows/release.yaml

@@ -36,6 +36,7 @@ jobs:
     if: needs.release-please.outputs.releases_created == 'true'
     permissions:
       contents: write
+
     needs:
       - release-please
     runs-on: ubuntu-latest
@@ -48,8 +49,6 @@ jobs:
         uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
         with:
           go-version: '1.20'
-      - name: Download Syft
-        uses: anchore/sbom-action/download-syft@v0.13.4
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@f82d6c1c344bcacabba2c841718984797f664a6b # v4
         with:
@@ -71,7 +70,6 @@ jobs:
       id-token: write
     env:
       IMAGE_TAG: ghcr.io/k8sgpt-ai/k8sgpt:${{ needs.release-please.outputs.tag_name }}
-      IMAGE_NAME: k8sgpt
     steps:
       - name: Checkout
         uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3
@@ -100,8 +98,8 @@ jobs:
             ${{ env.IMAGE_TAG }}
           builder: ${{ steps.buildx.outputs.name }}
           push: true
-          cache-from: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_TAG }}
-          cache-to: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_TAG }}
+          cache-from: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_NAME }}
+          cache-to: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_NAME }}
 
       - name: Generate SBOM
         uses: anchore/sbom-action@422cb34a0f8b599678c41b21163ea6088edb2624 # v0.14.1

.github/workflows/test.yaml

@@ -1,21 +0,0 @@
-name: Run tests
-
-on: [push]
-
-env:
-    GO_VERSION: "~1.20"
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3
-
-      - name: Set up Go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
-      - name: Test
-        run: go test -v ./...

.goreleaser.yaml

@@ -16,27 +16,6 @@ builds:
     ldflags:
           - -s -w -X main.version={{.Version}}
 
-nfpms:
-  - file_name_template: '{{ .ProjectName }}_{{ .Arch }}'
-    homepage: https://k8sgpt.ai
-    description: >-
-      K8sGPT is a tool for scanning your kubernetes clusters, diagnosing and triaging issues in simple english. It has SRE experience codified into it’s analyzers and helps to pull out the most relevant information to enrich it with AI.
-    license: "MIT"
-    formats:
-      - deb
-      - rpm
-      - apk
-    bindir: /usr/bin
-    section: utils
-    contents:
-      - src: ./LICENSE
-        dst: /usr/share/doc/nfpm/copyright
-        file_info:
-          mode: 0644
-
-sboms:
-  - artifacts: archive
-
 archives:
   - format: tar.gz
     # this name template makes the OS and Arch compatible with the results of uname.

.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.1.8"}
+{".":"0.1.6"}

CHANGELOG.md

@@ -1,65 +1,5 @@
 # Changelog
 
-## [0.1.8](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.7...v0.1.8) (2023-04-03)
-
-
-### Features
-
-* add password flag for backend authentication ([#199](https://github.com/k8sgpt-ai/k8sgpt/issues/199)) ([075a940](https://github.com/k8sgpt-ai/k8sgpt/commit/075a940d2c9bdd8aa9162940ed46abad47d46998))
-* adding shields to readme ([213ecd8](https://github.com/k8sgpt-ai/k8sgpt/commit/213ecd8e83933fabaa5d3d674c67958599dd72ce))
-* adding unit testing and example ([35b838b](https://github.com/k8sgpt-ai/k8sgpt/commit/35b838bfafa248dbf3932c7a3ee708b1a1539f18))
-* alias filter to filters ([dde4e83](https://github.com/k8sgpt-ai/k8sgpt/commit/dde4e833b0e87553dea4e5c1e17a14e303956bc1))
-* analyzer ifacing ([426f562](https://github.com/k8sgpt-ai/k8sgpt/commit/426f562be83ed0e708a07b9e1900ac06fa017c27))
-* service test ([44cc8f7](https://github.com/k8sgpt-ai/k8sgpt/commit/44cc8f7ad68d152ec577e57cab7d8d9ab9613378))
-* test workflow ([5f30a4d](https://github.com/k8sgpt-ai/k8sgpt/commit/5f30a4ddf44ebff949bb0573f261667539a2dcfb))
-
-
-### Bug Fixes
-
-* **deps:** update module github.com/sashabaranov/go-openai to v1.5.8 ([91fb065](https://github.com/k8sgpt-ai/k8sgpt/commit/91fb06530a21259da6e72c28342e743d2b481294))
-
-
-### Other
-
-* create linux packages ([#201](https://github.com/k8sgpt-ai/k8sgpt/issues/201)) ([67753be](https://github.com/k8sgpt-ai/k8sgpt/commit/67753be6f317c462ebe1d9a316f2b0c9684ca4e5))
-* **deps:** pin dependencies ([#198](https://github.com/k8sgpt-ai/k8sgpt/issues/198)) ([f8291aa](https://github.com/k8sgpt-ai/k8sgpt/commit/f8291aab085209f9fee13a6c92c96076163e2e90))
-
-## [0.1.7](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.6...v0.1.7) (2023-04-02)
-
-
-### Features
-
-* add hpa analyzer and init additionalAnalyzers ([3603872](https://github.com/k8sgpt-ai/k8sgpt/commit/360387249feb9a999286aaa874a13007986219a5))
-* add pda analyzer ([532a5ce](https://github.com/k8sgpt-ai/k8sgpt/commit/532a5ce0332a8466df42bc944800e6668e349801))
-* check if ScaleTargetRef is possible option ([5dad75f](https://github.com/k8sgpt-ai/k8sgpt/commit/5dad75fbe9fd15cfa7bfa69c046b851ea905876f))
-
-
-### Bug Fixes
-
-* hpaAnalyzer analysis result is using wrong parent ([1190fe6](https://github.com/k8sgpt-ai/k8sgpt/commit/1190fe60fdd6e66ce435874628039df7047a52b9))
-* spelling of PodDisruptionBudget ([ceff008](https://github.com/k8sgpt-ai/k8sgpt/commit/ceff0084df1b6de16f1ed503ee8a4b3c1a9f8648))
-* update client API call to use StatefulSet instead of Deployment ([4916fef](https://github.com/k8sgpt-ai/k8sgpt/commit/4916fef9d6b75c54bcfbc5d136550018e96e3632))
-
-
-### Refactoring
-
-* merged main into branch ([3e836d8](https://github.com/k8sgpt-ai/k8sgpt/commit/3e836d81b7c33ce5c0c133c2e1ca3b0c8d3eeeb0)), closes [#101](https://github.com/k8sgpt-ai/k8sgpt/issues/101)
-
-
-### Other
-
-* **deps:** update anchore/sbom-action action to v0.14.1 ([80f29da](https://github.com/k8sgpt-ai/k8sgpt/commit/80f29dae4fd6f6348967192ce2f51f0e0fb5dea0))
-* merge branch 'chetanguptaa-some-fixes' ([071ee56](https://github.com/k8sgpt-ai/k8sgpt/commit/071ee560f36b64b4c65274181e2d13bb14d5b914))
-* refine renovate config ([#172](https://github.com/k8sgpt-ai/k8sgpt/issues/172)) ([d23da9a](https://github.com/k8sgpt-ai/k8sgpt/commit/d23da9ae836a07f0fd59c20a1c3c71d6b7f75277))
-* removes bar on normal analyze events ([e1d8992](https://github.com/k8sgpt-ai/k8sgpt/commit/e1d89920b097db4417c55b020fb23dd8cbaf19ed))
-* removes bar on normal analyze events ([96d0d75](https://github.com/k8sgpt-ai/k8sgpt/commit/96d0d754eab67c0742d3a36a1eefb9c28df59e96))
-* update dependencies ([#174](https://github.com/k8sgpt-ai/k8sgpt/issues/174)) ([9d9c262](https://github.com/k8sgpt-ai/k8sgpt/commit/9d9c26214fbb4c4faba7ef85f2204bc961396de8))
-
-
-### Docs
-
-* add pdbAnalyzer as optional analyzer ([f6974d0](https://github.com/k8sgpt-ai/k8sgpt/commit/f6974d07581384e260059f121242854320dfc58b))
-
 ## [0.1.6](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.5...v0.1.6) (2023-03-31)
 
 

README.md

@@ -2,11 +2,6 @@
   <source media="(prefers-color-scheme: dark)" srcset="./images/banner-white.png" width="600px;">
   <img alt="Text changing depending on mode. Light: 'So light!' Dark: 'So dark!'" src="./images/banner-black.png" width="600px;">
 </picture>
-<br/>
-
-![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/k8sgpt-ai/k8sgpt)
-![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/k8sgpt-ai/k8sgpt/release.yaml)
-![GitHub release (latest by date)](https://img.shields.io/github/v/release/k8sgpt-ai/k8sgpt)
 
 `k8sgpt` is a tool for scanning your Kubernetes clusters, diagnosing, and triaging issues in simple English.
 
@@ -51,8 +46,7 @@ If you install gcc as suggested, the problem will persist. Therefore, you need t
 
 * Currently the default AI provider is OpenAI, you will need to generate an API key from [OpenAI](https://openai.com)
   * You can do this by running `k8sgpt generate` to open a browser link to generate it
-* Run `k8sgpt auth` to set it in k8sgpt. 
-  * You can provide the password directly using the `--password` flag.
+* Run `k8sgpt auth` to set it in k8sgpt.
 * Run `k8sgpt filters` to manage the active filters used by the analyzer. By default, all filters are executed during analysis.
 * Run `k8sgpt analyze` to run a scan.
 * And use `k8sgpt analyze --explain` to get a more detailed explanation of the issues.
@@ -78,7 +72,6 @@ you will be able to write your own analyzers.
 #### Optional
 
 - [x] hpaAnalyzer
-- [x] pdbAnalyzer
 
 ## Usage
 
@@ -184,8 +177,4 @@ the root cause of an issue.
 
 Please read our [contributing guide](./CONTRIBUTING.md).
 ## Community
-Find us on [Slack](https://k8sgpt.slack.com/)
-
-<a href="https://github.com/k8sgpt-ai/k8sgpt/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=k8sgpt-ai/k8sgpt" />
-</a>
+* Find us on [Slack](https://k8sgpt.slack.com/)

cmd/analyze/analyze.go

@@ -1,19 +1,13 @@
 package analyze
 
 import (
-	"context"
-	"encoding/json"
 	"fmt"
-	"os"
-	"strings"
-
 	"github.com/fatih/color"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/schollz/progressbar/v3"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analysis"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"os"
 )
 
 var (
@@ -53,91 +47,28 @@ var AnalyzeCmd = &cobra.Command{
 			os.Exit(1)
 		}
 
-		var aiClient ai.IAI
-		switch backendType {
-		case "openai":
-			aiClient = &ai.OpenAIClient{}
-			if err := aiClient.Configure(token, language); err != nil {
-				color.Red("Error: %v", err)
-				os.Exit(1)
-			}
-		default:
-			color.Red("Backend not supported")
+		// AnalysisResult configuration
+
+		aiClient, err := ai.NewAIClient("openai")
+		if err != nil {
+			color.Red("Error: %v", err)
 			os.Exit(1)
 		}
-
-		ctx := context.Background()
-		// Get kubernetes client from viper
-		client := viper.Get("kubernetesClient").(*kubernetes.Client)
-		// Analysis configuration
-		config := &analyzer.AnalysisConfiguration{
-			Namespace: namespace,
-			NoCache:   nocache,
-			Explain:   explain,
-		}
-
-		var analysisResults *[]analyzer.Analysis = &[]analyzer.Analysis{}
-		if err := analyzer.RunAnalysis(ctx, filters, config, client,
-			aiClient, analysisResults); err != nil {
+		if err := aiClient.Configure(token, language); err != nil {
 			color.Red("Error: %v", err)
 			os.Exit(1)
 		}
 
-		if len(*analysisResults) == 0 {
-			color.Green("{ \"status\": \"OK\" }")
-			os.Exit(0)
-		}
-		var bar = progressbar.Default(int64(len(*analysisResults)))
-		if !explain {
-			bar.Clear()
-		}
-		var printOutput []analyzer.Analysis
+		analysis := analysis.NewAnalysis(namespace, nocache, explain, filters, backend)
 
-		for _, analysis := range *analysisResults {
+		// Run analysis
+		_ = analysis.RunAnalysis()
 
-			if explain {
-				parsedText, err := analyzer.ParseViaAI(ctx, config, aiClient, analysis.Error)
-				if err != nil {
-					// Check for exhaustion
-					if strings.Contains(err.Error(), "status code: 429") {
-						color.Red("Exhausted API quota. Please try again later")
-						os.Exit(1)
-					}
-					color.Red("Error: %v", err)
-					continue
-				}
-				analysis.Details = parsedText
-				bar.Add(1)
-			}
-			printOutput = append(printOutput, analysis)
-		}
-
-		// print results
-		for n, analysis := range printOutput {
-
-			switch output {
-			case "json":
-				analysis.Error = analysis.Error[0:]
-				j, err := json.Marshal(analysis)
-				if err != nil {
-					color.Red("Error: %v", err)
-					os.Exit(1)
-				}
-				fmt.Println(string(j))
-			default:
-				fmt.Printf("%s %s(%s)\n", color.CyanString("%d", n),
-					color.YellowString(analysis.Name), color.CyanString(analysis.ParentObject))
-				for _, err := range analysis.Error {
-					fmt.Printf("- %s %s\n", color.RedString("Error:"), color.RedString(err))
-				}
-				fmt.Println(color.GreenString(analysis.Details + "\n"))
-			}
-		}
+		analysis.PrintJsonResult()
 	},
 }
 
 func init() {
-
 	// namespace flag
 	AnalyzeCmd.Flags().StringVarP(&namespace, "namespace", "n", "", "Namespace to analyze")
 	// no cache flag

cmd/auth/auth.go

@@ -13,8 +13,7 @@ import (
 )
 
 var (
-	backend  string
-	password string
+	backend string
 )
 
 // authCmd represents the auth command
@@ -39,16 +38,14 @@ var AuthCmd = &cobra.Command{
 			color.Green("Using %s as backend AI provider", backendType)
 		}
 
-		if password == "" {
-			fmt.Printf("Enter %s Key: ", backendType)
-			bytePassword, err := term.ReadPassword(int(syscall.Stdin))
-			if err != nil {
-				color.Red("Error reading %s Key from stdin: %s", backendType,
-					err.Error())
-				os.Exit(1)
-			}
-			password = strings.TrimSpace(string(bytePassword))
+		fmt.Printf("Enter %s Key: ", backendType)
+		bytePassword, err := term.ReadPassword(int(syscall.Stdin))
+		if err != nil {
+			color.Red("Error reading %s Key from stdin: %s", backendType,
+				err.Error())
+			os.Exit(1)
 		}
+		password := strings.TrimSpace(string(bytePassword))
 
 		viper.Set(fmt.Sprintf("%s_key", backendType), password)
 		if err := viper.WriteConfig(); err != nil {
@@ -62,6 +59,4 @@ var AuthCmd = &cobra.Command{
 func init() {
 	// add flag for backend
 	AuthCmd.Flags().StringVarP(&backend, "backend", "b", "openai", "Backend AI provider")
-	// add flag for password
-	AuthCmd.Flags().StringVarP(&password, "password", "p", "", "Backend AI password")
 }

cmd/filters/filters.go

@@ -6,7 +6,7 @@ import (
 
 var FiltersCmd = &cobra.Command{
 	Use:     "filters",
-	Aliases: []string{"filter"},
+	Aliases: []string{"filters"},
 	Short:   "Manage filters for analyzing Kubernetes resources",
 	Long: `The filters command allows you to manage filters that are used to analyze Kubernetes resources.
 	You can list available filters to analyze resources.`,

cmd/generate/generate.go

@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/viper"
 	"os/exec"
 	"runtime"
+	"time"
 )
 
 var (
@@ -30,6 +31,10 @@ var GenerateCmd = &cobra.Command{
 			backendType = backend
 		}
 		fmt.Println("")
+		color.Green("Opening: https://beta.openai.com/account/api-keys to generate a key for %s", backendType)
+		color.Green("Please copy the generated key and run `k8sgpt auth` to add it to your config file")
+		fmt.Println("")
+		time.Sleep(5 * time.Second)
 		openbrowser("https://beta.openai.com/account/api-keys")
 	},
 }
@@ -41,15 +46,9 @@ func init() {
 
 func openbrowser(url string) {
 	var err error
-	isGui := true
 	switch runtime.GOOS {
 	case "linux":
-		_, err = exec.LookPath("xdg-open")
-		if err != nil {
-			isGui = false
-		} else {
-			err = exec.Command("xdg-open", url).Start()
-		}
+		err = exec.Command("xdg-open", url).Start()
 	case "windows":
 		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
 	case "darwin":
@@ -57,21 +56,7 @@ func openbrowser(url string) {
 	default:
 		err = fmt.Errorf("unsupported platform")
 	}
-	printInstructions(isGui, backend)
 	if err != nil {
 		fmt.Println(err)
 	}
 }
-
-func printInstructions(isGui bool, backendType string) {
-	fmt.Println("")
-	if isGui {
-		color.Green("Opening: https://beta.openai.com/account/api-keys to generate a key for %s", backendType)
-		fmt.Println("")
-	} else {
-		color.Green("Please open: https://beta.openai.com/account/api-keys to generate a key for %s", backendType)
-		fmt.Println("")
-	}
-	color.Green("Please copy the generated key and run `k8sgpt auth` to add it to your config file")
-	fmt.Println("")
-}

go.mod

@@ -4,8 +4,7 @@ go 1.20
 
 require (
 	github.com/fatih/color v1.15.0
-	github.com/sashabaranov/go-openai v1.5.8
-	github.com/schollz/progressbar/v3 v3.13.1
+	github.com/sashabaranov/go-openai v1.5.7
 	github.com/spf13/cobra v1.6.1
 	github.com/spf13/viper v1.15.0
 	golang.org/x/term v0.6.0
@@ -17,7 +16,6 @@ require (
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/emicklei/go-restful/v3 v3.10.2 // indirect
-	github.com/evanphx/json-patch v4.12.0+incompatible // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/go-logr/logr v1.2.4 // indirect
 	github.com/go-openapi/jsonpointer v0.19.6 // indirect
@@ -38,15 +36,11 @@ require (
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.18 // indirect
-	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.7 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
 	github.com/spf13/afero v1.9.5 // indirect
 	github.com/spf13/cast v1.5.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect

go.sum

@@ -66,8 +66,6 @@ github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5y
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/evanphx/json-patch v4.12.0+incompatible h1:4onqiflcdA9EOZ4RxV643DvftH5pOlLGNtQ5lPWQu84=
-github.com/evanphx/json-patch v4.12.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
 github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
 github.com/flowstack/go-jsonschema v0.1.1/go.mod h1:yL7fNggx1o8rm9RlgXv7hTBWxdBM0rVwpMwimd3F3N0=
@@ -175,7 +173,6 @@ github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnr
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
@@ -194,13 +191,8 @@ github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJ
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
 github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
-github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
-github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -214,23 +206,17 @@ github.com/onsi/ginkgo/v2 v2.4.0 h1:+Ig9nvqgS5OBSACXNk15PLdp0U9XPYROt9CFzVdFGIs=
 github.com/onsi/gomega v1.23.0 h1:/oxKu9c2HVap+F3PfKort2Hw5DEU+HGlW8n+tguWsys=
 github.com/pelletier/go-toml/v2 v2.0.7 h1:muncTPStnKRos5dpVKULv2FVd4bMOhNePj9CjgDb8Us=
 github.com/pelletier/go-toml/v2 v2.0.7/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sashabaranov/go-openai v1.5.8 h1:EfNEmc+Ue+CuRy7iSpNdxfHyiOv2vQsQ2Y0kZRA/z5w=
-github.com/sashabaranov/go-openai v1.5.8/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
-github.com/schollz/progressbar/v3 v3.13.1 h1:o8rySDYiQ59Mwzy2FELeHY5ZARXZTVJC7iHD6PEFUiE=
-github.com/schollz/progressbar/v3 v3.13.1/go.mod h1:xvrbki8kfT1fzWzBT/UZd9L6GA+jdL7HAgq2RFnO6fQ=
+github.com/sashabaranov/go-openai v1.5.7 h1:8DGgRG+P7yWixte5j720y6yiXgY3Hlgcd0gcpHdltfo=
+github.com/sashabaranov/go-openai v1.5.7/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.9.5 h1:stMpOSZFs//0Lv29HduCmli3GUfpFoF3Y1Q/aXj/wVM=
 github.com/spf13/afero v1.9.5/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ=

pkg/ai/iai.go

@@ -1,8 +1,25 @@
 package ai
 
-import "context"
+import (
+	"context"
+	"errors"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/ai/openai"
+)
+
+var AIProviderMap = map[string]IAI{
+	"openai": &openai.OpenAIClient{},
+}
 
 type IAI interface {
 	Configure(token string, language string) error
 	GetCompletion(ctx context.Context, prompt string) (string, error)
+	Parse(text string, prompt []string, nocache bool) (string, error)
+}
+
+func NewAIClient(provider string) (IAI, error) {
+	ai, ok := AIProviderMap[provider]
+	if !ok {
+		return nil, errors.New("AI provider not found")
+	}
+	return ai, nil
 }

pkg/ai/openai/openai.go

@@ -1,9 +1,13 @@
-package ai
+package openai
 
 import (
 	"context"
+	"encoding/base64"
 	"errors"
 	"fmt"
+	"github.com/fatih/color"
+	"github.com/spf13/viper"
+	"strings"
 
 	"github.com/sashabaranov/go-openai"
 )
@@ -16,8 +20,10 @@ const (
 )
 
 type OpenAIClient struct {
+	context  context.Context
 	client   *openai.Client
 	language string
+	nocache  bool
 }
 
 func (c *OpenAIClient) Configure(token string, language string) error {
@@ -46,3 +52,41 @@ func (c *OpenAIClient) GetCompletion(ctx context.Context, prompt string) (string
 	}
 	return resp.Choices[0].Message.Content, nil
 }
+
+func (c OpenAIClient) Parse(text string, prompt []string, nocache bool) (string, error) {
+
+	// parse the text with the AI backend
+	inputKey := strings.Join(prompt, " ")
+	// Check for cached data
+	sEnc := base64.StdEncoding.EncodeToString([]byte(inputKey))
+	// find in viper cache
+	if viper.IsSet(sEnc) && !c.nocache {
+		// retrieve data from cache
+		response := viper.GetString(sEnc)
+		if response == "" {
+			color.Red("error retrieving cached data")
+			return "", nil
+		}
+		output, err := base64.StdEncoding.DecodeString(response)
+		if err != nil {
+			color.Red("error decoding cached data: %v", err)
+			return "", nil
+		}
+		return string(output), nil
+	}
+
+	response, err := c.GetCompletion(c.context, inputKey)
+	if err != nil {
+		color.Red("error getting completion: %v", err)
+		return "", err
+	}
+
+	if !viper.IsSet(sEnc) {
+		viper.Set(sEnc, base64.StdEncoding.EncodeToString([]byte(response)))
+		if err := viper.WriteConfig(); err != nil {
+			color.Red("error writing config: %v", err)
+			return "", nil
+		}
+	}
+	return response, nil
+}

pkg/analysis/analysis.go

@@ -0,0 +1,98 @@
+package analysis
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	"github.com/spf13/viper"
+)
+
+type Analysis struct {
+	Context         context.Context
+	Namespace       string
+	NoCache         bool
+	Explain         bool
+	AIClient        ai.IAI
+	Filters         []string
+	Client          *kubernetes.Client
+	analysisResults []common.Result
+}
+
+func NewAnalysis(namespace string, noCache bool, explain bool, filters []string, aiProvider string) *Analysis {
+	var aiClient ai.IAI
+	var err error
+
+	ctx := context.Background()
+	client := viper.Get("kubernetesClient").(*kubernetes.Client)
+
+	if explain {
+		aiClient, err = ai.NewAIClient(aiProvider)
+		if err != nil {
+			fmt.Println("Error creating AI client: ", err)
+		}
+	}
+
+	return &Analysis{
+		Context:   ctx,
+		Namespace: namespace,
+		NoCache:   noCache,
+		Explain:   explain,
+		Filters:   filters,
+		Client:    client,
+		AIClient:  aiClient,
+	}
+}
+
+func (a *Analysis) RunAnalysis() error {
+	activeFilters := viper.GetStringSlice("active_filters")
+	analyzerList := analyzer.GetAnalyzerList()
+
+	// if there are no filters selected and no active_filters then run all of them
+	if len(a.Filters) == 0 && len(activeFilters) == 0 {
+		for _, al := range analyzerList {
+			thisanalysis, _ := analyzer.NewAnalyzer(al, a.Client, a.Context, a.Namespace, a.AIClient, a.Explain)
+			err := thisanalysis.Analyze()
+			if err != nil {
+				fmt.Println("Error running analysis: ", err)
+			}
+			a.analysisResults = append(a.analysisResults, thisanalysis.GetResult()...)
+		}
+		return nil
+	}
+
+	// if the filters flag is specified
+	if len(a.Filters) != 0 {
+		for _, filter := range a.Filters {
+			for _, ali := range analyzerList {
+				if filter == ali {
+					thisanalysis, _ := analyzer.NewAnalyzer(ali, a.Client, a.Context, a.Namespace, a.AIClient, a.Explain)
+					err := thisanalysis.Analyze()
+					if err != nil {
+						fmt.Println("Error running analysis: ", err)
+					}
+					a.analysisResults = append(a.analysisResults, thisanalysis.GetResult()...)
+				}
+			}
+		}
+		return nil
+	}
+	return nil
+}
+
+func (a *Analysis) PrintAnalysisResult() {
+	for _, result := range a.analysisResults {
+		fmt.Println(result)
+	}
+}
+
+func (a *Analysis) PrintJsonResult() {
+	output, err := json.MarshalIndent(a.analysisResults, "", "  ")
+	if err != nil {
+		fmt.Println("Error marshalling json: ", err)
+	}
+	fmt.Println(string(output))
+}

pkg/analyzer/analysis.go

@@ -1,34 +0,0 @@
-package analyzer
-
-import (
-	appsv1 "k8s.io/api/apps/v1"
-	autoscalingv1 "k8s.io/api/autoscaling/v1"
-	v1 "k8s.io/api/core/v1"
-	networkingv1 "k8s.io/api/networking/v1"
-	policyv1 "k8s.io/api/policy/v1"
-)
-
-type AnalysisConfiguration struct {
-	Namespace string
-	NoCache   bool
-	Explain   bool
-}
-
-type PreAnalysis struct {
-	Pod                      v1.Pod
-	FailureDetails           []string
-	ReplicaSet               appsv1.ReplicaSet
-	PersistentVolumeClaim    v1.PersistentVolumeClaim
-	Endpoint                 v1.Endpoints
-	Ingress                  networkingv1.Ingress
-	HorizontalPodAutoscalers autoscalingv1.HorizontalPodAutoscaler
-	PodDisruptionBudget      policyv1.PodDisruptionBudget
-}
-
-type Analysis struct {
-	Kind         string   `json:"kind"`
-	Name         string   `json:"name"`
-	Error        []string `json:"error"`
-	Details      string   `json:"details"`
-	ParentObject string   `json:"parentObject"`
-}

pkg/analyzer/analyzer.go

@@ -2,133 +2,78 @@ package analyzer
 
 import (
 	"context"
-	"encoding/base64"
-	"strings"
-
-	"github.com/fatih/color"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/hpa"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/ingress"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/pod"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/pvc"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/rs"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/service"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/spf13/viper"
 )
 
-var coreAnalyzerMap = map[string]IAnalyzer{
-	"Pod":                   PodAnalyzer{},
-	"ReplicaSet":            ReplicaSetAnalyzer{},
-	"PersistentVolumeClaim": PvcAnalyzer{},
-	"Service":               ServiceAnalyzer{},
-	"Ingress":               IngressAnalyzer{},
+type IAnalyzer interface {
+	Analyze() error
+	GetResult() []common.Result
 }
 
-var additionalAnalyzerMap = map[string]IAnalyzer{
-	"HorizontalPodAutoScaler": HpaAnalyzer{},
-	"PodDisruptionBudget":     PdbAnalyzer{},
+var AnalyzerMap = map[string]IAnalyzer{
+	"Pod":                   &pod.PodAnalyzer{},
+	"ReplicaSet":            &rs.ReplicaSetAnalyzer{},
+	"PersistentVolumeClaim": &pvc.PvcAnalyzer{},
+	"Service":               &service.ServiceAnalyzer{},
+	"Ingress":               &ingress.IngressAnalyzer{},
+	"HPA":                   &hpa.HPAAnalyzer{},
 }
 
-func RunAnalysis(ctx context.Context, filters []string, config *AnalysisConfiguration,
-	client *kubernetes.Client,
-	aiClient ai.IAI, analysisResults *[]Analysis) error {
+var coreAnalyzerList = []string{"Pod", "ReplicaSet", "PersistentVolumeClaim", "Service", "Ingress"}
+var additionalAnalyzerList = []string{"HPA"}
 
-	activeFilters := viper.GetStringSlice("active_filters")
-
-	analyzerMap := getAnalyzerMap()
-
-	// if there are no filters selected and no active_filters then run all of them
-	if len(filters) == 0 && len(activeFilters) == 0 {
-		for _, analyzer := range analyzerMap {
-			if err := analyzer.RunAnalysis(ctx, config, client, aiClient, analysisResults); err != nil {
-				return err
-			}
-		}
-		return nil
+func NewAnalyzer(analyzer string, client *kubernetes.Client, context context.Context, namespace string, aiClient ai.IAI, explain bool) (IAnalyzer, error) {
+	analyzerConfig := common.Analyzer{
+		AIClient:  aiClient,
+		Namespace: namespace,
+		Context:   context,
+		Client:    client,
+		Explain:   explain,
 	}
 
-	// if the filters flag is specified
-	if len(filters) != 0 {
-		for _, filter := range filters {
-			if analyzer, ok := analyzerMap[filter]; ok {
-				if err := analyzer.RunAnalysis(ctx, config, client, aiClient, analysisResults); err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	}
-
-	// use active_filters
-	for _, filter := range activeFilters {
-		if analyzer, ok := analyzerMap[filter]; ok {
-			if err := analyzer.RunAnalysis(ctx, config, client, aiClient, analysisResults); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func ParseViaAI(ctx context.Context, config *AnalysisConfiguration,
-	aiClient ai.IAI, prompt []string) (string, error) {
-	// parse the text with the AI backend
-	inputKey := strings.Join(prompt, " ")
-	// Check for cached data
-	sEnc := base64.StdEncoding.EncodeToString([]byte(inputKey))
-	// find in viper cache
-	if viper.IsSet(sEnc) && !config.NoCache {
-		// retrieve data from cache
-		response := viper.GetString(sEnc)
-		if response == "" {
-			color.Red("error retrieving cached data")
-			return "", nil
-		}
-		output, err := base64.StdEncoding.DecodeString(response)
-		if err != nil {
-			color.Red("error decoding cached data: %v", err)
-			return "", nil
-		}
-		return string(output), nil
-	}
-
-	response, err := aiClient.GetCompletion(ctx, inputKey)
-	if err != nil {
-		color.Red("error getting completion: %v", err)
-		return "", err
-	}
-
-	if !viper.IsSet(sEnc) {
-		viper.Set(sEnc, base64.StdEncoding.EncodeToString([]byte(response)))
-		if err := viper.WriteConfig(); err != nil {
-			color.Red("error writing config: %v", err)
-			return "", nil
-		}
-	}
-	return response, nil
+	analyzerConfig.PreAnalysis = make(map[string]common.PreAnalysis)
+	return AnalyzerMap[analyzer], nil
 }
 
 func ListFilters() ([]string, []string) {
-	coreKeys := make([]string, 0, len(coreAnalyzerMap))
-	for k := range coreAnalyzerMap {
-		coreKeys = append(coreKeys, k)
+	coreKeys := []string{}
+	for _, filter := range coreAnalyzerList {
+		coreKeys = append(coreKeys, filter)
 	}
 
-	additionalKeys := make([]string, 0, len(additionalAnalyzerMap))
-	for k := range additionalAnalyzerMap {
-		additionalKeys = append(additionalKeys, k)
+	additionalKeys := []string{}
+	for _, filter := range coreAnalyzerList {
+		coreKeys = append(additionalKeys, filter)
 	}
 	return coreKeys, additionalKeys
 }
 
-func getAnalyzerMap() map[string]IAnalyzer {
+func GetAnalyzerList() []string {
+	list := []string{}
 
-	mergedMap := make(map[string]IAnalyzer)
+	list = append(list, coreAnalyzerList...)
+	list = append(list, additionalAnalyzerList...)
 
-	// add core analyzer
-	for key, value := range coreAnalyzerMap {
-		mergedMap[key] = value
-	}
+	list = removeDuplicateStr(list)
 
-	// add additional analyzer
-	for key, value := range additionalAnalyzerMap {
-		mergedMap[key] = value
-	}
-
-	return mergedMap
+	return list
+}
+func removeDuplicateStr(strSlice []string) []string {
+	allKeys := make(map[string]bool)
+	list := []string{}
+	for _, item := range strSlice {
+		if _, value := allKeys[item]; !value {
+			allKeys[item] = true
+			list = append(list, item)
+		}
+	}
+	return list
 }

pkg/analyzer/common/events.go

@@ -0,0 +1,57 @@
+package common
+
+import (
+	"context"
+
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func FetchLatestPodEvent(ctx context.Context, kubernetesClient *kubernetes.Client, pod *v1.Pod) (*v1.Event, error) {
+
+	// get the list of events
+	events, err := kubernetesClient.GetClient().CoreV1().Events(pod.Namespace).List(ctx,
+		metav1.ListOptions{
+			FieldSelector: "involvedObject.name=" + pod.Name,
+		})
+
+	if err != nil {
+		return nil, err
+	}
+	// find most recent event
+	var latestEvent *v1.Event
+	for _, event := range events.Items {
+		if latestEvent == nil {
+			latestEvent = &event
+		}
+		if event.LastTimestamp.After(latestEvent.LastTimestamp.Time) {
+			latestEvent = &event
+		}
+	}
+	return latestEvent, nil
+}
+
+func FetchLatestPvcEvent(ctx context.Context, kubernetesClient *kubernetes.Client, pvc *v1.PersistentVolumeClaim) (*v1.Event, error) {
+
+	// get the list of events
+	events, err := kubernetesClient.GetClient().CoreV1().Events(pvc.Namespace).List(ctx,
+		metav1.ListOptions{
+			FieldSelector: "involvedObject.name=" + pvc.Name,
+		})
+
+	if err != nil {
+		return nil, err
+	}
+	// find most recent event
+	var latestEvent *v1.Event
+	for _, event := range events.Items {
+		if latestEvent == nil {
+			latestEvent = &event
+		}
+		if event.LastTimestamp.After(latestEvent.LastTimestamp.Time) {
+			latestEvent = &event
+		}
+	}
+	return latestEvent, nil
+}

pkg/analyzer/common/types.go

@@ -0,0 +1,40 @@
+package common
+
+import (
+	"context"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	appsv1 "k8s.io/api/apps/v1"
+	autov1 "k8s.io/api/autoscaling/v1"
+	v1 "k8s.io/api/core/v1"
+	networkv1 "k8s.io/api/networking/v1"
+)
+
+type Analyzer struct {
+	Client      *kubernetes.Client
+	AIClient    ai.IAI
+	Context     context.Context
+	Namespace   string
+	PreAnalysis map[string]PreAnalysis
+	Explain     bool
+	NoCache     bool
+	Result      []Result
+}
+
+type Result struct {
+	Kind         string   `json:"kind"`
+	Name         string   `json:"name"`
+	Error        []string `json:"error"`
+	Details      string   `json:"details"`
+	ParentObject string   `json:"parentObject"`
+}
+
+type PreAnalysis struct {
+	Pod                      v1.Pod
+	FailureDetails           []string
+	ReplicaSet               appsv1.ReplicaSet
+	PersistentVolumeClaim    v1.PersistentVolumeClaim
+	Endpoint                 v1.Endpoints
+	Ingress                  networkv1.Ingress
+	HorizontalPodAutoscalers autov1.HorizontalPodAutoscaler
+}

pkg/analyzer/events.go

@@ -1,33 +0,0 @@
-package analyzer
-
-import (
-	"context"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-func FetchLatestEvent(ctx context.Context, kubernetesClient *kubernetes.Client, namespace string, name string) (*v1.Event, error) {
-
-	// get the list of events
-	events, err := kubernetesClient.GetClient().CoreV1().Events(namespace).List(ctx,
-		metav1.ListOptions{
-			FieldSelector: "involvedObject.name=" + name,
-		})
-
-	if err != nil {
-		return nil, err
-	}
-	// find most recent event
-	var latestEvent *v1.Event
-	for _, event := range events.Items {
-		if latestEvent == nil {
-			latestEvent = &event
-		}
-		if event.LastTimestamp.After(latestEvent.LastTimestamp.Time) {
-			latestEvent = &event
-		}
-	}
-	return latestEvent, nil
-}

pkg/analyzer/hpa/hpaAnalyzer.go

@@ -1,27 +1,22 @@
-package analyzer
+package hpa
 
 import (
-	"context"
 	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-type HpaAnalyzer struct{}
+type HPAAnalyzer struct {
+	common.Analyzer
+}
 
-func (HpaAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration, client *kubernetes.Client, aiClient ai.IAI,
-	analysisResults *[]Analysis) error {
-
-	list, err := client.GetClient().AutoscalingV1().HorizontalPodAutoscalers(config.Namespace).List(ctx, metav1.ListOptions{})
+func (a *HPAAnalyzer) Analyze() error {
+	list, err := a.Client.GetClient().AutoscalingV1().HorizontalPodAutoscalers(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
 
-	var preAnalysis = map[string]PreAnalysis{}
-
 	for _, hpa := range list.Items {
 		var failures []string
 
@@ -31,22 +26,22 @@ func (HpaAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 
 		switch scaleTargetRef.Kind {
 		case "Deployment":
-			_, err := client.GetClient().AppsV1().Deployments(config.Namespace).Get(ctx, scaleTargetRef.Name, metav1.GetOptions{})
+			_, err := a.Client.GetClient().AppsV1().Deployments(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
 			if err != nil {
 				scaleTargetRefNotFound = true
 			}
 		case "ReplicationController":
-			_, err := client.GetClient().CoreV1().ReplicationControllers(config.Namespace).Get(ctx, scaleTargetRef.Name, metav1.GetOptions{})
+			_, err := a.Client.GetClient().CoreV1().ReplicationControllers(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
 			if err != nil {
 				scaleTargetRefNotFound = true
 			}
 		case "ReplicaSet":
-			_, err := client.GetClient().AppsV1().ReplicaSets(config.Namespace).Get(ctx, scaleTargetRef.Name, metav1.GetOptions{})
+			_, err := a.Client.GetClient().AppsV1().ReplicaSets(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
 			if err != nil {
 				scaleTargetRefNotFound = true
 			}
 		case "StatefulSet":
-			_, err := client.GetClient().AppsV1().StatefulSets(config.Namespace).Get(ctx, scaleTargetRef.Name, metav1.GetOptions{})
+			_, err := a.Client.GetClient().AppsV1().StatefulSets(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
 			if err != nil {
 				scaleTargetRefNotFound = true
 			}
@@ -59,25 +54,26 @@ func (HpaAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 		}
 
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", hpa.Namespace, hpa.Name)] = PreAnalysis{
+			a.PreAnalysis[fmt.Sprintf("%s/%s", hpa.Namespace, hpa.Name)] = common.PreAnalysis{
 				HorizontalPodAutoscalers: hpa,
 				FailureDetails:           failures,
 			}
 		}
-
 	}
 
-	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
+	for key, value := range a.PreAnalysis {
+		var currentAnalysis = common.Result{
 			Kind:  "HorizontalPodAutoscaler",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
-
-		parent, _ := util.GetParent(client, value.HorizontalPodAutoscalers.ObjectMeta)
+		parent, _ := util.GetParent(a.Client, value.Ingress.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
 	return nil
 }
+
+func (a *HPAAnalyzer) GetResult() []common.Result {
+	return a.Result
+}

pkg/analyzer/ianalyzer.go

@@ -1,13 +0,0 @@
-package analyzer
-
-import (
-	"context"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-)
-
-type IAnalyzer interface {
-	RunAnalysis(ctx context.Context, config *AnalysisConfiguration, client *kubernetes.Client, aiClient ai.IAI,
-		analysisResults *[]Analysis) error
-}

pkg/analyzer/ingress/ingressAnalyzer.go

@@ -1,27 +1,23 @@
-package analyzer
+package ingress
 
 import (
-	"context"
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-type IngressAnalyzer struct{}
+type IngressAnalyzer struct {
+	common.Analyzer
+}
 
-func (IngressAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration, client *kubernetes.Client, aiClient ai.IAI,
-	analysisResults *[]Analysis) error {
-
-	list, err := client.GetClient().NetworkingV1().Ingresses(config.Namespace).List(ctx, metav1.ListOptions{})
+func (a *IngressAnalyzer) Analyze() error {
+	list, err := a.Client.GetClient().NetworkingV1().Ingresses(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
 
-	var preAnalysis = map[string]PreAnalysis{}
-
 	for _, ing := range list.Items {
 		var failures []string
 
@@ -38,7 +34,7 @@ func (IngressAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfigur
 
 		// check if ingressclass exist
 		if ingressClassName != nil {
-			_, err := client.GetClient().NetworkingV1().IngressClasses().Get(ctx, *ingressClassName, metav1.GetOptions{})
+			_, err := a.Client.GetClient().NetworkingV1().IngressClasses().Get(a.Context, *ingressClassName, metav1.GetOptions{})
 			if err != nil {
 				failures = append(failures, fmt.Sprintf("Ingress uses the ingress class %s which does not exist.", *ingressClassName))
 			}
@@ -48,7 +44,7 @@ func (IngressAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfigur
 		for _, rule := range ing.Spec.Rules {
 			// loop over paths
 			for _, path := range rule.HTTP.Paths {
-				_, err := client.GetClient().CoreV1().Services(ing.Namespace).Get(ctx, path.Backend.Service.Name, metav1.GetOptions{})
+				_, err := a.Client.GetClient().CoreV1().Services(ing.Namespace).Get(a.Context, path.Backend.Service.Name, metav1.GetOptions{})
 				if err != nil {
 					failures = append(failures, fmt.Sprintf("Ingress uses the service %s/%s which does not exist.", ing.Namespace, path.Backend.Service.Name))
 				}
@@ -56,13 +52,13 @@ func (IngressAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfigur
 		}
 
 		for _, tls := range ing.Spec.TLS {
-			_, err := client.GetClient().CoreV1().Secrets(ing.Namespace).Get(ctx, tls.SecretName, metav1.GetOptions{})
+			_, err := a.Client.GetClient().CoreV1().Secrets(ing.Namespace).Get(a.Context, tls.SecretName, metav1.GetOptions{})
 			if err != nil {
 				failures = append(failures, fmt.Sprintf("Ingress uses the secret %s/%s as a TLS certificate which does not exist.", ing.Namespace, tls.SecretName))
 			}
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", ing.Namespace, ing.Name)] = PreAnalysis{
+			a.PreAnalysis[fmt.Sprintf("%s/%s", ing.Namespace, ing.Name)] = common.PreAnalysis{
 				Ingress:        ing,
 				FailureDetails: failures,
 			}
@@ -70,17 +66,20 @@ func (IngressAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfigur
 
 	}
 
-	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
+	for key, value := range a.PreAnalysis {
+		var currentAnalysis = common.Result{
 			Kind:  "Ingress",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
 
-		parent, _ := util.GetParent(client, value.Ingress.ObjectMeta)
+		parent, _ := util.GetParent(a.Client, value.Ingress.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
 	return nil
 }
+
+func (a *IngressAnalyzer) GetResult() []common.Result {
+	return a.Result
+}

pkg/analyzer/pdbAnalyzer.go

@@ -1,67 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type PdbAnalyzer struct{}
-
-func (PdbAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration, client *kubernetes.Client, aiClient ai.IAI,
-	analysisResults *[]Analysis) error {
-
-	list, err := client.GetClient().PolicyV1().PodDisruptionBudgets(config.Namespace).List(ctx, metav1.ListOptions{})
-	if err != nil {
-		return err
-	}
-
-	var preAnalysis = map[string]PreAnalysis{}
-
-	for _, pdb := range list.Items {
-		var failures []string
-
-		evt, err := FetchLatestEvent(ctx, client, pdb.Namespace, pdb.Name)
-		if err != nil || evt == nil {
-			continue
-		}
-
-		if evt.Reason == "NoPods" && evt.Message != "" {
-			if pdb.Spec.Selector != nil {
-				for k, v := range pdb.Spec.Selector.MatchLabels {
-					failures = append(failures, fmt.Sprintf("%s, expected label %s=%s", evt.Message, k, v))
-				}
-				for _, v := range pdb.Spec.Selector.MatchExpressions {
-					failures = append(failures, fmt.Sprintf("%s, expected expression %s", evt.Message, v))
-				}
-			} else {
-				failures = append(failures, fmt.Sprintf("%s, selector is nil", evt.Message))
-			}
-		}
-
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", pdb.Namespace, pdb.Name)] = PreAnalysis{
-				PodDisruptionBudget: pdb,
-				FailureDetails:      failures,
-			}
-		}
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
-			Kind:  "PodDisruptionBudget",
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(client, value.PodDisruptionBudget.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
-	}
-
-	return nil
-}

pkg/analyzer/pod/podAnalyzer.go

@@ -1,27 +1,22 @@
-package analyzer
+package pod
 
 import (
-	"context"
 	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-type PodAnalyzer struct{}
-
-func (PodAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration,
-	client *kubernetes.Client, aiClient ai.IAI, analysisResults *[]Analysis) error {
+type PodAnalyzer struct {
+	common.Analyzer ", inline"
+}
 
+func (a *PodAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
-	list, err := client.GetClient().CoreV1().Pods(config.Namespace).List(ctx, metav1.ListOptions{})
+	list, err := a.Client.GetClient().CoreV1().Pods(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
-	var preAnalysis = map[string]PreAnalysis{}
-
 	for _, pod := range list.Items {
 		var failures []string
 		// Check for pending pods
@@ -49,7 +44,7 @@ func (PodAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 				if containerStatus.State.Waiting.Reason == "ContainerCreating" && pod.Status.Phase == "Pending" {
 
 					// parse the event log and append details
-					evt, err := FetchLatestEvent(ctx, client, pod.Namespace, pod.Name)
+					evt, err := common.FetchLatestPodEvent(a.Context, a.Client, &pod)
 					if err != nil || evt == nil {
 						continue
 					}
@@ -60,24 +55,27 @@ func (PodAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 			}
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", pod.Namespace, pod.Name)] = PreAnalysis{
+			a.PreAnalysis[fmt.Sprintf("%s/%s", pod.Namespace, pod.Name)] = common.PreAnalysis{
 				Pod:            pod,
 				FailureDetails: failures,
 			}
 		}
 	}
 
-	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
+	for key, value := range a.PreAnalysis {
+		var currentAnalysis = common.Result{
 			Kind:  "Pod",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
 
-		parent, _ := util.GetParent(client, value.Pod.ObjectMeta)
+		parent, _ := util.GetParent(a.Client, value.Pod.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
 	return nil
 }
+
+func (a *PodAnalyzer) GetResult() []common.Result {
+	return a.Result
+}

pkg/analyzer/podAnalyzer_test.go

@@ -1,45 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestPodAnalzyer(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(&v1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:        "example",
-			Namespace:   "default",
-			Annotations: map[string]string{},
-		},
-		Status: v1.PodStatus{
-			Phase: v1.PodPending,
-			Conditions: []v1.PodCondition{
-				{
-					Type:    v1.PodScheduled,
-					Reason:  "Unschedulable",
-					Message: "0/1 nodes are available: 1 node(s) had taint {node-role.kubernetes.io/master: }, that the pod didn't tolerate.",
-				},
-			},
-		},
-	})
-
-	podAnalyzer := PodAnalyzer{}
-	var analysisResults []Analysis
-	podAnalyzer.RunAnalysis(context.Background(),
-		&AnalysisConfiguration{
-			Namespace: "default",
-		},
-		&kubernetes.Client{
-			Client: clientset,
-		}, nil, &analysisResults)
-
-	assert.Equal(t, len(analysisResults), 1)
-}

pkg/analyzer/pvc/pvcAnalyzer.go

@@ -1,26 +1,25 @@
-package analyzer
+package pvc
 
 import (
-	"context"
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-type PvcAnalyzer struct{}
-
-func (PvcAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration, client *kubernetes.Client, aiClient ai.IAI, analysisResults *[]Analysis) error {
+type PvcAnalyzer struct {
+	common.Analyzer
+}
 
+func (a *PvcAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
-	list, err := client.GetClient().CoreV1().PersistentVolumeClaims(config.Namespace).List(ctx, metav1.ListOptions{})
+	list, err := a.Client.GetClient().CoreV1().PersistentVolumeClaims(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
 
-	var preAnalysis = map[string]PreAnalysis{}
+	var preAnalysis = map[string]common.PreAnalysis{}
 
 	for _, pvc := range list.Items {
 		var failures []string
@@ -29,7 +28,7 @@ func (PvcAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 		if pvc.Status.Phase == "Pending" {
 
 			// parse the event log and append details
-			evt, err := FetchLatestEvent(ctx, client, pvc.Namespace, pvc.Name)
+			evt, err := common.FetchLatestPvcEvent(a.Context, a.Client, &pvc)
 			if err != nil || evt == nil {
 				continue
 			}
@@ -38,7 +37,7 @@ func (PvcAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 			}
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", pvc.Namespace, pvc.Name)] = PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", pvc.Namespace, pvc.Name)] = common.PreAnalysis{
 				PersistentVolumeClaim: pvc,
 				FailureDetails:        failures,
 			}
@@ -46,16 +45,19 @@ func (PvcAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguratio
 	}
 
 	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
+		var currentAnalysis = common.Result{
 			Kind:  "PersistentVolumeClaim",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
 
-		parent, _ := util.GetParent(client, value.PersistentVolumeClaim.ObjectMeta)
+		parent, _ := util.GetParent(a.Client, value.PersistentVolumeClaim.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
 	return nil
 }
+
+func (a *PvcAnalyzer) GetResult() []common.Result {
+	return a.Result
+}

pkg/analyzer/rs/rsAnalyzer.go

@@ -1,27 +1,25 @@
-package analyzer
+package rs
 
 import (
-	"context"
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-type ReplicaSetAnalyzer struct{}
-
-func (ReplicaSetAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration,
-	client *kubernetes.Client, aiClient ai.IAI, analysisResults *[]Analysis) error {
+type ReplicaSetAnalyzer struct {
+	common.Analyzer
+}
 
+func (a *ReplicaSetAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
-	list, err := client.GetClient().AppsV1().ReplicaSets(config.Namespace).List(ctx, metav1.ListOptions{})
+	list, err := a.Client.GetClient().AppsV1().ReplicaSets(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
 
-	var preAnalysis = map[string]PreAnalysis{}
+	var preAnalysis = map[string]common.PreAnalysis{}
 
 	for _, rs := range list.Items {
 		var failures []string
@@ -37,7 +35,7 @@ func (ReplicaSetAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfi
 			}
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", rs.Namespace, rs.Name)] = PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", rs.Namespace, rs.Name)] = common.PreAnalysis{
 				ReplicaSet:     rs,
 				FailureDetails: failures,
 			}
@@ -45,16 +43,19 @@ func (ReplicaSetAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfi
 	}
 
 	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
+		var currentAnalysis = common.Result{
 			Kind:  "ReplicaSet",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
 
-		parent, _ := util.GetParent(client, value.ReplicaSet.ObjectMeta)
+		parent, _ := util.GetParent(a.Client, value.ReplicaSet.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
 	return nil
 }
+
+func (a *ReplicaSetAnalyzer) GetResult() []common.Result {
+	return a.Result
+}

pkg/analyzer/service/serviceAnalyzer.go

@@ -1,35 +1,33 @@
-package analyzer
+package service
 
 import (
-	"context"
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 
 	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-type ServiceAnalyzer struct{}
-
-func (ServiceAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfiguration, client *kubernetes.Client, aiClient ai.IAI,
-	analysisResults *[]Analysis) error {
+type ServiceAnalyzer struct {
+	common.Analyzer
+}
 
+func (a *ServiceAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
-	list, err := client.GetClient().CoreV1().Endpoints(config.Namespace).List(ctx, metav1.ListOptions{})
+	list, err := a.Client.GetClient().CoreV1().Endpoints(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
 		return err
 	}
 
-	var preAnalysis = map[string]PreAnalysis{}
+	var preAnalysis = map[string]common.PreAnalysis{}
 
 	for _, ep := range list.Items {
 		var failures []string
 
 		// Check for empty service
 		if len(ep.Subsets) == 0 {
-			svc, err := client.GetClient().CoreV1().Services(ep.Namespace).Get(ctx, ep.Name, metav1.GetOptions{})
+			svc, err := a.Client.GetClient().CoreV1().Services(ep.Namespace).Get(a.Context, ep.Name, metav1.GetOptions{})
 			if err != nil {
 				color.Yellow("Service %s/%s does not exist", ep.Namespace, ep.Name)
 				continue
@@ -55,7 +53,7 @@ func (ServiceAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfigur
 		}
 
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", ep.Namespace, ep.Name)] = PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", ep.Namespace, ep.Name)] = common.PreAnalysis{
 				Endpoint:       ep,
 				FailureDetails: failures,
 			}
@@ -63,15 +61,19 @@ func (ServiceAnalyzer) RunAnalysis(ctx context.Context, config *AnalysisConfigur
 	}
 
 	for key, value := range preAnalysis {
-		var currentAnalysis = Analysis{
+		var currentAnalysis = common.Result{
 			Kind:  "Service",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
 
-		parent, _ := util.GetParent(client, value.Endpoint.ObjectMeta)
+		parent, _ := util.GetParent(a.Client, value.Endpoint.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		*analysisResults = append(*analysisResults, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
 	return nil
 }
+
+func (a *ServiceAnalyzer) GetResult() []common.Result {
+	return a.Result
+}

pkg/analyzer/serviceAnalyzer_test.go

@@ -1,46 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestServiceAnalzyer(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(&v1.Endpoints{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:        "example",
-			Namespace:   "default",
-			Annotations: map[string]string{},
-		},
-	},
-		&v1.Service{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-			Spec: v1.ServiceSpec{
-				Selector: map[string]string{
-					"app": "example",
-				},
-			}})
-
-	serviceAnalyzer := ServiceAnalyzer{}
-	var analysisResults []Analysis
-	serviceAnalyzer.RunAnalysis(context.Background(),
-		&AnalysisConfiguration{
-			Namespace: "default",
-		},
-		&kubernetes.Client{
-			Client: clientset,
-		}, nil, &analysisResults)
-
-	assert.Equal(t, len(analysisResults), 1)
-}

pkg/kubernetes/kubernetes.go

@@ -6,11 +6,11 @@ import (
 )
 
 type Client struct {
-	Client kubernetes.Interface
+	client *kubernetes.Clientset
 }
 
-func (c *Client) GetClient() kubernetes.Interface {
-	return c.Client
+func (c *Client) GetClient() *kubernetes.Clientset {
+	return c.client
 }
 
 func NewClient(kubecontext string, kubeconfig string) (*Client, error) {
@@ -31,6 +31,6 @@ func NewClient(kubecontext string, kubeconfig string) (*Client, error) {
 	}
 
 	return &Client{
-		Client: clientSet,
+		client: clientSet,
 	}, nil
 }