debug

var ProblemPodCrashLoopBackOff = Problem{
	Resource:         "pod",
	ID:               "PodCrashLoopBackOff",
	ShortDescription: "A pod is in a crash loop backoff state, meaning it is crashing repeatedly",
	Detector: func(ctx context.Context, obj runtime.Object) (string, bool, bool) {
		pod, ok := obj.(*corev1.Pod)
		if !ok {
			return "", false, false
		}

		isCrashLoopBackoff := func(cs *corev1.ContainerStatus) bool {
			return cs.State.Waiting != nil && cs.State.Waiting.Reason == "CrashLoopBackOff"
		}

		for i := range pod.Status.ContainerStatuses {
			cs := &pod.Status.ContainerStatuses[i]
			if isCrashLoopBackoff(cs) {
				return fmt.Sprintf("Container %s in a crash loop backoff state: %v",
					cs.Name, cs.LastTerminationState.Terminated.Message,
				), false, true
			}
		}

		for i := range pod.Status.InitContainerStatuses {
			cs := &pod.Status.InitContainerStatuses[i]
			if isCrashLoopBackoff(cs) {
				return fmt.Sprintf("Init container %s in a crash loop backoff state: %v",
					cs.Name, cs.LastTerminationState.Terminated.Message,
				), false, true
			}
		}

		return "", false, false
	},
}

var ProblemPodImagePullBackOff = Problem{
	Resource:         "pod",
	ID:               "PodImagePullBackOff",
	ShortDescription: "A pod is in a image pull backoff state, meaning it is unable to pull the image",
	Detector: func(ctx context.Context, obj runtime.Object) (string, bool, bool) {
		pod, ok := obj.(*corev1.Pod)
		if !ok {
			return "", false, false
		}

		isImagePullBackOff := func(cs *corev1.ContainerStatus) bool {

			return cs.State.Waiting != nil &&
				(cs.State.Waiting.Reason == "ImagePullBackOff" || cs.State.Waiting.Reason == "ErrImagePull")
		}

		getImageForContainerStatus := func(isInitContainer bool, cs *corev1.ContainerStatus) string {
			sl := pod.Spec.Containers
			if isInitContainer {
				sl = pod.Spec.InitContainers
			}

			var container *corev1.Container
			for i := range sl {
				c := &sl[i]
				if c.Name == cs.Name {
					container = c
					break
				}
			}
			if container == nil {
				return "unknown"
			}

			return container.Image
		}

		for i := range pod.Status.ContainerStatuses {
			cs := &pod.Status.ContainerStatuses[i]
			imageName := getImageForContainerStatus(false, cs)
			if isImagePullBackOff(cs) {
				return fmt.Sprintf("Container %s is failing to pull its image (%s)", cs.Name, imageName), false, true
			}
		}

		for i := range pod.Status.InitContainerStatuses {
			cs := &pod.Status.InitContainerStatuses[i]
			imageName := getImageForContainerStatus(true, cs)
			if isImagePullBackOff(cs) {
				return fmt.Sprintf("Container %s is failing to pull its image (%s)", cs.Name, imageName), false, true
			}
		}

		return "", false, false
	},
}

var ProblemPodNotReady = Problem{
	Resource:         "pod",
	ID:               "PodNotReady",
	ShortDescription: "A pod is not ready which can indicate a problem with the pod",
	Detector: func(ctx context.Context, obj runtime.Object) (string, bool, bool) {
		pod, ok := obj.(*corev1.Pod)
		if !ok {
			return "", false, false
		}

		if pod.Status.Phase != corev1.PodRunning {
			return "", false, false
		}

		for i := range pod.Status.ContainerStatuses {
			cs := &pod.Status.ContainerStatuses[i]
			if !cs.Ready {
				return fmt.Sprintf("Container %s is not ready", cs.Name), false, true
			}
		}

		return "", false, false
	},
}

var ProblemPodOOMKilled = Problem{
	Resource:         "pod",
	ID:               "PodOOMKilled",
	ShortDescription: "A pod was killed because it ran out of memory recently",
	Detector: func(ctx context.Context, obj runtime.Object) (string, bool, bool) {
		pod, ok := obj.(*corev1.Pod)
		if !ok {
			return "", false, false
		}

		for i := range pod.Status.ContainerStatuses {
			cs := &pod.Status.ContainerStatuses[i]
			if cs.State.Terminated != nil && cs.State.Terminated.Reason == "OOMKilled" {
				return fmt.Sprintf("Container %s was killed because it ran out of memory", cs.Name), false, true
			}

			if cs.LastTerminationState.Terminated != nil && cs.LastTerminationState.Terminated.Reason == "OOMKilled" {
				return fmt.Sprintf("Container %s was recently killed because it ran out of memory: %s",
					cs.Name,
					cs.LastTerminationState.Terminated.FinishedAt.Time,
				), true, true
			}
		}

		return "", false, false
	},
}

var ProblemPodPending = Problem{
	Resource:         "pod",
	ID:               "PodPending",
	ShortDescription: "A pod is pending",
	Detector: func(ctx context.Context, obj runtime.Object) (string, bool, bool) {
		pod, ok := obj.(*corev1.Pod)
		if !ok {
			return "", false, false
		}

		if pod.Status.Phase != corev1.PodPending {
			return "", false, false
		}

		for i := range pod.Status.ContainerStatuses {
			cs := &pod.Status.ContainerStatuses[i]
			if cs.State.Waiting != nil {
				return fmt.Sprintf("Container %s is pending: %s", cs.Name, cs.State.Waiting.Message), false, true
			}
		}

		for i := range pod.Status.InitContainerStatuses {
			cs := &pod.Status.InitContainerStatuses[i]
			if cs.State.Waiting != nil {
				return fmt.Sprintf("Init container %s is pending: %s", cs.Name, cs.State.Waiting.Message), false, true
			}
		}

		return "", false, false
	},
}

var ProblemVaultTokenExpired = Problem{
	Resource:         "vault",
	ID:               "VaultTokenExpired",
	ShortDescription: "Vault token is expired, run `devenv auth refresh` to get a new token",
	Detector: func(ctx context.Context, obj runtime.Object) (string, bool, bool) {
		b, err := box.LoadBox()
		if err != nil {
			return fmt.Sprintf("failed to load box configuration, %s", err), false, true
		}

		if b.DeveloperEnvironmentConfig.VaultConfig.Enabled {

			nullLogger := logrus.New()
			nullLogger.Out = io.Discard
			if err := vault.IsLoggedIn(ctx, nullLogger, b); err != nil {
				return fmt.Sprintf("failed to get vault authentication status, %s", err), false, true
			}
		}

		return "", false, false
	},
}