Repository: kubernetes-sigs/scheduler-plugins
Pull request #813 (2024-10-29 11:07:54)

feature: use contextal logging 
<!--  Thanks for sending a pull request!  Here are some tips for you:

1. If this is your first time, please read our contributor guidelines: https://git.k8s.io/community/contributors/guide/first-contribution.md#your-first-contribution and developer guide https://git.k8s.io/community/contributors/devel/development.md#development-guide
2. Please label this pull request according to what type of issue you are addressing, especially if this is a release targeted pull request. For reference on required PR/issue labels, read here:
https://git.k8s.io/community/contributors/devel/sig-release/release.md#issuepr-kind-label
3. Ensure you have added or ran the appropriate tests for your PR: https://git.k8s.io/community/contributors/devel/sig-testing/testing.md
4. If you want *faster* PR reviews, read how: https://git.k8s.io/community/contributors/guide/pull-requests.md#best-practices-for-faster-reviews
5. If the PR is unfinished, see how to mark it: https://git.k8s.io/community/contributors/guide/pull-requests.md#marking-unfinished-pull-requests
-->

#### What type of PR is this?

<!--
Add one of the following kinds:
/kind bug
/kind cleanup
/kind documentation
/kind feature

Optionally add one or more of the following kinds if applicable:
/kind api-change
/kind deprecation
/kind failing-test
/kind flake
/kind regression
-->

#### What this PR does / why we need it:
- use contextal logging

Due to the large scope, I may only be able to complete part of the plugins work in this PR.
- coscheduling
- capacityscheduling
- networkaware
- sysched
#### Which issue(s) this PR fixes:
<!--
*Automatically closes linked issue when PR is merged.
Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
-->
Fixes # part of https://github.com/kubernetes-sigs/scheduler-plugins/issues/743

#### Special notes for your reviewer:

#### Does this PR introduce a user-facing change?
<!--
If no, just write "NONE" in the release-note block below.
If yes, a release note is required:
Enter your extended release note in the block below. If the PR requires additional action from users switching to the new release, include the string "action required".

For more information on release notes see: https://git.k8s.io/community/contributors/guide/release-notes.md
-->
```release-note
None
```


k8s-ci-robot: Adding the "do-not-merge/release-note-label-needed" label because no release-note block was detected, please follow our [release note process](https://git.k8s.io/community/contributors/guide/release-notes.md) to remove it.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository.
</details>
k8s-ci-robot: [APPROVALNOTIFIER] This PR is **NOT APPROVED**

This pull-request has been approved by: *<a href="https://github.com/kubernetes-sigs/scheduler-plugins/pull/813#" title="Author self-approved">googs1025</a>*
**Once this PR has been reviewed and has the lgtm label**, please assign [huang-wei](https://github.com/huang-wei) for approval. For more information see [the Kubernetes Code Review Process](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process).

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes-sigs%2Fscheduler-plugins).

<details open>
Needs approval from an approver in each of these files:

- **[OWNERS](https://github.com/kubernetes-sigs/scheduler-plugins/blob/master/OWNERS)**

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":["huang-wei"]} -->
netlify[bot]: ### <span aria-hidden="true">👷</span> Deploy Preview for *kubernetes-sigs-scheduler-plugins* processing.


|  Name | Link |
|:-:|------------------------|
|<span aria-hidden="true">🔨</span> Latest commit | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 |
|<span aria-hidden="true">🔍</span> Latest deploy log | https://app.netlify.com/sites/kubernetes-sigs-scheduler-plugins/deploys/6720c20d0f15f80008837408 |
k8s-ci-robot: @googs1025: The following test **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-scheduler-plugins-verify-build-master | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_scheduler-plugins/813/pull-scheduler-plugins-verify-build-master/1851219414435762176) | true | `/test pull-scheduler-plugins-verify-build-master`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=scheduler-plugins&pr=813). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Agoogs1025). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/scheduler-plugins/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
k8s-ci-robot: @googs1025: The following tests **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-scheduler-plugins-verify-build-master | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_scheduler-plugins/813/pull-scheduler-plugins-verify-build-master/1851219414435762176) | true | `/test pull-scheduler-plugins-verify-build-master`
pull-scheduler-plugins-integration-test-master | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_scheduler-plugins/813/pull-scheduler-plugins-integration-test-master/1851219414536425472) | true | `/test pull-scheduler-plugins-integration-test-master`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=scheduler-plugins&pr=813). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Agoogs1025). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/scheduler-plugins/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
k8s-ci-robot: @googs1025: The following tests **failed**, say `/retest` to rerun all failed tests or `/retest-required` to rerun all mandatory failed tests:

Test name | Commit | Details | Required | Rerun command
--- | --- | --- | --- | ---
pull-scheduler-plugins-verify-build-master | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_scheduler-plugins/813/pull-scheduler-plugins-verify-build-master/1851219414435762176) | true | `/test pull-scheduler-plugins-verify-build-master`
pull-scheduler-plugins-integration-test-master | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_scheduler-plugins/813/pull-scheduler-plugins-integration-test-master/1851219414536425472) | true | `/test pull-scheduler-plugins-integration-test-master`
pull-scheduler-plugins-unit-test-master | 74852c4b4e074a07e57e6d4c4e019b96a6996db1 | [link](https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_scheduler-plugins/813/pull-scheduler-plugins-unit-test-master/1851219414490288128) | true | `/test pull-scheduler-plugins-unit-test-master`

[Full PR test history](https://prow.k8s.io/pr-history?org=kubernetes-sigs&repo=scheduler-plugins&pr=813). [Your PR dashboard](https://prow.k8s.io/pr?query=is%3Apr%20state%3Aopen%20author%3Agoogs1025). Please help us cut down on flakes by [linking to](https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md#filing-issues-for-flaky-tests) an [open issue](https://github.com/kubernetes-sigs/scheduler-plugins/issues?q=is:issue+is:open) when you hit one in your PR.

<details>

Instructions for interacting with me using PR comments are available [here](https://git.k8s.io/community/contributors/guide/pull-requests.md).  If you have questions or suggestions related to my behavior, please file an issue against the [kubernetes-sigs/prow](https://github.com/kubernetes-sigs/prow/issues/new?title=Prow%20issue:) repository. I understand the commands that are listed [here](https://go.k8s.io/bot-commands).
</details>
<!-- test report -->
googs1025: /kind feature

Patch:
diff --git a/go.mod b/go.mod
index 2a8bfb2d..511b624b 100644
--- a/go.mod
+++ b/go.mod
@@ -16,17 +16,17 @@ require (
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.8.4
 	gonum.org/v1/gonum v0.12.0
-	k8s.io/api v0.30.6
-	k8s.io/apimachinery v0.30.6
-	k8s.io/apiserver v0.30.6
-	k8s.io/client-go v0.30.6
-	k8s.io/code-generator v0.30.6
-	k8s.io/component-base v0.30.6
-	k8s.io/component-helpers v0.30.6
+	k8s.io/api v0.30.4
+	k8s.io/apimachinery v0.30.4
+	k8s.io/apiserver v0.30.4
+	k8s.io/client-go v0.30.4
+	k8s.io/code-generator v0.30.4
+	k8s.io/component-base v0.30.4
+	k8s.io/component-helpers v0.30.4
 	k8s.io/klog/hack/tools v0.0.0-20210917071902-331d2323a192
 	k8s.io/klog/v2 v2.120.1
-	k8s.io/kube-scheduler v0.30.6
-	k8s.io/kubernetes v1.30.6
+	k8s.io/kube-scheduler v0.30.4
+	k8s.io/kubernetes v1.30.4
 	k8s.io/utils v0.0.0-20230726121419-3b25d923346b
 	sigs.k8s.io/controller-runtime v0.18.5
 	sigs.k8s.io/security-profiles-operator v0.4.0
@@ -130,17 +130,17 @@ require (
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	k8s.io/apiextensions-apiserver v0.30.6 // indirect
-	k8s.io/cloud-provider v0.30.6 // indirect
-	k8s.io/controller-manager v0.30.6 // indirect
-	k8s.io/csi-translation-lib v0.30.6 // indirect
-	k8s.io/dynamic-resource-allocation v0.30.6 // indirect
+	k8s.io/apiextensions-apiserver v0.30.4 // indirect
+	k8s.io/cloud-provider v0.30.4 // indirect
+	k8s.io/controller-manager v0.30.4 // indirect
+	k8s.io/csi-translation-lib v0.30.4 // indirect
+	k8s.io/dynamic-resource-allocation v0.30.4 // indirect
 	k8s.io/gengo/v2 v2.0.0-20240228010128-51d4e06bde70 // indirect
-	k8s.io/kms v0.30.6 // indirect
+	k8s.io/kms v0.30.4 // indirect
 	k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 // indirect
-	k8s.io/kubelet v0.30.6 // indirect
-	k8s.io/metrics v0.30.6 // indirect
-	k8s.io/mount-utils v0.30.6 // indirect
+	k8s.io/kubelet v0.30.4 // indirect
+	k8s.io/metrics v0.30.4 // indirect
+	k8s.io/mount-utils v0.30.4 // indirect
 	sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.29.0 // indirect
 	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
 	sigs.k8s.io/release-utils v0.3.0 // indirect
@@ -153,33 +153,33 @@ replace (
 	go.opentelemetry.io/otel/metric => go.opentelemetry.io/otel/metric v1.21.0
 	go.opentelemetry.io/otel/sdk => go.opentelemetry.io/otel/sdk v1.21.0
 	go.opentelemetry.io/otel/trace => go.opentelemetry.io/otel/trace v1.21.0
-	k8s.io/api => k8s.io/api v0.30.6
-	k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.30.6
-	k8s.io/apimachinery => k8s.io/apimachinery v0.30.6
-	k8s.io/apiserver => k8s.io/apiserver v0.30.6
-	k8s.io/cli-runtime => k8s.io/cli-runtime v0.30.6
-	k8s.io/client-go => k8s.io/client-go v0.30.6
-	k8s.io/cloud-provider => k8s.io/cloud-provider v0.30.6
-	k8s.io/cluster-bootstrap => k8s.io/cluster-bootstrap v0.30.6
-	k8s.io/code-generator => k8s.io/code-generator v0.30.6
-	k8s.io/component-base => k8s.io/component-base v0.30.6
-	k8s.io/component-helpers => k8s.io/component-helpers v0.30.6
-	k8s.io/controller-manager => k8s.io/controller-manager v0.30.6
-	k8s.io/cri-api => k8s.io/cri-api v0.30.6
-	k8s.io/csi-translation-lib => k8s.io/csi-translation-lib v0.30.6
-	k8s.io/dynamic-resource-allocation => k8s.io/dynamic-resource-allocation v0.30.6
-	k8s.io/endpointslice => k8s.io/endpointslice v0.30.6
-	k8s.io/kms => k8s.io/kms v0.30.6
-	k8s.io/kube-aggregator => k8s.io/kube-aggregator v0.30.6
-	k8s.io/kube-controller-manager => k8s.io/kube-controller-manager v0.30.6
-	k8s.io/kube-proxy => k8s.io/kube-proxy v0.30.6
-	k8s.io/kube-scheduler => k8s.io/kube-scheduler v0.30.6
-	k8s.io/kubectl => k8s.io/kubectl v0.30.6
-	k8s.io/kubelet => k8s.io/kubelet v0.30.6
-	k8s.io/kubernetes => k8s.io/kubernetes v1.30.6
-	k8s.io/legacy-cloud-providers => k8s.io/legacy-cloud-providers v0.30.6
-	k8s.io/metrics => k8s.io/metrics v0.30.6
-	k8s.io/mount-utils => k8s.io/mount-utils v0.30.6
-	k8s.io/pod-security-admission => k8s.io/pod-security-admission v0.30.6
-	k8s.io/sample-apiserver => k8s.io/sample-apiserver v0.30.6
+	k8s.io/api => k8s.io/api v0.30.4
+	k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.30.4
+	k8s.io/apimachinery => k8s.io/apimachinery v0.30.4
+	k8s.io/apiserver => k8s.io/apiserver v0.30.4
+	k8s.io/cli-runtime => k8s.io/cli-runtime v0.30.4
+	k8s.io/client-go => k8s.io/client-go v0.30.4
+	k8s.io/cloud-provider => k8s.io/cloud-provider v0.30.4
+	k8s.io/cluster-bootstrap => k8s.io/cluster-bootstrap v0.30.4
+	k8s.io/code-generator => k8s.io/code-generator v0.30.4
+	k8s.io/component-base => k8s.io/component-base v0.30.4
+	k8s.io/component-helpers => k8s.io/component-helpers v0.30.4
+	k8s.io/controller-manager => k8s.io/controller-manager v0.30.4
+	k8s.io/cri-api => k8s.io/cri-api v0.30.4
+	k8s.io/csi-translation-lib => k8s.io/csi-translation-lib v0.30.4
+	k8s.io/dynamic-resource-allocation => k8s.io/dynamic-resource-allocation v0.30.4
+	k8s.io/endpointslice => k8s.io/endpointslice v0.30.4
+	k8s.io/kms => k8s.io/kms v0.30.4
+	k8s.io/kube-aggregator => k8s.io/kube-aggregator v0.30.4
+	k8s.io/kube-controller-manager => k8s.io/kube-controller-manager v0.30.4
+	k8s.io/kube-proxy => k8s.io/kube-proxy v0.30.4
+	k8s.io/kube-scheduler => k8s.io/kube-scheduler v0.30.4
+	k8s.io/kubectl => k8s.io/kubectl v0.30.4
+	k8s.io/kubelet => k8s.io/kubelet v0.30.4
+	k8s.io/kubernetes => k8s.io/kubernetes v1.30.4
+	k8s.io/legacy-cloud-providers => k8s.io/legacy-cloud-providers v0.30.4
+	k8s.io/metrics => k8s.io/metrics v0.30.4
+	k8s.io/mount-utils => k8s.io/mount-utils v0.30.4
+	k8s.io/pod-security-admission => k8s.io/pod-security-admission v0.30.4
+	k8s.io/sample-apiserver => k8s.io/sample-apiserver v0.30.4
 )
diff --git a/go.sum b/go.sum
index 22482516..64980b17 100644
--- a/go.sum
+++ b/go.sum
@@ -1022,8 +1022,9 @@ github.com/containers/ocicrypt v1.1.1/go.mod h1:Dm55fwWm1YZAjYRaJ94z2mfZikIyIN4B
 github.com/containers/ocicrypt v1.1.2/go.mod h1:Dm55fwWm1YZAjYRaJ94z2mfZikIyIN4B0oB3dj3jFxY=
 github.com/containers/storage v1.35.0/go.mod h1:qzYhasQP2/V9D9XdO+vRwkHBhsBO0oznMLzzRDQ8s20=
 github.com/containers/storage v1.36.0/go.mod h1:vbd3SKVQNHdmU5qQI6hTEcKPxnZkGqydG4f6uwrI5a8=
+github.com/coredns/caddy v1.1.0/go.mod h1:A6ntJQlAWuQfFlsd9hvigKbo2WS0VUs2l1e2F+BawD4=
 github.com/coredns/caddy v1.1.1/go.mod h1:A6ntJQlAWuQfFlsd9hvigKbo2WS0VUs2l1e2F+BawD4=
-github.com/coredns/corefile-migration v1.0.24/go.mod h1:56DPqONc3njpVPsdilEnfijCwNGC3/kTJLl7i7SPavY=
+github.com/coredns/corefile-migration v1.0.21/go.mod h1:XnhgULOEouimnzgn0t4WPuFDN2/PJQcTxdWKC5eXNGE=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
@@ -3038,34 +3039,34 @@ honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt
 honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las=
-k8s.io/api v0.30.6 h1:uqRDLnFkmPLorI9D0x1dGXdYeRQMhQHlrHDgZ3/45RE=
-k8s.io/api v0.30.6/go.mod h1:6x759Hj7155pXRKStxzM7TMN9hW0x7WrBr51kuDMSHo=
-k8s.io/apiextensions-apiserver v0.30.6 h1:eXmd0cki9xjpUguN7zaWI8I6wo1utHQj6RWqeBaVmew=
-k8s.io/apiextensions-apiserver v0.30.6/go.mod h1:va7pN44YJJDHrShKhPSL9S5CyTJ8idAmqIARt5wY4j8=
-k8s.io/apimachinery v0.30.6 h1:dlplzGrUL/DiPOVVVjDcT9ZoQBOwYeB6hcFy90veggs=
-k8s.io/apimachinery v0.30.6/go.mod h1:iexa2somDaxdnj7bha06bhb43Zpa6eWH8N8dbqVjTUc=
-k8s.io/apiserver v0.30.6 h1:kMkE/pln4hJpc1OJGa/u8CzpLtr4URbmgkdfw37lzMA=
-k8s.io/apiserver v0.30.6/go.mod h1:kloaQDI0pBfhnHM0vfsgzOkWpTW7Z69rjPWEsMlIUzg=
-k8s.io/cli-runtime v0.30.6/go.mod h1:aWY1dJ9IB5pysp4tU2x70zpHlckMbCMVcHYopjVPSWw=
-k8s.io/client-go v0.30.6 h1:hMo7AUkHy/UqnwPMH+oJvFR9gpvXVfQnsiO+G2fdE30=
-k8s.io/client-go v0.30.6/go.mod h1:DDN89/30A1DfatO+c3ksYMM12kL7a/CZvsBaVjwh33g=
-k8s.io/cloud-provider v0.30.6 h1:6MOnKBXwMihQldcPqxutAzT/0mnIQ7UaDwIeZbjVG+4=
-k8s.io/cloud-provider v0.30.6/go.mod h1:biTWwTVHB0Ktx3UbT3bISKNzIhUqkCLbXSpZIMEdmUw=
-k8s.io/cluster-bootstrap v0.30.6/go.mod h1:Qev/E/JthxXKeXfZ+ZCSx0e4zy+n6nWHS4NiEomTzRA=
-k8s.io/code-generator v0.30.6 h1:P0pDCNLfT5lxrY6kZ07WtdIHc7a5cZCiJYz1B3MRbu8=
-k8s.io/code-generator v0.30.6/go.mod h1:Sg5PSxoHkTD7iFp+gM4d1XvCFCvrMkEa9uoHnCbyfwE=
-k8s.io/component-base v0.30.6 h1:t94cw6cQ7bplaS3Y5C/txkUXpaxG+wbgspTmudGUpNs=
-k8s.io/component-base v0.30.6/go.mod h1:GAemfIPE9Zc3bxOmeLPpHKKHzfuMlmTwsAjx/bWaJvQ=
-k8s.io/component-helpers v0.30.6 h1:l+DJ3hGcAWELcuEJwwdhqcphpJL8Huo+L6NDq537rgM=
-k8s.io/component-helpers v0.30.6/go.mod h1:HqICFUjRQYqdfl+Ttqrhumw1NmG9jEfINJ/nxEj9hOY=
-k8s.io/controller-manager v0.30.6 h1:ryqNMyX7O0l/G1G+hfJoGbuc8Wm5fDUDBCZgjyd8SR8=
-k8s.io/controller-manager v0.30.6/go.mod h1:FOkXQsnChtGb0Xj0a3Xj0v3BTMDBULKlkm8+MqRhGbY=
-k8s.io/cri-api v0.30.6/go.mod h1://4/umPJSW1ISNSNng4OwjpkvswJOQwU8rnkvO8P+xg=
-k8s.io/csi-translation-lib v0.30.6 h1:L9mVQcl1HZcn+iS/oQyiJXl1+v2nIHmy6VKJ1xg1vxw=
-k8s.io/csi-translation-lib v0.30.6/go.mod h1:mkz+kSR033tlpMirz6QK8nT9+G5phWt8NJw5Oq5A+LE=
-k8s.io/dynamic-resource-allocation v0.30.6 h1:WHSFQwKQ9zZ4pqVKSt/svqVh5c87lm+7m+DznoS0IT8=
-k8s.io/dynamic-resource-allocation v0.30.6/go.mod h1:Tx7NiG4EGqaLf7q8mFGyhJr1O0HGJotdefFC8ws9QJI=
-k8s.io/endpointslice v0.30.6/go.mod h1:53m0BjQXaGtV6xFPU4OV25dxOkJwpu5AMi/kJU8f1Is=
+k8s.io/api v0.30.4 h1:XASIELmW8w8q0i1Y4124LqPoWMycLjyQti/fdYHYjCs=
+k8s.io/api v0.30.4/go.mod h1:ZqniWRKu7WIeLijbbzetF4U9qZ03cg5IRwl8YVs8mX0=
+k8s.io/apiextensions-apiserver v0.30.4 h1:FwOMIk/rzZvM/Gx0IOz0+biZ+dlnlCeyfXW17uzV1qE=
+k8s.io/apiextensions-apiserver v0.30.4/go.mod h1:m8cAkJ9PVU8Olb4cPW4hrUDBZGvoSJ0kY0G0CfdGQac=
+k8s.io/apimachinery v0.30.4 h1:5QHQI2tInzr8LsT4kU/2+fSeibH1eIHswNx480cqIoY=
+k8s.io/apimachinery v0.30.4/go.mod h1:iexa2somDaxdnj7bha06bhb43Zpa6eWH8N8dbqVjTUc=
+k8s.io/apiserver v0.30.4 h1:rHkGJhxd+m4jILrgkenwSmG4X0QXk6ecGuybzS/PQak=
+k8s.io/apiserver v0.30.4/go.mod h1:oyGAj9B9/0+I9huJyf4/8SMBF2mNh2bTMlu7703dkH8=
+k8s.io/cli-runtime v0.30.4/go.mod h1:O9Rf0F9x0zeMCcBQEIQxzd4zvxoqfhZZgDAet4hhBPs=
+k8s.io/client-go v0.30.4 h1:eculUe+HPQoPbixfwmaSZGsKcOf7D288tH6hDAdd+wY=
+k8s.io/client-go v0.30.4/go.mod h1:IBS0R/Mt0LHkNHF4E6n+SUDPG7+m2po6RZU7YHeOpzc=
+k8s.io/cloud-provider v0.30.4 h1:j5T/KePmxux289heU+aG+Aq3RmaGfzARAglWUkxTErE=
+k8s.io/cloud-provider v0.30.4/go.mod h1:OfI8YUt8pCU8xvkN1dQ1pvJpQwNZlEszIY186v68H7A=
+k8s.io/cluster-bootstrap v0.30.4/go.mod h1:Jh3Gp1uh/KC7YcCDkugs01Ld0dQJzWhzWs/GQ3q8Lk0=
+k8s.io/code-generator v0.30.4 h1:1J2AcpPNBGh/NH9+m4TDh8Yj+mSbM+JyQhH0QdIMwmE=
+k8s.io/code-generator v0.30.4/go.mod h1:Dd8gxOr5ieh9yHCLKnIkKDmk1H2glH8nYCAqwFogD2M=
+k8s.io/component-base v0.30.4 h1:FlgKqazIkIIxpLA4wFXsiPiDllJn9fhsN3G4TeX7T7U=
+k8s.io/component-base v0.30.4/go.mod h1:Qd3h+OJxV/LrnriXG/E15ZK83dzd306qJHW9+87S5ls=
+k8s.io/component-helpers v0.30.4 h1:A4KYmrz12HZtGZ8TAnanl0SUx7n6tKduxzB3NHvinr0=
+k8s.io/component-helpers v0.30.4/go.mod h1:h5D4gI8hGQXMHw90qJq41PRUJrn2dvFA3ElZFUTzRps=
+k8s.io/controller-manager v0.30.4 h1:PdAGa5srv9fTECbBtWeaLshNpy//hGHHpXjRkh1wOkQ=
+k8s.io/controller-manager v0.30.4/go.mod h1:fTVfW8X0yJh+pUuybc45WxyoLQEhJqJjSff6/2b+l3I=
+k8s.io/cri-api v0.30.4/go.mod h1://4/umPJSW1ISNSNng4OwjpkvswJOQwU8rnkvO8P+xg=
+k8s.io/csi-translation-lib v0.30.4 h1:CxcU8ovSYo267gsDDKdnSO/seSnH3J6dj/HWGcR/OyQ=
+k8s.io/csi-translation-lib v0.30.4/go.mod h1:zOyhRMqMOTeWl7NXLMnAfBmgAooFUL51vL9GiyaZXVo=
+k8s.io/dynamic-resource-allocation v0.30.4 h1:ixvGblhL97SCHQ3n3jRgyGmo0GQEDR1QKVZoNmzT7k0=
+k8s.io/dynamic-resource-allocation v0.30.4/go.mod h1:00Gc/KBbg713RGf2ueWtssdwvgtL6egOCo6c+ixvNww=
+k8s.io/endpointslice v0.30.4/go.mod h1:9iRogOOxizgQboz9LBIaCu74qB/q0tNnJeC440ceZUI=
 k8s.io/gengo v0.0.0-20210813121822-485abfe95c7c/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E=
 k8s.io/gengo/v2 v2.0.0-20240228010128-51d4e06bde70 h1:NGrVE502P0s0/1hudf8zjgwki1X/TByhmAoILTarmzo=
 k8s.io/gengo/v2 v2.0.0-20240228010128-51d4e06bde70/go.mod h1:VH3AT8AaQOqiGjMF9p0/IM1Dj+82ZwjfxUP1IxaHE+8=
@@ -3081,29 +3082,29 @@ k8s.io/klog/v2 v2.80.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
 k8s.io/klog/v2 v2.100.1/go.mod h1:y1WjHnz7Dj687irZUWR/WLkLc5N1YHtjLdmgWjndZn0=
 k8s.io/klog/v2 v2.120.1 h1:QXU6cPEOIslTGvZaXvFWiP9VKyeet3sawzTOvdXb4Vw=
 k8s.io/klog/v2 v2.120.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE=
-k8s.io/kms v0.30.6 h1:54j1mvj/DnCTkZOIdxFk9MHKoTcsnZ45CBnhRimpGGE=
-k8s.io/kms v0.30.6/go.mod h1:GrMurD0qk3G4yNgGcsCEmepqf9KyyIrTXYR2lyUOJC4=
-k8s.io/kube-aggregator v0.30.6/go.mod h1:XengKxlgTCWd6B+bJc2m2KnbxZCOEjk2O9wdMTmAfUc=
-k8s.io/kube-controller-manager v0.30.6/go.mod h1:yEwucgtPJQsERvv3NNg7kYWhEVQ1KMmoxGYZcAxosP0=
+k8s.io/kms v0.30.4 h1:Je7wR5/m+w/E7Ef9R9RY1yeMU/C2GXIvhzRFfg8H5kQ=
+k8s.io/kms v0.30.4/go.mod h1:GrMurD0qk3G4yNgGcsCEmepqf9KyyIrTXYR2lyUOJC4=
+k8s.io/kube-aggregator v0.30.4/go.mod h1:w/ZLttTfMdPmEzV9k/9O2ENKI77ENpwIzeljQ5fj+qc=
+k8s.io/kube-controller-manager v0.30.4/go.mod h1:8RRCcoUZP1FDzZwjSs7kQS1X0u8OHcDWfVO28fEeQzo=
 k8s.io/kube-openapi v0.0.0-20230109183929-3758b55a6596/go.mod h1:/BYxry62FuDzmI+i9B+X2pqfySRmSOW2ARmj5Zbqhj0=
 k8s.io/kube-openapi v0.0.0-20230531092745-9b4dcd38a4bf/go.mod h1:l8HTwL5fqnlns4jOveW1L75eo7R9KFHxiE0bsPGy428=
 k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 h1:BZqlfIlq5YbRMFko6/PM7FjZpUb45WallggurYhKGag=
 k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340/go.mod h1:yD4MZYeKMBwQKVht279WycxKyM84kkAx2DPrTXaeb98=
-k8s.io/kube-proxy v0.30.6/go.mod h1:zi0eHOeq+iDg8etr9CvxzdQcrgCOFSqRmtnn64UcME0=
-k8s.io/kube-scheduler v0.30.6 h1:v+AmcRqdMnWpcLTg7M0juLZsxmJuagG8ZHPlK6j50cM=
-k8s.io/kube-scheduler v0.30.6/go.mod h1:YBAH4f4yjDW/+/QpK5Vq6dOHnDAtk2BzDyK1XxT9nDw=
-k8s.io/kubectl v0.30.6/go.mod h1:MHos6OafyfyoFaoSawxQh1uPVc3xXs+v98FGF8Mz0/0=
-k8s.io/kubelet v0.30.6 h1:jae6hlfOeSA8YCgaPAJRqrWdmGUAtRmbMuatey5e/NA=
-k8s.io/kubelet v0.30.6/go.mod h1:blswm8XUMWUXmS3hduLjButEksPbla9mkGXrjTWyX9U=
-k8s.io/kubernetes v1.30.6 h1:cB/R87sSwwEDbWmzaldb29JYwaorqe+mMdsp68RZyaQ=
-k8s.io/kubernetes v1.30.6/go.mod h1:hV3c+sqOEO0eVqgSo0KW5dOJ6UjGJ2l3Pd9+Qvft8UI=
-k8s.io/legacy-cloud-providers v0.30.6/go.mod h1:0wNZYgN+FydNVqDIHCca6VScwKA7KHapcgmx/1u07qY=
-k8s.io/metrics v0.30.6 h1:oRMnf1X547Zo3gjJNCP0F9Xb+FxAH/KAvZLOeOCKdrw=
-k8s.io/metrics v0.30.6/go.mod h1:lYRgo9LbZfw3Uk6bB2Vulk1e9Jqq4uXoQAhaxs8UUaU=
-k8s.io/mount-utils v0.30.6 h1:vq6MvNgYmFsXVeiBbeZEQa5O3CEh6thkYzxPB5Ub6K0=
-k8s.io/mount-utils v0.30.6/go.mod h1:9sCVmwGLcV1MPvbZ+rToMDnl1QcGozy+jBPd0MsQLIo=
-k8s.io/pod-security-admission v0.30.6/go.mod h1:fvisNyrKEtmEka21IXL8jILyVUMS9gI+U5lu3CGDkxE=
-k8s.io/sample-apiserver v0.30.6/go.mod h1:Uxkem/Cb36XyxaIaqpRlHsLZl1UVV8e7fXDuI0KU9TI=
+k8s.io/kube-proxy v0.30.4/go.mod h1:WfeZOgj8FAoVW2V5FoTyZsCDHhl0aF0YRgfp4GHtCpc=
+k8s.io/kube-scheduler v0.30.4 h1:6H+NfNuJ4RvUdSD1dtnJBXuYGAp+ETGZaxFk4sLGPdU=
+k8s.io/kube-scheduler v0.30.4/go.mod h1:7MMICziKySYQQ7rOFGBsSkn1PE3urPwsxlp6uwU+NhU=
+k8s.io/kubectl v0.30.4/go.mod h1:4KnGCshO4fFxd/tncWcbKH3Nj9wtoFYwMYPj8CUnduE=
+k8s.io/kubelet v0.30.4 h1:2TP59RVxuWuKpD58gQ6qow1Oy2Ys2uOH4hfSD/qv5EQ=
+k8s.io/kubelet v0.30.4/go.mod h1:v0lRl+1y2NNId5OlFiJ1rhjXc9D8Tp7PqvQYJS7W/L0=
+k8s.io/kubernetes v1.30.4 h1:LfWX7JNmT9Hp8uFVHsB9gQCZesjcWTQ02PHwMz6dGqk=
+k8s.io/kubernetes v1.30.4/go.mod h1:yPbIk3MhmhGigX62FLJm+CphNtjxqCvAIFQXup6RKS0=
+k8s.io/legacy-cloud-providers v0.30.4/go.mod h1:Wbpfm7Ul3SxIs0B1U30OMtb4Vy6ZicrOg3hgTo/tEis=
+k8s.io/metrics v0.30.4 h1:CI7Df+c2G65X9B/e6BxK8c1MqmjXRj3Fdd6VEN4N7YQ=
+k8s.io/metrics v0.30.4/go.mod h1:3zPvjwIFSjjwdWIUwEaTO+/ugUpzFCV+l3jISZ+/x3A=
+k8s.io/mount-utils v0.30.4 h1:48vAsFQNwSpFJ8a3+G1PoxEn5OmzS+5AajZjQwLY8t4=
+k8s.io/mount-utils v0.30.4/go.mod h1:9sCVmwGLcV1MPvbZ+rToMDnl1QcGozy+jBPd0MsQLIo=
+k8s.io/pod-security-admission v0.30.4/go.mod h1:FL0x1BxYxKWoEZMqAw+HI0gj1TiCiJqQD9J/9rONkDI=
+k8s.io/sample-apiserver v0.30.4/go.mod h1:Q9n3oQqbN7X/Xnhaa2qBKoMu8ZU+nt5tJjBNIIY7xjU=
 k8s.io/system-validators v1.8.0/go.mod h1:gP1Ky+R9wtrSiFbrpEPwWMeYz9yqyy1S/KOh0Vci7WI=
 k8s.io/utils v0.0.0-20190801114015-581e00157fb1/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
 k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
diff --git a/manifests/install/charts/as-a-second-scheduler/README.md b/manifests/install/charts/as-a-second-scheduler/README.md
index e0e7995e..78c23068 100644
--- a/manifests/install/charts/as-a-second-scheduler/README.md
+++ b/manifests/install/charts/as-a-second-scheduler/README.md
@@ -45,20 +45,17 @@ scheduler-plugins-scheduler    1/1     1            1           7s
 The following table lists the configurable parameters of the as-a-second-scheduler chart and their default values.
 
 | Parameter                 | Description                 | Default                                                                                         |
-| ------------------------- | --------------------------- | ----------------------------------------------------------------------------------------------- |
+|---------------------------|-----------------------------|-------------------------------------------------------------------------------------------------|
 | `scheduler.name`          | Scheduler name              | `scheduler-plugins-scheduler`                                                                   |
 | `scheduler.image`         | Scheduler image             | `registry.k8s.io/scheduler-plugins/kube-scheduler:v0.29.7`                                      |
-| `scheduler.command`       | Scheduler command           | `["/bin/kube-scheduler"]`                                                                       |
 | `scheduler.leaderElect`   | Scheduler leaderElection    | `false`                                                                                         |
 | `scheduler.replicaCount`  | Scheduler replicaCount      | `1`                                                                                             |
-| `scheduler.resources`     | Scheduler resources         | `{}`                                                                                            |
 | `scheduler.nodeSelector`  | Scheduler nodeSelector      | `{}`                                                                                            |
 | `scheduler.affinity`      | Scheduler affinity          | `{}`                                                                                            |
 | `scheduler.tolerations`   | Scheduler tolerations       | `[]`                                                                                            |
 | `controller.name`         | Controller name             | `scheduler-plugins-controller`                                                                  |
 | `controller.image`        | Controller image            | `registry.k8s.io/scheduler-plugins/controller:v0.29.7`                                          |
 | `controller.replicaCount` | Controller replicaCount     | `1`                                                                                             |
-| `controller.resources`    | Controller resources        | `{}`                                                                                            |
 | `controller.nodeSelector` | Controller nodeSelector     | `{}`                                                                                            |
 | `controller.affinity`     | Controller affinity         | `{}`                                                                                            |
 | `controller.tolerations`  | Controller tolerations      | `[]`                                                                                            |
diff --git a/manifests/install/charts/as-a-second-scheduler/templates/configmap.yaml b/manifests/install/charts/as-a-second-scheduler/templates/configmap.yaml
index 3a053ea5..7bb8ee42 100644
--- a/manifests/install/charts/as-a-second-scheduler/templates/configmap.yaml
+++ b/manifests/install/charts/as-a-second-scheduler/templates/configmap.yaml
@@ -10,8 +10,6 @@ data:
     kind: KubeSchedulerConfiguration
     leaderElection:
       leaderElect: {{ .Values.scheduler.leaderElect }}
-      resourceNamespace: {{ .Release.Namespace }}
-      resourceName: {{ .Values.scheduler.name }}
     profiles:
     # Compose all plugins in one profile
     - schedulerName: {{ .Values.scheduler.name }}
diff --git a/manifests/install/charts/as-a-second-scheduler/templates/deployment.yaml b/manifests/install/charts/as-a-second-scheduler/templates/deployment.yaml
index 3abc7a28..9d0b3730 100644
--- a/manifests/install/charts/as-a-second-scheduler/templates/deployment.yaml
+++ b/manifests/install/charts/as-a-second-scheduler/templates/deployment.yaml
@@ -20,17 +20,14 @@ spec:
       - name: scheduler-plugins-controller
         image: {{ .Values.controller.image }}
         imagePullPolicy: IfNotPresent
-        {{- with .Values.controller.resources }}
-        resources: {{- toYaml . | nindent 10 }}
-        {{- end }}
       {{- with .Values.controller.nodeSelector }}
-      nodeSelector: {{- toYaml . | nindent 8 }}
+      nodeSelector: {{- toYaml . | nindent 8}}
       {{- end }}
       {{- with .Values.controller.affinity }}
-      affinity: {{- toYaml . | nindent 8 }}
+      affinity: {{- toYaml . | nindent 8}}
       {{- end }}
       {{- with .Values.controller.tolerations }}
-      tolerations: {{- toYaml . | nindent 8 }}
+      tolerations: {{- toYaml . | nindent 8}}
       {{- end }}
 
 ---
@@ -53,8 +50,7 @@ spec:
     spec:
       serviceAccountName: {{ .Values.scheduler.name }}
       containers:
-      - command: {{- toYaml .Values.scheduler.command | nindent 8 }}
-        args:
+      - args:
         - --config=/etc/kubernetes/scheduler-config.yaml
         image: {{ .Values.scheduler.image }}
         imagePullPolicy: IfNotPresent
@@ -70,9 +66,9 @@ spec:
             path: /healthz
             port: 10259
             scheme: HTTPS
-        {{- with .Values.scheduler.resources }}
-        resources: {{- toYaml . | nindent 10 }}
-        {{- end }}
+        resources:
+          requests:
+            cpu: '0.1'
         securityContext:
           privileged: false
         volumeMounts:
@@ -86,11 +82,12 @@ spec:
         configMap:
           name: scheduler-config
       {{- with .Values.scheduler.nodeSelector }}
-      nodeSelector: {{- toYaml . | nindent 8 }}
+      nodeSelector: {{- toYaml . | nindent 8}}
       {{- end }}
       {{- with .Values.scheduler.affinity }}
-      affinity: {{- toYaml . | nindent 8 }}
+      affinity: {{- toYaml . | nindent 8}}
       {{- end }}
       {{- with .Values.scheduler.tolerations }}
-      tolerations: {{- toYaml . | nindent 8 }}
+      tolerations: {{- toYaml . | nindent 8}}
       {{- end }}
+      
diff --git a/manifests/install/charts/as-a-second-scheduler/templates/rbac.yaml b/manifests/install/charts/as-a-second-scheduler/templates/rbac.yaml
index 8645b318..172144ba 100644
--- a/manifests/install/charts/as-a-second-scheduler/templates/rbac.yaml
+++ b/manifests/install/charts/as-a-second-scheduler/templates/rbac.yaml
@@ -13,14 +13,14 @@ rules:
   resources: ["leases"]
   verbs: ["create"]
 - apiGroups: ["coordination.k8s.io"]
-  resourceNames: ["{{ .Values.scheduler.name }}"]
+  resourceNames: ["kube-scheduler"]
   resources: ["leases"]
   verbs: ["get", "update"]
 - apiGroups: [""]
   resources: ["endpoints"]
   verbs: ["create"]
 - apiGroups: [""]
-  resourceNames: ["{{ .Values.scheduler.name }}"]
+  resourceNames: ["kube-scheduler"]
   resources: ["endpoints"]
   verbs: ["get", "update"]
 - apiGroups: [""]
diff --git a/manifests/install/charts/as-a-second-scheduler/values.yaml b/manifests/install/charts/as-a-second-scheduler/values.yaml
index 25578dee..5d59314f 100644
--- a/manifests/install/charts/as-a-second-scheduler/values.yaml
+++ b/manifests/install/charts/as-a-second-scheduler/values.yaml
@@ -5,11 +5,8 @@
 scheduler:
   name: scheduler-plugins-scheduler
   image: registry.k8s.io/scheduler-plugins/kube-scheduler:v0.29.7
-  command:
-  - /bin/kube-scheduler
   replicaCount: 1
   leaderElect: false
-  resources: {}
   nodeSelector: {}
   affinity: {}
   tolerations: []
@@ -18,7 +15,6 @@ controller:
   name: scheduler-plugins-controller
   image: registry.k8s.io/scheduler-plugins/controller:v0.29.7
   replicaCount: 1
-  resources: {}
   nodeSelector: {}
   affinity: {}
   tolerations: []
diff --git a/pkg/capacityscheduling/capacity_scheduling.go b/pkg/capacityscheduling/capacity_scheduling.go
index b9caa850..f9b8fb34 100644
--- a/pkg/capacityscheduling/capacity_scheduling.go
+++ b/pkg/capacityscheduling/capacity_scheduling.go
@@ -125,6 +125,7 @@ func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (fram
 		podLister:         handle.SharedInformerFactory().Core().V1().Pods().Lister(),
 		pdbLister:         getPDBLister(handle.SharedInformerFactory()),
 	}
+	logger := klog.FromContext(ctx)
 
 	client, err := client.New(handle.KubeConfig(), client.Options{Scheme: scheme})
 	if err != nil {
@@ -187,7 +188,7 @@ func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (fram
 			},
 		},
 	)
-	klog.InfoS("CapacityScheduling start")
+	logger.Info("CapacityScheduling start")
 	return c, nil
 }
 
@@ -288,9 +289,11 @@ func (c *CapacityScheduling) PreFilterExtensions() framework.PreFilterExtensions
 
 // AddPod from pre-computed data in cycleState.
 func (c *CapacityScheduling) AddPod(ctx context.Context, cycleState *framework.CycleState, podToSchedule *v1.Pod, podToAdd *framework.PodInfo, nodeInfo *framework.NodeInfo) *framework.Status {
+	logger := klog.FromContext(ctx)
+
 	elasticQuotaSnapshotState, err := getElasticQuotaSnapshotState(cycleState)
 	if err != nil {
-		klog.ErrorS(err, "Failed to read elasticQuotaSnapshot from cycleState", "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
+		logger.Error(err, "Failed to read elasticQuotaSnapshot from cycleState", "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
 		return framework.NewStatus(framework.Error, err.Error())
 	}
 
@@ -298,7 +301,7 @@ func (c *CapacityScheduling) AddPod(ctx context.Context, cycleState *framework.C
 	if elasticQuotaInfo != nil {
 		err := elasticQuotaInfo.addPodIfNotPresent(podToAdd.Pod)
 		if err != nil {
-			klog.ErrorS(err, "Failed to add Pod to its associated elasticQuota", "pod", klog.KObj(podToAdd.Pod))
+			logger.Error(err, "Failed to add Pod to its associated elasticQuota", "pod", klog.KObj(podToAdd.Pod))
 		}
 	}
 
@@ -307,9 +310,11 @@ func (c *CapacityScheduling) AddPod(ctx context.Context, cycleState *framework.C
 
 // RemovePod from pre-computed data in cycleState.
 func (c *CapacityScheduling) RemovePod(ctx context.Context, cycleState *framework.CycleState, podToSchedule *v1.Pod, podToRemove *framework.PodInfo, nodeInfo *framework.NodeInfo) *framework.Status {
+	logger := klog.FromContext(ctx)
+
 	elasticQuotaSnapshotState, err := getElasticQuotaSnapshotState(cycleState)
 	if err != nil {
-		klog.ErrorS(err, "Failed to read elasticQuotaSnapshot from cycleState", "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
+		logger.Error(err, "Failed to read elasticQuotaSnapshot from cycleState", "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
 		return framework.NewStatus(framework.Error, err.Error())
 	}
 
@@ -317,7 +322,7 @@ func (c *CapacityScheduling) RemovePod(ctx context.Context, cycleState *framewor
 	if elasticQuotaInfo != nil {
 		err = elasticQuotaInfo.deletePodIfPresent(podToRemove.Pod)
 		if err != nil {
-			klog.ErrorS(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(podToRemove.Pod))
+			logger.Error(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(podToRemove.Pod))
 		}
 	}
 
@@ -348,11 +353,13 @@ func (c *CapacityScheduling) Reserve(ctx context.Context, state *framework.Cycle
 	c.Lock()
 	defer c.Unlock()
 
+	logger := klog.FromContext(ctx)
+
 	elasticQuotaInfo := c.elasticQuotaInfos[pod.Namespace]
 	if elasticQuotaInfo != nil {
 		err := elasticQuotaInfo.addPodIfNotPresent(pod)
 		if err != nil {
-			klog.ErrorS(err, "Failed to add Pod to its associated elasticQuota", "pod", klog.KObj(pod))
+			logger.Error(err, "Failed to add Pod to its associated elasticQuota", "pod", klog.KObj(pod))
 			return framework.NewStatus(framework.Error, err.Error())
 		}
 	}
@@ -363,11 +370,13 @@ func (c *CapacityScheduling) Unreserve(ctx context.Context, state *framework.Cyc
 	c.Lock()
 	defer c.Unlock()
 
+	logger := klog.FromContext(ctx)
+
 	elasticQuotaInfo := c.elasticQuotaInfos[pod.Namespace]
 	if elasticQuotaInfo != nil {
 		err := elasticQuotaInfo.deletePodIfPresent(pod)
 		if err != nil {
-			klog.ErrorS(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(pod))
+			logger.Error(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(pod))
 		}
 	}
 }
@@ -400,14 +409,16 @@ func (p *preemptor) CandidatesToVictimsMap(candidates []preemption.Candidate) ma
 // We look at the node that is nominated for this pod and as long as there are
 // terminating pods on the node, we don't consider this for preempting more pods.
 func (p *preemptor) PodEligibleToPreemptOthers(pod *v1.Pod, nominatedNodeStatus *framework.Status) (bool, string) {
+	logger := klog.FromContext(context.TODO())
+
 	if pod.Spec.PreemptionPolicy != nil && *pod.Spec.PreemptionPolicy == v1.PreemptNever {
-		klog.V(5).InfoS("Pod is not eligible for preemption because of its preemptionPolicy", "pod", klog.KObj(pod), "preemptionPolicy", v1.PreemptNever)
+		logger.V(5).Info("Pod is not eligible for preemption because of its preemptionPolicy", "pod", klog.KObj(pod), "preemptionPolicy", v1.PreemptNever)
 		return false, "not eligible due to preemptionPolicy=Never."
 	}
 
 	preFilterState, err := getPreFilterState(p.state)
 	if err != nil {
-		klog.V(5).InfoS("Failed to read preFilterState from cycleState, err: %s", err, "preFilterStateKey", preFilterStateKey)
+		logger.V(5).Info("Failed to read preFilterState from cycleState, err: %s", err, "preFilterStateKey", preFilterStateKey)
 		return false, "not eligible due to failed to read from cycleState"
 	}
 
@@ -422,7 +433,7 @@ func (p *preemptor) PodEligibleToPreemptOthers(pod *v1.Pod, nominatedNodeStatus
 
 		elasticQuotaSnapshotState, err := getElasticQuotaSnapshotState(p.state)
 		if err != nil {
-			klog.ErrorS(err, "Failed to read elasticQuotaSnapshot from cycleState", "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
+			logger.Error(err, "Failed to read elasticQuotaSnapshot from cycleState", "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
 			return true, ""
 		}
 
@@ -480,17 +491,20 @@ func (p *preemptor) SelectVictimsOnNode(
 	pod *v1.Pod,
 	nodeInfo *framework.NodeInfo,
 	pdbs []*policy.PodDisruptionBudget) ([]*v1.Pod, int, *framework.Status) {
+
+	logger := klog.FromContext(ctx)
+
 	elasticQuotaSnapshotState, err := getElasticQuotaSnapshotState(state)
 	if err != nil {
 		msg := "Failed to read elasticQuotaSnapshot from cycleState"
-		klog.ErrorS(err, msg, "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
+		logger.Error(err, msg, "elasticQuotaSnapshotKey", ElasticQuotaSnapshotKey)
 		return nil, 0, framework.NewStatus(framework.Unschedulable, msg)
 	}
 
 	preFilterState, err := getPreFilterState(state)
 	if err != nil {
 		msg := "Failed to read preFilterState from cycleState"
-		klog.ErrorS(err, msg, "preFilterStateKey", preFilterStateKey)
+		logger.Error(err, msg, "preFilterStateKey", preFilterStateKey)
 		return nil, 0, framework.NewStatus(framework.Unschedulable, msg)
 	}
 
@@ -498,7 +512,6 @@ func (p *preemptor) SelectVictimsOnNode(
 	var nominatedPodsReqWithPodReq framework.Resource
 	podReq := preFilterState.podReq
 
-	logger := klog.FromContext(ctx)
 	removePod := func(rpi *framework.PodInfo) error {
 		if err := nodeInfo.RemovePod(logger, rpi.Pod); err != nil {
 			return err
@@ -625,7 +638,7 @@ func (p *preemptor) SelectVictimsOnNode(
 				return false, err
 			}
 			victims = append(victims, pi.Pod)
-			klog.V(5).InfoS("Found a potential preemption victim on node", "pod", klog.KObj(pi.Pod), "node", klog.KObj(nodeInfo.Node()))
+			logger.V(5).Info("Found a potential preemption victim on node", "pod", klog.KObj(pi.Pod), "node", klog.KObj(nodeInfo.Node()))
 		}
 
 		if preemptorWithElasticQuota && (preemptorElasticQuotaInfo.usedOverMaxWith(&nominatedPodsReqInEQWithPodReq) || elasticQuotaInfos.aggregatedUsedOverMinWith(nominatedPodsReqWithPodReq)) {
@@ -633,14 +646,14 @@ func (p *preemptor) SelectVictimsOnNode(
 				return false, err
 			}
 			victims = append(victims, pi.Pod)
-			klog.V(5).InfoS("Found a potential preemption victim on node", "pod", klog.KObj(pi.Pod), " node", klog.KObj(nodeInfo.Node()))
+			logger.V(5).Info("Found a potential preemption victim on node", "pod", klog.KObj(pi.Pod), " node", klog.KObj(nodeInfo.Node()))
 		}
 
 		return fits, nil
 	}
 	for _, pi := range violatingVictims {
 		if fits, err := reprievePod(pi); err != nil {
-			klog.ErrorS(err, "Failed to reprieve pod", "pod", klog.KObj(pi.Pod))
+			logger.Error(err, "Failed to reprieve pod", "pod", klog.KObj(pi.Pod))
 			return nil, 0, framework.AsStatus(err)
 		} else if !fits {
 			numViolatingVictim++
@@ -649,7 +662,7 @@ func (p *preemptor) SelectVictimsOnNode(
 	// Now we try to reprieve non-violating victims.
 	for _, pi := range nonViolatingVictims {
 		if _, err := reprievePod(pi); err != nil {
-			klog.ErrorS(err, "Failed to reprieve pod", "pod", klog.KObj(pi.Pod))
+			logger.Error(err, "Failed to reprieve pod", "pod", klog.KObj(pi.Pod))
 			return nil, 0, framework.AsStatus(err)
 		}
 	}
@@ -694,6 +707,9 @@ func (c *CapacityScheduling) deleteElasticQuota(obj interface{}) {
 }
 
 func (c *CapacityScheduling) addPod(obj interface{}) {
+	ctx := context.TODO()
+	logger := klog.FromContext(ctx)
+
 	pod := obj.(*v1.Pod)
 
 	c.Lock()
@@ -703,8 +719,8 @@ func (c *CapacityScheduling) addPod(obj interface{}) {
 	// If elasticQuotaInfo is nil, try to list ElasticQuotas through elasticQuotaLister
 	if elasticQuotaInfo == nil {
 		var eqList v1alpha1.ElasticQuotaList
-		if err := c.client.List(context.Background(), &eqList, client.InNamespace(pod.Namespace)); err != nil {
-			klog.ErrorS(err, "Failed to get elasticQuota", "elasticQuota", pod.Namespace)
+		if err := c.client.List(ctx, &eqList, client.InNamespace(pod.Namespace)); err != nil {
+			logger.Error(err, "Failed to get elasticQuota", "elasticQuota", pod.Namespace)
 			return
 		}
 
@@ -724,11 +740,13 @@ func (c *CapacityScheduling) addPod(obj interface{}) {
 
 	err := elasticQuotaInfo.addPodIfNotPresent(pod)
 	if err != nil {
-		klog.ErrorS(err, "Failed to add Pod to its associated elasticQuota", "pod", klog.KObj(pod))
+		logger.Error(err, "Failed to add Pod to its associated elasticQuota", "pod", klog.KObj(pod))
 	}
 }
 
 func (c *CapacityScheduling) updatePod(oldObj, newObj interface{}) {
+	logger := klog.FromContext(context.TODO())
+
 	oldPod := oldObj.(*v1.Pod)
 	newPod := newObj.(*v1.Pod)
 
@@ -744,13 +762,15 @@ func (c *CapacityScheduling) updatePod(oldObj, newObj interface{}) {
 		if elasticQuotaInfo != nil {
 			err := elasticQuotaInfo.deletePodIfPresent(newPod)
 			if err != nil {
-				klog.ErrorS(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(newPod))
+				logger.Error(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(newPod))
 			}
 		}
 	}
 }
 
 func (c *CapacityScheduling) deletePod(obj interface{}) {
+	logger := klog.FromContext(context.TODO())
+
 	pod := obj.(*v1.Pod)
 	c.Lock()
 	defer c.Unlock()
@@ -759,7 +779,7 @@ func (c *CapacityScheduling) deletePod(obj interface{}) {
 	if elasticQuotaInfo != nil {
 		err := elasticQuotaInfo.deletePodIfPresent(pod)
 		if err != nil {
-			klog.ErrorS(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(pod))
+			logger.Error(err, "Failed to delete Pod from its associated elasticQuota", "pod", klog.KObj(pod))
 		}
 	}
 }
diff --git a/pkg/coscheduling/core/core.go b/pkg/coscheduling/core/core.go
index daa139c7..17746761 100644
--- a/pkg/coscheduling/core/core.go
+++ b/pkg/coscheduling/core/core.go
@@ -65,10 +65,10 @@ type Manager interface {
 	PreFilter(context.Context, *corev1.Pod) error
 	Permit(context.Context, *framework.CycleState, *corev1.Pod) Status
 	GetPodGroup(context.Context, *corev1.Pod) (string, *v1alpha1.PodGroup)
-	GetCreationTimestamp(*corev1.Pod, time.Time) time.Time
-	DeletePermittedPodGroup(string)
-	CalculateAssignedPods(string, string) int
-	ActivateSiblings(pod *corev1.Pod, state *framework.CycleState)
+	GetCreationTimestamp(context.Context, *corev1.Pod, time.Time) time.Time
+	DeletePermittedPodGroup(context.Context, string)
+	CalculateAssignedPods(context.Context, string, string) int
+	ActivateSiblings(ctx context.Context, pod *corev1.Pod, state *framework.CycleState)
 	BackoffPodGroup(string, time.Duration)
 }
 
@@ -112,7 +112,8 @@ func (pgMgr *PodGroupManager) BackoffPodGroup(pgName string, backoff time.Durati
 
 // ActivateSiblings stashes the pods belonging to the same PodGroup of the given pod
 // in the given state, with a reserved key "kubernetes.io/pods-to-activate".
-func (pgMgr *PodGroupManager) ActivateSiblings(pod *corev1.Pod, state *framework.CycleState) {
+func (pgMgr *PodGroupManager) ActivateSiblings(ctx context.Context, pod *corev1.Pod, state *framework.CycleState) {
+	lh := klog.FromContext(ctx)
 	pgName := util.GetPodGroupLabel(pod)
 	if pgName == "" {
 		return
@@ -129,7 +130,7 @@ func (pgMgr *PodGroupManager) ActivateSiblings(pod *corev1.Pod, state *framework
 		labels.SelectorFromSet(labels.Set{v1alpha1.PodGroupLabel: pgName}),
 	)
 	if err != nil {
-		klog.ErrorS(err, "Failed to obtain pods belong to a PodGroup", "podGroup", pgName)
+		lh.Error(err, "Failed to obtain pods belong to a PodGroup", "podGroup", pgName)
 		return
 	}
 
@@ -159,7 +160,8 @@ func (pgMgr *PodGroupManager) ActivateSiblings(pod *corev1.Pod, state *framework
 // 2. the total number of pods in the podgroup is less than the minimum number of pods
 // that is required to be scheduled.
 func (pgMgr *PodGroupManager) PreFilter(ctx context.Context, pod *corev1.Pod) error {
-	klog.V(5).InfoS("Pre-filter", "pod", klog.KObj(pod))
+	lh := klog.FromContext(ctx)
+	lh.V(5).Info("Pre-filter", "pod", klog.KObj(pod))
 	pgFullName, pg := pgMgr.GetPodGroup(ctx, pod)
 	if pg == nil {
 		return nil
@@ -202,7 +204,7 @@ func (pgMgr *PodGroupManager) PreFilter(ctx context.Context, pod *corev1.Pod) er
 	minResources[corev1.ResourcePods] = *podQuantity
 	err = CheckClusterResource(ctx, nodes, minResources, pgFullName)
 	if err != nil {
-		klog.ErrorS(err, "Failed to PreFilter", "podGroup", klog.KObj(pg))
+		lh.Error(err, "Failed to PreFilter", "podGroup", klog.KObj(pg))
 		return err
 	}
 	pgMgr.permittedPG.Add(pgFullName, pgFullName, *pgMgr.scheduleTimeout)
@@ -220,7 +222,7 @@ func (pgMgr *PodGroupManager) Permit(ctx context.Context, state *framework.Cycle
 		return PodGroupNotFound
 	}
 
-	assigned := pgMgr.CalculateAssignedPods(pg.Name, pg.Namespace)
+	assigned := pgMgr.CalculateAssignedPods(ctx, pg.Name, pg.Namespace)
 	// The number of pods that have been assigned nodes is calculated from the snapshot.
 	// The current pod in not included in the snapshot during the current scheduling cycle.
 	if int32(assigned)+1 >= pg.Spec.MinMember {
@@ -243,20 +245,20 @@ func (pgMgr *PodGroupManager) Permit(ctx context.Context, state *framework.Cycle
 }
 
 // GetCreationTimestamp returns the creation time of a podGroup or a pod.
-func (pgMgr *PodGroupManager) GetCreationTimestamp(pod *corev1.Pod, ts time.Time) time.Time {
+func (pgMgr *PodGroupManager) GetCreationTimestamp(ctx context.Context, pod *corev1.Pod, ts time.Time) time.Time {
 	pgName := util.GetPodGroupLabel(pod)
 	if len(pgName) == 0 {
 		return ts
 	}
 	var pg v1alpha1.PodGroup
-	if err := pgMgr.client.Get(context.TODO(), types.NamespacedName{Namespace: pod.Namespace, Name: pgName}, &pg); err != nil {
+	if err := pgMgr.client.Get(ctx, types.NamespacedName{Namespace: pod.Namespace, Name: pgName}, &pg); err != nil {
 		return ts
 	}
 	return pg.CreationTimestamp.Time
 }
 
 // DeletePermittedPodGroup deletes a podGroup that passes Pre-Filter but reaches PostFilter.
-func (pgMgr *PodGroupManager) DeletePermittedPodGroup(pgFullName string) {
+func (pgMgr *PodGroupManager) DeletePermittedPodGroup(_ context.Context, pgFullName string) {
 	pgMgr.permittedPG.Delete(pgFullName)
 }
 
@@ -274,10 +276,11 @@ func (pgMgr *PodGroupManager) GetPodGroup(ctx context.Context, pod *corev1.Pod)
 }
 
 // CalculateAssignedPods returns the number of pods that has been assigned nodes: assumed or bound.
-func (pgMgr *PodGroupManager) CalculateAssignedPods(podGroupName, namespace string) int {
+func (pgMgr *PodGroupManager) CalculateAssignedPods(ctx context.Context, podGroupName, namespace string) int {
+	lh := klog.FromContext(ctx)
 	nodeInfos, err := pgMgr.snapshotSharedLister.NodeInfos().List()
 	if err != nil {
-		klog.ErrorS(err, "Cannot get nodeInfos from frameworkHandle")
+		lh.Error(err, "Cannot get nodeInfos from frameworkHandle")
 		return 0
 	}
 	var count int
@@ -354,6 +357,6 @@ func getNodeResource(ctx context.Context, info *framework.NodeInfo, desiredPodGr
 			leftResource.ScalarResources[k] = allocatableEx - requestEx
 		}
 	}
-	klog.V(4).InfoS("Node left resource", "node", klog.KObj(info.Node()), "resource", leftResource)
+	logger.V(4).Info("Node left resource", "node", klog.KObj(info.Node()), "resource", leftResource)
 	return &leftResource
 }
diff --git a/pkg/coscheduling/coscheduling.go b/pkg/coscheduling/coscheduling.go
index 55f5f368..69b36175 100644
--- a/pkg/coscheduling/coscheduling.go
+++ b/pkg/coscheduling/coscheduling.go
@@ -60,7 +60,11 @@ const (
 )
 
 // New initializes and returns a new Coscheduling plugin.
-func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+
+	lh := klog.FromContext(ctx)
+	lh.V(5).Info("creating new coscheduling plugin")
+
 	args, ok := obj.(*config.CoschedulingArgs)
 	if !ok {
 		return nil, fmt.Errorf("want args to be of type CoschedulingArgs, got %T", obj)
@@ -93,7 +97,7 @@ func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framew
 	}
 	if args.PodGroupBackoffSeconds < 0 {
 		err := fmt.Errorf("parse arguments failed")
-		klog.ErrorS(err, "PodGroupBackoffSeconds cannot be negative")
+		lh.Error(err, "PodGroupBackoffSeconds cannot be negative")
 		return nil, err
 	} else if args.PodGroupBackoffSeconds > 0 {
 		pgBackoff := time.Duration(args.PodGroupBackoffSeconds) * time.Second
@@ -128,8 +132,8 @@ func (cs *Coscheduling) Less(podInfo1, podInfo2 *framework.QueuedPodInfo) bool {
 	if prio1 != prio2 {
 		return prio1 > prio2
 	}
-	creationTime1 := cs.pgMgr.GetCreationTimestamp(podInfo1.Pod, *podInfo1.InitialAttemptTimestamp)
-	creationTime2 := cs.pgMgr.GetCreationTimestamp(podInfo2.Pod, *podInfo2.InitialAttemptTimestamp)
+	creationTime1 := cs.pgMgr.GetCreationTimestamp(context.TODO(), podInfo1.Pod, *podInfo1.InitialAttemptTimestamp)
+	creationTime2 := cs.pgMgr.GetCreationTimestamp(context.TODO(), podInfo2.Pod, *podInfo2.InitialAttemptTimestamp)
 	if creationTime1.Equal(creationTime2) {
 		return core.GetNamespacedName(podInfo1.Pod) < core.GetNamespacedName(podInfo2.Pod)
 	}
@@ -140,10 +144,11 @@ func (cs *Coscheduling) Less(podInfo1, podInfo2 *framework.QueuedPodInfo) bool {
 // 1. Whether the PodGroup that the Pod belongs to is on the deny list.
 // 2. Whether the total number of pods in a PodGroup is less than its `minMember`.
 func (cs *Coscheduling) PreFilter(ctx context.Context, state *framework.CycleState, pod *v1.Pod) (*framework.PreFilterResult, *framework.Status) {
+	lh := klog.FromContext(ctx)
 	// If PreFilter fails, return framework.UnschedulableAndUnresolvable to avoid
 	// any preemption attempts.
 	if err := cs.pgMgr.PreFilter(ctx, pod); err != nil {
-		klog.ErrorS(err, "PreFilter failed", "pod", klog.KObj(pod))
+		lh.Error(err, "PreFilter failed", "pod", klog.KObj(pod))
 		return nil, framework.NewStatus(framework.UnschedulableAndUnresolvable, err.Error())
 	}
 	return nil, framework.NewStatus(framework.Success, "")
@@ -152,17 +157,18 @@ func (cs *Coscheduling) PreFilter(ctx context.Context, state *framework.CycleSta
 // PostFilter is used to reject a group of pods if a pod does not pass PreFilter or Filter.
 func (cs *Coscheduling) PostFilter(ctx context.Context, state *framework.CycleState, pod *v1.Pod,
 	filteredNodeStatusMap framework.NodeToStatusMap) (*framework.PostFilterResult, *framework.Status) {
+	lh := klog.FromContext(ctx)
 	pgName, pg := cs.pgMgr.GetPodGroup(ctx, pod)
 	if pg == nil {
-		klog.V(4).InfoS("Pod does not belong to any group", "pod", klog.KObj(pod))
+		lh.V(4).Info("Pod does not belong to any group", "pod", klog.KObj(pod))
 		return &framework.PostFilterResult{}, framework.NewStatus(framework.Unschedulable, "can not find pod group")
 	}
 
 	// This indicates there are already enough Pods satisfying the PodGroup,
 	// so don't bother to reject the whole PodGroup.
-	assigned := cs.pgMgr.CalculateAssignedPods(pg.Name, pod.Namespace)
+	assigned := cs.pgMgr.CalculateAssignedPods(ctx, pg.Name, pod.Namespace)
 	if assigned >= int(pg.Spec.MinMember) {
-		klog.V(4).InfoS("Assigned pods", "podGroup", klog.KObj(pg), "assigned", assigned)
+		lh.V(4).Info("Assigned pods", "podGroup", klog.KObj(pg), "assigned", assigned)
 		return &framework.PostFilterResult{}, framework.NewStatus(framework.Unschedulable)
 	}
 
@@ -170,7 +176,7 @@ func (cs *Coscheduling) PostFilter(ctx context.Context, state *framework.CycleSt
 	// to see they can satisfy the PodGroup
 	notAssignedPercentage := float32(int(pg.Spec.MinMember)-assigned) / float32(pg.Spec.MinMember)
 	if notAssignedPercentage <= 0.1 {
-		klog.V(4).InfoS("A small gap of pods to reach the quorum", "podGroup", klog.KObj(pg), "percentage", notAssignedPercentage)
+		lh.V(4).Info("A small gap of pods to reach the quorum", "podGroup", klog.KObj(pg), "percentage", notAssignedPercentage)
 		return &framework.PostFilterResult{}, framework.NewStatus(framework.Unschedulable)
 	}
 
@@ -178,7 +184,7 @@ func (cs *Coscheduling) PostFilter(ctx context.Context, state *framework.CycleSt
 	// it's inferrable other Pods belonging to the same PodGroup would be very likely to fail.
 	cs.frameworkHandler.IterateOverWaitingPods(func(waitingPod framework.WaitingPod) {
 		if waitingPod.GetPod().Namespace == pod.Namespace && util.GetPodGroupLabel(waitingPod.GetPod()) == pg.Name {
-			klog.V(3).InfoS("PostFilter rejects the pod", "podGroup", klog.KObj(pg), "pod", klog.KObj(waitingPod.GetPod()))
+			lh.V(3).Info("PostFilter rejects the pod", "podGroup", klog.KObj(pg), "pod", klog.KObj(waitingPod.GetPod()))
 			waitingPod.Reject(cs.Name(), "optimistic rejection in PostFilter")
 		}
 	})
@@ -192,7 +198,7 @@ func (cs *Coscheduling) PostFilter(ctx context.Context, state *framework.CycleSt
 		}
 	}
 
-	cs.pgMgr.DeletePermittedPodGroup(pgName)
+	cs.pgMgr.DeletePermittedPodGroup(ctx, pgName)
 	return &framework.PostFilterResult{}, framework.NewStatus(framework.Unschedulable,
 		fmt.Sprintf("PodGroup %v gets rejected due to Pod %v is unschedulable even after PostFilter", pgName, pod.Name))
 }
@@ -204,6 +210,7 @@ func (cs *Coscheduling) PreFilterExtensions() framework.PreFilterExtensions {
 
 // Permit is the functions invoked by the framework at "Permit" extension point.
 func (cs *Coscheduling) Permit(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) (*framework.Status, time.Duration) {
+	lh := klog.FromContext(ctx)
 	waitTime := *cs.scheduleTimeout
 	s := cs.pgMgr.Permit(ctx, state, pod)
 	var retStatus *framework.Status
@@ -213,23 +220,23 @@ func (cs *Coscheduling) Permit(ctx context.Context, state *framework.CycleState,
 	case core.PodGroupNotFound:
 		return framework.NewStatus(framework.Unschedulable, "PodGroup not found"), 0
 	case core.Wait:
-		klog.InfoS("Pod is waiting to be scheduled to node", "pod", klog.KObj(pod), "nodeName", nodeName)
+		lh.Info("Pod is waiting to be scheduled to node", "pod", klog.KObj(pod), "nodeName", nodeName)
 		_, pg := cs.pgMgr.GetPodGroup(ctx, pod)
 		if wait := util.GetWaitTimeDuration(pg, cs.scheduleTimeout); wait != 0 {
 			waitTime = wait
 		}
 		retStatus = framework.NewStatus(framework.Wait)
 		// We will also request to move the sibling pods back to activeQ.
-		cs.pgMgr.ActivateSiblings(pod, state)
+		cs.pgMgr.ActivateSiblings(ctx, pod, state)
 	case core.Success:
 		pgFullName := util.GetPodGroupFullName(pod)
 		cs.frameworkHandler.IterateOverWaitingPods(func(waitingPod framework.WaitingPod) {
 			if util.GetPodGroupFullName(waitingPod.GetPod()) == pgFullName {
-				klog.V(3).InfoS("Permit allows", "pod", klog.KObj(waitingPod.GetPod()))
+				lh.V(3).Info("Permit allows", "pod", klog.KObj(waitingPod.GetPod()))
 				waitingPod.Allow(cs.Name())
 			}
 		})
-		klog.V(3).InfoS("Permit allows", "pod", klog.KObj(pod))
+		lh.V(3).Info("Permit allows", "pod", klog.KObj(pod))
 		retStatus = framework.NewStatus(framework.Success)
 		waitTime = 0
 	}
@@ -244,15 +251,16 @@ func (cs *Coscheduling) Reserve(ctx context.Context, state *framework.CycleState
 
 // Unreserve rejects all other Pods in the PodGroup when one of the pods in the group times out.
 func (cs *Coscheduling) Unreserve(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) {
+	lh := klog.FromContext(ctx)
 	pgName, pg := cs.pgMgr.GetPodGroup(ctx, pod)
 	if pg == nil {
 		return
 	}
 	cs.frameworkHandler.IterateOverWaitingPods(func(waitingPod framework.WaitingPod) {
 		if waitingPod.GetPod().Namespace == pod.Namespace && util.GetPodGroupLabel(waitingPod.GetPod()) == pg.Name {
-			klog.V(3).InfoS("Unreserve rejects", "pod", klog.KObj(waitingPod.GetPod()), "podGroup", klog.KObj(pg))
+			lh.V(3).Info("Unreserve rejects", "pod", klog.KObj(waitingPod.GetPod()), "podGroup", klog.KObj(pg))
 			waitingPod.Reject(cs.Name(), "rejection in Unreserve")
 		}
 	})
-	cs.pgMgr.DeletePermittedPodGroup(pgName)
+	cs.pgMgr.DeletePermittedPodGroup(ctx, pgName)
 }
diff --git a/pkg/networkaware/networkoverhead/networkoverhead.go b/pkg/networkaware/networkoverhead/networkoverhead.go
index bc59602f..242e0a62 100644
--- a/pkg/networkaware/networkoverhead/networkoverhead.go
+++ b/pkg/networkaware/networkoverhead/networkoverhead.go
@@ -139,8 +139,9 @@ func (no *NetworkOverhead) ScoreExtensions() framework.ScoreExtensions {
 }
 
 // New : create an instance of a NetworkOverhead plugin
-func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
-	klog.V(4).InfoS("Creating new instance of the NetworkOverhead plugin")
+func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+	logger := klog.FromContext(ctx)
+	logger.V(4).Info("Creating new instance of the NetworkOverhead plugin")
 
 	args, err := getArgs(obj)
 	if err != nil {
@@ -177,6 +178,7 @@ func (no *NetworkOverhead) PreFilter(ctx context.Context, state *framework.Cycle
 	preFilterState := &PreFilterState{
 		scoreEqually: true,
 	}
+	logger := klog.FromContext(ctx)
 
 	// Write initial status
 	state.Write(preFilterStateKey, preFilterState)
@@ -188,10 +190,10 @@ func (no *NetworkOverhead) PreFilter(ctx context.Context, state *framework.Cycle
 	}
 
 	// Get AppGroup CR
-	appGroup := no.findAppGroupNetworkOverhead(agName)
+	appGroup := no.findAppGroupNetworkOverhead(ctx, logger, agName)
 
 	// Get NetworkTopology CR
-	networkTopology := no.findNetworkTopologyNetworkOverhead()
+	networkTopology := no.findNetworkTopologyNetworkOverhead(ctx, logger)
 
 	// Sort Costs if manual weights were selected
 	no.sortNetworkTopologyCosts(networkTopology)
@@ -220,7 +222,7 @@ func (no *NetworkOverhead) PreFilter(ctx context.Context, state *framework.Cycle
 	scheduledList := networkawareutil.GetScheduledList(pods)
 	// Check if scheduledList is empty...
 	if len(scheduledList) == 0 {
-		klog.ErrorS(nil, "Scheduled list is empty, return")
+		logger.Error(nil, "Scheduled list is empty, return")
 		return nil, framework.NewStatus(framework.Success, "Scheduled list is empty, return")
 	}
 
@@ -244,7 +246,7 @@ func (no *NetworkOverhead) PreFilter(ctx context.Context, state *framework.Cycle
 		// retrieve region and zone labels
 		region := networkawareutil.GetNodeRegion(nodeInfo.Node())
 		zone := networkawareutil.GetNodeZone(nodeInfo.Node())
-		klog.V(6).InfoS("Node info",
+		logger.V(6).Info("Node info",
 			"name", nodeInfo.Node().Name,
 			"region", region,
 			"zone", zone)
@@ -254,13 +256,13 @@ func (no *NetworkOverhead) PreFilter(ctx context.Context, state *framework.Cycle
 
 		// Populate cost map for the given node
 		no.populateCostMap(costMap, networkTopology, region, zone)
-		klog.V(6).InfoS("Map", "costMap", costMap)
+		logger.V(6).Info("Map", "costMap", costMap)
 
 		// Update nodeCostMap
 		nodeCostMap[nodeInfo.Node().Name] = costMap
 
 		// Get Satisfied and Violated number of dependencies
-		satisfied, violated, ok := checkMaxNetworkCostRequirements(scheduledList, dependencyList, nodeInfo, region, zone, costMap, no)
+		satisfied, violated, ok := checkMaxNetworkCostRequirements(logger, scheduledList, dependencyList, nodeInfo, region, zone, costMap, no)
 		if ok != nil {
 			return nil, framework.NewStatus(framework.Error, fmt.Sprintf("pod hostname not found: %v", ok))
 		}
@@ -268,14 +270,14 @@ func (no *NetworkOverhead) PreFilter(ctx context.Context, state *framework.Cycle
 		// Update Satisfied and Violated maps
 		satisfiedMap[nodeInfo.Node().Name] = satisfied
 		violatedMap[nodeInfo.Node().Name] = violated
-		klog.V(6).InfoS("Number of dependencies", "satisfied", satisfied, "violated", violated)
+		logger.V(6).Info("Number of dependencies", "satisfied", satisfied, "violated", violated)
 
 		// Get accumulated cost based on pod dependencies
-		cost, ok := no.getAccumulatedCost(scheduledList, dependencyList, nodeInfo.Node().Name, region, zone, costMap)
+		cost, ok := no.getAccumulatedCost(logger, scheduledList, dependencyList, nodeInfo.Node().Name, region, zone, costMap)
 		if ok != nil {
 			return nil, framework.NewStatus(framework.Error, fmt.Sprintf("getting pod hostname from Snapshot: %v", ok))
 		}
-		klog.V(6).InfoS("Node final cost", "cost", cost)
+		logger.V(6).Info("Node final cost", "cost", cost)
 		finalCostMap[nodeInfo.Node().Name] = cost
 	}
 
@@ -330,24 +332,25 @@ func (no *NetworkOverhead) Filter(ctx context.Context,
 	if nodeInfo.Node() == nil {
 		return framework.NewStatus(framework.Error, "node not found")
 	}
+	logger := klog.FromContext(ctx)
 
 	// Get PreFilterState
 	preFilterState, err := getPreFilterState(cycleState)
 	if err != nil {
-		klog.ErrorS(err, "Failed to read preFilterState from cycleState", "preFilterStateKey", preFilterStateKey)
+		logger.Error(err, "Failed to read preFilterState from cycleState", "preFilterStateKey", preFilterStateKey)
 		return framework.NewStatus(framework.Error, "not eligible due to failed to read from cycleState")
 	}
 
 	// If scoreEqually, return nil
 	if preFilterState.scoreEqually {
-		klog.V(6).InfoS("Score all nodes equally, return")
+		logger.V(6).Info("Score all nodes equally, return")
 		return nil
 	}
 
 	// Get satisfied and violated number of dependencies
 	satisfied := preFilterState.satisfiedMap[nodeInfo.Node().Name]
 	violated := preFilterState.violatedMap[nodeInfo.Node().Name]
-	klog.V(6).InfoS("Number of dependencies:", "satisfied", satisfied, "violated", violated)
+	logger.V(6).Info("Number of dependencies:", "satisfied", satisfied, "violated", violated)
 
 	// The pod is filtered out if the number of violated dependencies is higher than the satisfied ones
 	if violated > satisfied {
@@ -364,10 +367,11 @@ func (no *NetworkOverhead) Score(ctx context.Context,
 	nodeName string) (int64, *framework.Status) {
 	score := framework.MinNodeScore
 
+	logger := klog.FromContext(ctx)
 	// Get PreFilterState
 	preFilterState, err := getPreFilterState(cycleState)
 	if err != nil {
-		klog.ErrorS(err, "Failed to read preFilterState from cycleState", "preFilterStateKey", preFilterStateKey)
+		logger.Error(err, "Failed to read preFilterState from cycleState", "preFilterStateKey", preFilterStateKey)
 		return score, framework.NewStatus(framework.Error, "not eligible due to failed to read from cycleState, return min score")
 	}
 
@@ -378,7 +382,7 @@ func (no *NetworkOverhead) Score(ctx context.Context,
 
 	// Return Accumulated Cost as score
 	score = preFilterState.finalCostMap[nodeName]
-	klog.V(4).InfoS("Score:", "pod", pod.GetName(), "node", nodeName, "finalScore", score)
+	logger.V(4).Info("Score:", "pod", pod.GetName(), "node", nodeName, "finalScore", score)
 	return score, framework.NewStatus(framework.Success, "Accumulated cost added as score, normalization ensures lower costs are favored")
 }
 
@@ -387,7 +391,8 @@ func (no *NetworkOverhead) NormalizeScore(ctx context.Context,
 	state *framework.CycleState,
 	pod *corev1.Pod,
 	scores framework.NodeScoreList) *framework.Status {
-	klog.V(4).InfoS("before normalization: ", "scores", scores)
+	logger := klog.FromContext(ctx)
+	logger.V(4).Info("before normalization: ", "scores", scores)
 
 	// Get Min and Max Scores to normalize between framework.MaxNodeScore and framework.MinNodeScore
 	minCost, maxCost := getMinMaxScores(scores)
@@ -409,7 +414,7 @@ func (no *NetworkOverhead) NormalizeScore(ctx context.Context,
 			scores[i].Score = framework.MaxNodeScore - int64(normCost)
 		}
 	}
-	klog.V(4).InfoS("after normalization: ", "scores", scores)
+	logger.V(4).Info("after normalization: ", "scores", scores)
 	return nil
 }
 
@@ -494,6 +499,7 @@ func (no *NetworkOverhead) populateCostMap(
 
 // checkMaxNetworkCostRequirements : verifies the number of met and unmet dependencies based on the pod being filtered
 func checkMaxNetworkCostRequirements(
+	logger klog.Logger,
 	scheduledList networkawareutil.ScheduledList,
 	dependencyList []agv1alpha1.DependenciesInfo,
 	nodeInfo *framework.NodeInfo,
@@ -522,7 +528,7 @@ func checkMaxNetworkCostRequirements(
 				// If Nodes are not the same, get NodeInfo from pod Hostname
 				podNodeInfo, err := no.handle.SnapshotSharedLister().NodeInfos().Get(podAllocated.Hostname)
 				if err != nil {
-					klog.ErrorS(nil, "getting pod nodeInfo %q from Snapshot: %v", podNodeInfo, err)
+					logger.Error(nil, "getting pod nodeInfo %q from Snapshot: %v", podNodeInfo, err)
 					return satisfied, violated, err
 				}
 
@@ -569,6 +575,7 @@ func checkMaxNetworkCostRequirements(
 
 // getAccumulatedCost : calculate the accumulated cost based on the Pod's dependencies
 func (no *NetworkOverhead) getAccumulatedCost(
+	logger klog.Logger,
 	scheduledList networkawareutil.ScheduledList,
 	dependencyList []agv1alpha1.DependenciesInfo,
 	nodeName string,
@@ -592,7 +599,7 @@ func (no *NetworkOverhead) getAccumulatedCost(
 				// Get NodeInfo from pod Hostname
 				podNodeInfo, err := no.handle.SnapshotSharedLister().NodeInfos().Get(podAllocated.Hostname)
 				if err != nil {
-					klog.ErrorS(nil, "getting pod hostname %q from Snapshot: %v", podNodeInfo, err)
+					logger.Error(nil, "getting pod hostname %q from Snapshot: %v", podNodeInfo, err)
 					return cost, err
 				}
 				// Get zone and region from Pod Hostname
@@ -646,18 +653,18 @@ func getPreFilterState(cycleState *framework.CycleState) (*PreFilterState, error
 	return state, nil
 }
 
-func (no *NetworkOverhead) findAppGroupNetworkOverhead(agName string) *agv1alpha1.AppGroup {
-	klog.V(6).InfoS("namespaces: %s", no.namespaces)
+func (no *NetworkOverhead) findAppGroupNetworkOverhead(ctx context.Context, logger klog.Logger, agName string) *agv1alpha1.AppGroup {
+	logger.V(6).Info("namespaces: %s", no.namespaces)
 	for _, namespace := range no.namespaces {
-		klog.V(6).InfoS("appGroup CR", "namespace", namespace, "name", agName)
+		logger.V(6).Info("appGroup CR", "namespace", namespace, "name", agName)
 		// AppGroup could not be placed in several namespaces simultaneously
 		appGroup := &agv1alpha1.AppGroup{}
-		err := no.Get(context.TODO(), client.ObjectKey{
+		err := no.Get(ctx, client.ObjectKey{
 			Namespace: namespace,
 			Name:      agName,
 		}, appGroup)
 		if err != nil {
-			klog.V(4).ErrorS(err, "Cannot get AppGroup from AppGroupNamespaceLister:")
+			logger.V(4).Error(err, "Cannot get AppGroup from AppGroupNamespaceLister:")
 			continue
 		}
 		if appGroup != nil && appGroup.GetUID() != "" {
@@ -667,18 +674,18 @@ func (no *NetworkOverhead) findAppGroupNetworkOverhead(agName string) *agv1alpha
 	return nil
 }
 
-func (no *NetworkOverhead) findNetworkTopologyNetworkOverhead() *ntv1alpha1.NetworkTopology {
-	klog.V(6).InfoS("namespaces: %s", no.namespaces)
+func (no *NetworkOverhead) findNetworkTopologyNetworkOverhead(ctx context.Context, logger klog.Logger) *ntv1alpha1.NetworkTopology {
+	logger.V(6).Info("namespaces: %s", no.namespaces)
 	for _, namespace := range no.namespaces {
-		klog.V(6).InfoS("networkTopology CR:", "namespace", namespace, "name", no.ntName)
+		logger.V(6).Info("networkTopology CR:", "namespace", namespace, "name", no.ntName)
 		// NetworkTopology could not be placed in several namespaces simultaneously
 		networkTopology := &ntv1alpha1.NetworkTopology{}
-		err := no.Get(context.TODO(), client.ObjectKey{
+		err := no.Get(ctx, client.ObjectKey{
 			Namespace: namespace,
 			Name:      no.ntName,
 		}, networkTopology)
 		if err != nil {
-			klog.V(4).ErrorS(err, "Cannot get networkTopology from networkTopologyNamespaceLister:")
+			logger.V(4).Error(err, "Cannot get networkTopology from networkTopologyNamespaceLister:")
 			continue
 		}
 		if networkTopology != nil && networkTopology.GetUID() != "" {
diff --git a/pkg/networkaware/topologicalsort/topologicalsort.go b/pkg/networkaware/topologicalsort/topologicalsort.go
index 326a2db9..a360347e 100644
--- a/pkg/networkaware/topologicalsort/topologicalsort.go
+++ b/pkg/networkaware/topologicalsort/topologicalsort.go
@@ -72,8 +72,9 @@ func getArgs(obj runtime.Object) (*pluginconfig.TopologicalSortArgs, error) {
 }
 
 // New : create an instance of a TopologicalSort plugin
-func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
-	klog.V(4).InfoS("Creating new instance of the TopologicalSort plugin")
+func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+	logger := klog.FromContext(ctx)
+	logger.V(4).Info("Creating new instance of the TopologicalSort plugin")
 
 	args, err := getArgs(obj)
 	if err != nil {
@@ -101,18 +102,20 @@ func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framew
 func (ts *TopologicalSort) Less(pInfo1, pInfo2 *framework.QueuedPodInfo) bool {
 	p1AppGroup := networkawareutil.GetPodAppGroupLabel(pInfo1.Pod)
 	p2AppGroup := networkawareutil.GetPodAppGroupLabel(pInfo2.Pod)
+	ctx := context.TODO()
+	logger := klog.FromContext(ctx)
 
 	// If pods do not belong to an AppGroup, or being to different AppGroups, follow vanilla QoS Sort
 	if p1AppGroup != p2AppGroup || len(p1AppGroup) == 0 {
-		klog.V(4).InfoS("Pods do not belong to the same AppGroup CR", "p1AppGroup", p1AppGroup, "p2AppGroup", p2AppGroup)
+		logger.V(4).Info("Pods do not belong to the same AppGroup CR", "p1AppGroup", p1AppGroup, "p2AppGroup", p2AppGroup)
 		s := &queuesort.PrioritySort{}
 		return s.Less(pInfo1, pInfo2)
 	}
 
 	// Pods belong to the same appGroup, get the CR
-	klog.V(6).InfoS("Pods belong to the same AppGroup CR", "p1 name", pInfo1.Pod.Name, "p2 name", pInfo2.Pod.Name, "appGroup", p1AppGroup)
+	logger.V(6).Info("Pods belong to the same AppGroup CR", "p1 name", pInfo1.Pod.Name, "p2 name", pInfo2.Pod.Name, "appGroup", p1AppGroup)
 	agName := p1AppGroup
-	appGroup := ts.findAppGroupTopologicalSort(agName)
+	appGroup := ts.findAppGroupTopologicalSort(ctx, logger, agName)
 
 	// Get labels from both pods
 	labelsP1 := pInfo1.Pod.GetLabels()
@@ -122,24 +125,23 @@ func (ts *TopologicalSort) Less(pInfo1, pInfo2 *framework.QueuedPodInfo) bool {
 	orderP1 := networkawareutil.FindPodOrder(appGroup.Status.TopologyOrder, labelsP1[agv1alpha.AppGroupSelectorLabel])
 	orderP2 := networkawareutil.FindPodOrder(appGroup.Status.TopologyOrder, labelsP2[agv1alpha.AppGroupSelectorLabel])
 
-	klog.V(6).InfoS("Pod order values", "p1 order", orderP1, "p2 order", orderP2)
+	logger.V(6).Info("Pod order values", "p1 order", orderP1, "p2 order", orderP2)
 
 	// Lower is better
 	return orderP1 <= orderP2
 }
 
-func (ts *TopologicalSort) findAppGroupTopologicalSort(agName string) *agv1alpha.AppGroup {
-	klog.V(6).InfoS("namespaces: %s", ts.namespaces)
+func (ts *TopologicalSort) findAppGroupTopologicalSort(ctx context.Context, logger klog.Logger, agName string) *agv1alpha.AppGroup {
 	for _, namespace := range ts.namespaces {
-		klog.V(6).InfoS("appGroup CR", "namespace", namespace, "name", agName)
+		logger.V(6).Info("appGroup CR", "namespace", namespace, "name", agName)
 		// AppGroup couldn't be placed in several namespaces simultaneously
 		appGroup := &agv1alpha.AppGroup{}
-		err := ts.Get(context.TODO(), client.ObjectKey{
+		err := ts.Get(ctx, client.ObjectKey{
 			Namespace: namespace,
 			Name:      agName,
 		}, appGroup)
 		if err != nil {
-			klog.V(4).InfoS("Cannot get AppGroup from AppGroupNamespaceLister:", "error", err)
+			logger.V(4).Info("Cannot get AppGroup from AppGroupNamespaceLister:", "error", err)
 			continue
 		}
 		if appGroup != nil {
diff --git a/pkg/noderesources/allocatable.go b/pkg/noderesources/allocatable.go
index f394035a..4bd71cc1 100644
--- a/pkg/noderesources/allocatable.go
+++ b/pkg/noderesources/allocatable.go
@@ -59,6 +59,7 @@ func validateResources(resources []schedulerconfig.ResourceSpec) error {
 
 // Score invoked at the score extension point.
 func (alloc *Allocatable) Score(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
+	logger := klog.FromContext(ctx)
 	nodeInfo, err := alloc.handle.SnapshotSharedLister().NodeInfos().Get(nodeName)
 	if err != nil {
 		return 0, framework.NewStatus(framework.Error, fmt.Sprintf("getting node %q from Snapshot: %v", nodeName, err))
@@ -68,7 +69,7 @@ func (alloc *Allocatable) Score(ctx context.Context, state *framework.CycleState
 	// It calculates the sum of the node's weighted allocatable resources.
 	//
 	// Note: the returned "score" is negative for least allocatable, and positive for most allocatable.
-	return alloc.score(pod, nodeInfo)
+	return alloc.score(logger, pod, nodeInfo)
 }
 
 // ScoreExtensions of the Score plugin.
diff --git a/pkg/noderesources/resource_allocation.go b/pkg/noderesources/resource_allocation.go
index 1e29873d..b4b26e5b 100644
--- a/pkg/noderesources/resource_allocation.go
+++ b/pkg/noderesources/resource_allocation.go
@@ -47,6 +47,7 @@ type resourceToValueMap map[v1.ResourceName]int64
 
 // score will use `scorer` function to calculate the score.
 func (r *resourceAllocationScorer) score(
+	logger klog.Logger,
 	pod *v1.Pod,
 	nodeInfo *framework.NodeInfo) (int64, *framework.Status) {
 	node := nodeInfo.Node()
@@ -59,13 +60,13 @@ func (r *resourceAllocationScorer) score(
 	requested := make(resourceToValueMap, len(r.resourceToWeightMap))
 	allocatable := make(resourceToValueMap, len(r.resourceToWeightMap))
 	for resource := range r.resourceToWeightMap {
-		allocatable[resource], requested[resource] = calculateResourceAllocatableRequest(nodeInfo, pod, resource)
+		allocatable[resource], requested[resource] = calculateResourceAllocatableRequest(logger, nodeInfo, pod, resource)
 	}
 
 	score := r.scorer(requested, allocatable)
 
-	if klog.V(10).Enabled() {
-		klog.InfoS("Resources and score",
+	if logger.V(10).Enabled() {
+		logger.Info("Resources and score",
 			"podName", pod.Name, "nodeName", node.Name, "scorer", r.Name,
 			"allocatableResources", allocatable, "requestedResources", requested,
 			"score", score)
@@ -75,7 +76,7 @@ func (r *resourceAllocationScorer) score(
 }
 
 // calculateResourceAllocatableRequest returns resources Allocatable and Requested values
-func calculateResourceAllocatableRequest(nodeInfo *framework.NodeInfo, pod *v1.Pod, resource v1.ResourceName) (int64, int64) {
+func calculateResourceAllocatableRequest(logger klog.Logger, nodeInfo *framework.NodeInfo, pod *v1.Pod, resource v1.ResourceName) (int64, int64) {
 	podRequest := calculatePodResourceRequest(pod, resource)
 	switch resource {
 	case v1.ResourceCPU:
@@ -90,8 +91,8 @@ func calculateResourceAllocatableRequest(nodeInfo *framework.NodeInfo, pod *v1.P
 			return nodeInfo.Allocatable.ScalarResources[resource], (nodeInfo.Requested.ScalarResources[resource] + podRequest)
 		}
 	}
-	if klog.V(10).Enabled() {
-		klog.InfoS("Requested resource not considered for node score calculation",
+	if logger.V(10).Enabled() {
+		logger.Info("Requested resource not considered for node score calculation",
 			"resource", resource,
 		)
 	}
diff --git a/pkg/preemptiontoleration/README.md b/pkg/preemptiontoleration/README.md
index 6aaa9c58..ae4bb7fb 100644
--- a/pkg/preemptiontoleration/README.md
+++ b/pkg/preemptiontoleration/README.md
@@ -39,11 +39,10 @@ Preemption toleration policy can be defined on each `PriorityClass` resource by
 # Any pod P in this priority class can not be preempted (can tolerate preemption)
 # - by preemptor pods with priority < 10000 
 # - and if P is within 1h since being scheduled
-apiVersion: scheduling.k8s.io/v1
 kind: PriorityClass
 metadata:
   name: toleration-policy-sample
-  annotations:
+  annotation:
     preemption-toleration.scheduling.x-k8s.io/minimum-preemptable-priority: "10000"
     preemption-toleration.scheduling.x-k8s.io/toleration-seconds: "3600"
 value: 8000
diff --git a/pkg/preemptiontoleration/preemption_toleration.go b/pkg/preemptiontoleration/preemption_toleration.go
index c71f17e8..7ab7767d 100644
--- a/pkg/preemptiontoleration/preemption_toleration.go
+++ b/pkg/preemptiontoleration/preemption_toleration.go
@@ -129,6 +129,8 @@ func ExemptedFromPreemption(
 	pcLister schedulinglisters.PriorityClassLister,
 	now time.Time,
 ) (bool, error) {
+	logger := klog.FromContext(context.TODO())
+
 	if victimCandidate.Spec.PriorityClassName == "" {
 		return false, nil
 	}
@@ -149,7 +151,7 @@ func ExemptedFromPreemption(
 	policy, err := parsePreemptionTolerationPolicy(*victimPriorityClass)
 	if err != nil {
 		// if any error raised, no toleration at all
-		klog.ErrorS(err, "Failed to parse preemption toleration policy of victim candidate's priorityclass.  This victim candidate can't tolerate the preemption",
+		logger.Error(err, "Failed to parse preemption toleration policy of victim candidate's priorityclass.  This victim candidate can't tolerate the preemption",
 			"PreemptorPod", klog.KObj(preemptor),
 			"VictimCandidatePod", klog.KObj(victimCandidate),
 			"VictimCandidatePriorityClass", klog.KRef("", victimPriorityClass.Name),
@@ -219,7 +221,7 @@ func (pl *PreemptionToleration) SelectVictimsOnNode(
 		// For a pod with lower priority, check if it can be exempted from the preemption.
 		exempted, err := ExemptedFromPreemption(pi.Pod, preemptor, pl.priorityClassLister, pl.curTime)
 		if err != nil {
-			klog.ErrorS(err, "Encountered error while selecting victims on node", "Node", nodeInfo.Node().Name)
+			logger.Error(err, "Encountered error while selecting victims on node", "Node", nodeInfo.Node().Name)
 			return nil, 0, framework.AsStatus(err)
 		}
 
@@ -265,7 +267,7 @@ func (pl *PreemptionToleration) SelectVictimsOnNode(
 			}
 			rpi := pi.Pod
 			victims = append(victims, rpi)
-			klog.V(5).InfoS("Pod is a potential preemption victim on node", "pod", klog.KObj(rpi), "node", klog.KObj(nodeInfo.Node()))
+			logger.V(5).Info("Pod is a potential preemption victim on node", "pod", klog.KObj(rpi), "node", klog.KObj(nodeInfo.Node()))
 		}
 		return fits, nil
 	}
@@ -324,8 +326,9 @@ func (pl *PreemptionToleration) calculateNumCandidates(numNodes int32) int32 {
 // We look at the node that is nominated for this pod and as long as there are
 // terminating pods on the node, we don't consider this for preempting more pods.
 func (pl *PreemptionToleration) PodEligibleToPreemptOthers(pod *v1.Pod, nominatedNodeStatus *framework.Status) (bool, string) {
+	logger := klog.FromContext(context.TODO())
 	if pod.Spec.PreemptionPolicy != nil && *pod.Spec.PreemptionPolicy == v1.PreemptNever {
-		klog.V(5).InfoS("Pod is not eligible for preemption because it has a preemptionPolicy of Never", "pod", klog.KObj(pod))
+		logger.V(5).Info("Pod is not eligible for preemption because it has a preemptionPolicy of Never", "pod", klog.KObj(pod))
 		return false, "not eligible due to preemptionPolicy=Never."
 	}
 	nodeInfos := pl.fh.SnapshotSharedLister().NodeInfos()
diff --git a/pkg/sysched/sysched.go b/pkg/sysched/sysched.go
index 3c8289cc..4f8359f1 100644
--- a/pkg/sysched/sysched.go
+++ b/pkg/sysched/sysched.go
@@ -17,9 +17,9 @@ import (
 	"k8s.io/klog/v2"
 	"k8s.io/kubernetes/pkg/scheduler/framework"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/helper"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/security-profiles-operator/api/seccompprofile/v1beta1"
 
-	"sigs.k8s.io/controller-runtime/pkg/client"
 	pluginconfig "sigs.k8s.io/scheduler-plugins/apis/config"
 	"sigs.k8s.io/scheduler-plugins/apis/scheduling/v1alpha1"
 )
@@ -120,7 +120,7 @@ func (sc *SySched) readSPOProfileCR(name string, namespace string) (sets.Set[str
 // SPO is used to generate and input the seccomp profile to a pod
 // If a pod does not have a SPO seccomp profile, then an unconfined
 // system call set is return for the pod
-func (sc *SySched) getSyscalls(pod *v1.Pod) sets.Set[string] {
+func (sc *SySched) getSyscalls(logger klog.Logger, pod *v1.Pod) sets.Set[string] {
 	r := sets.New[string]()
 
 	// read the seccomp profile from the security context of a pod
@@ -134,7 +134,7 @@ func (sc *SySched) getSyscalls(pod *v1.Pod) sets.Set[string] {
 			if len(ns) > 0 && len(name) > 0 {
 				syscalls, err := sc.readSPOProfileCR(name, ns)
 				if err != nil {
-					klog.ErrorS(err, "Failed to read syscall CR by parsing pod security context")
+					logger.Error(err, "Failed to read syscall CR by parsing pod security context")
 				}
 
 				if len(syscalls) > 0 {
@@ -155,7 +155,7 @@ func (sc *SySched) getSyscalls(pod *v1.Pod) sets.Set[string] {
 				if len(ns) > 0 && len(name) > 0 {
 					syscalls, err := sc.readSPOProfileCR(name, ns)
 					if err != nil {
-						klog.ErrorS(err, "Failed to read syscall CR by parsing container security context")
+						logger.Error(err, "Failed to read syscall CR by parsing container security context")
 					}
 
 					if len(syscalls) > 0 {
@@ -179,7 +179,7 @@ func (sc *SySched) getSyscalls(pod *v1.Pod) sets.Set[string] {
 					syscalls, err := sc.readSPOProfileCR(name, ns)
 
 					if err != nil {
-						klog.ErrorS(err, "Failed to read syscall CR by parsing pod annotation")
+						logger.Error(err, "Failed to read syscall CR by parsing pod annotation")
 						continue
 					}
 
@@ -196,7 +196,7 @@ func (sc *SySched) getSyscalls(pod *v1.Pod) sets.Set[string] {
 	if len(r) == 0 {
 		syscalls, err := sc.readSPOProfileCR(sc.DefaultProfileName, sc.DefaultProfileNamespace)
 		if err != nil {
-			klog.ErrorS(err, "Failed to read the CR of all syscalls")
+			logger.Error(err, "Failed to read the CR of all syscalls")
 		}
 
 		if syscalls.Len() > 0 {
@@ -212,7 +212,7 @@ func (sc *SySched) Name() string {
 	return Name
 }
 
-func (sc *SySched) calcScore(syscalls sets.Set[string]) int {
+func (sc *SySched) calcScore(logger klog.Logger, syscalls sets.Set[string]) int {
 	// Currently, score is not adjusted based on critical/cve syscalls.
 	// NOTE: weight W is hardcoded for now
 	// TODO: add critical/cve syscalls
@@ -222,13 +222,14 @@ func (sc *SySched) calcScore(syscalls sets.Set[string]) int {
 
 	score := syscalls.Len() - totCrit
 	score = score + W*totCrit
-	klog.V(10).InfoS("Score: ", "score", score, "tot_crit", totCrit)
+	logger.V(10).Info("Score: ", "score", score, "tot_crit", totCrit)
 
 	return score
 }
 
 // Score invoked at the score extension point.
 func (sc *SySched) Score(ctx context.Context, cs *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
+	logger := klog.FromContext(ctx)
 	// Read directly from API server because cached state in SnapSharedLister not always up-to-date
 	// especially during initial scheduler start.
 	node, err := sc.handle.ClientSet().CoreV1().Nodes().Get(ctx, nodeName, metav1.GetOptions{})
@@ -236,7 +237,7 @@ func (sc *SySched) Score(ctx context.Context, cs *framework.CycleState, pod *v1.
 		return 0, nil
 	}
 
-	podSyscalls := sc.getSyscalls(pod)
+	podSyscalls := sc.getSyscalls(logger, pod)
 
 	// NOTE: this condition is true only when a pod does not
 	// have a syscall profile, or the unconfined syscall is
@@ -245,7 +246,7 @@ func (sc *SySched) Score(ctx context.Context, cs *framework.CycleState, pod *v1.
 		return math.MaxInt64, nil
 	}
 
-	_, hostSyscalls := sc.getHostSyscalls(node.Name)
+	_, hostSyscalls := sc.getHostSyscalls(logger, node.Name)
 
 	// when a host or node does not have any pods
 	// running, the extraneous syscall score is zero
@@ -254,30 +255,31 @@ func (sc *SySched) Score(ctx context.Context, cs *framework.CycleState, pod *v1.
 	}
 
 	diffSyscalls := hostSyscalls.Difference(podSyscalls)
-	totalDiffs := sc.calcScore(diffSyscalls)
+	totalDiffs := sc.calcScore(logger, diffSyscalls)
 
 	// add the difference existing pods will see if new Pod is added into this host
 	newHostSyscalls := hostSyscalls.Clone()
 	newHostSyscalls = newHostSyscalls.Union(podSyscalls)
 	for _, p := range sc.HostToPods[node.Name] {
-		podSyscalls = sc.getSyscalls(p)
+		podSyscalls = sc.getSyscalls(logger, p)
 		diffSyscalls = newHostSyscalls.Difference(podSyscalls)
-		totalDiffs += sc.calcScore(diffSyscalls)
+		totalDiffs += sc.calcScore(logger, diffSyscalls)
 	}
 
 	sc.ExSAvg = sc.ExSAvg + (float64(totalDiffs)-sc.ExSAvg)/float64(sc.ExSAvgCount)
 	sc.ExSAvgCount += 1
 
-	klog.V(10).Info("ExSAvg: ", sc.ExSAvg)
-	klog.V(10).InfoS("Score: ", "totalDiffs", totalDiffs, "pod", pod.Name, "node", nodeName)
+	logger.V(10).Info("ExSAvg: ", sc.ExSAvg)
+	logger.V(10).Info("Score: ", "totalDiffs", totalDiffs, "pod", pod.Name, "node", nodeName)
 
 	return int64(totalDiffs), nil
 }
 
 func (sc *SySched) NormalizeScore(ctx context.Context, state *framework.CycleState, pod *v1.Pod, scores framework.NodeScoreList) *framework.Status {
-	klog.V(10).InfoS("Original: ", "scores", scores, "pod", pod.Name)
+	logger := klog.FromContext(ctx)
+	logger.V(10).Info("Original: ", "scores", scores, "pod", pod.Name)
 	ret := helper.DefaultNormalizeScore(framework.MaxNodeScore, true, scores)
-	klog.V(10).InfoS("Normalized: ", "scores", scores, "pod", pod.Name)
+	logger.V(10).Info("Normalized: ", "scores", scores, "pod", pod.Name)
 
 	return ret
 }
@@ -287,22 +289,22 @@ func (sc *SySched) ScoreExtensions() framework.ScoreExtensions {
 	return sc
 }
 
-func (sc *SySched) getHostSyscalls(nodeName string) (int, sets.Set[string]) {
+func (sc *SySched) getHostSyscalls(logger klog.Logger, nodeName string) (int, sets.Set[string]) {
 	count := 0
 	h, ok := sc.HostSyscalls[nodeName]
 	if !ok {
-		klog.V(5).Infof("getHostSyscalls: no nodeName %s", nodeName)
+		logger.V(5).Info(fmt.Sprintf("getHostSyscalls: no nodeName %s", nodeName))
 		return count, nil
 	}
 	return h.Len(), h
 }
 
-func (sc *SySched) updateHostSyscalls(pod *v1.Pod) {
-	syscall := sc.getSyscalls(pod)
+func (sc *SySched) updateHostSyscalls(logger klog.Logger, pod *v1.Pod) {
+	syscall := sc.getSyscalls(logger, pod)
 	sc.HostSyscalls[pod.Spec.NodeName] = sc.HostSyscalls[pod.Spec.NodeName].Union(syscall)
 }
 
-func (sc *SySched) addPod(pod *v1.Pod) {
+func (sc *SySched) addPod(logger klog.Logger, pod *v1.Pod) {
 	nodeName := pod.Spec.NodeName
 	name := pod.Name
 
@@ -311,7 +313,7 @@ func (sc *SySched) addPod(pod *v1.Pod) {
 		sc.HostToPods[nodeName] = make([]*v1.Pod, 0)
 		sc.HostToPods[nodeName] = append(sc.HostToPods[nodeName], pod)
 		sc.HostSyscalls[nodeName] = sets.New[string]()
-		sc.updateHostSyscalls(pod)
+		sc.updateHostSyscalls(logger, pod)
 		return
 	}
 
@@ -322,36 +324,36 @@ func (sc *SySched) addPod(pod *v1.Pod) {
 	}
 
 	sc.HostToPods[nodeName] = append(sc.HostToPods[nodeName], pod)
-	sc.updateHostSyscalls(pod)
+	sc.updateHostSyscalls(logger, pod)
 
 	return
 }
 
-func (sc *SySched) recomputeHostSyscalls(pods []*v1.Pod) sets.Set[string] {
+func (sc *SySched) recomputeHostSyscalls(logger klog.Logger, pods []*v1.Pod) sets.Set[string] {
 	syscalls := sets.New[string]()
 
 	for _, p := range pods {
-		syscall := sc.getSyscalls(p)
+		syscall := sc.getSyscalls(logger, p)
 		syscalls = syscalls.Union(syscall)
 	}
 
 	return syscalls
 }
 
-func (sc *SySched) removePod(pod *v1.Pod) {
+func (sc *SySched) removePod(logger klog.Logger, pod *v1.Pod) {
 	nodeName := pod.Spec.NodeName
 
 	_, ok := sc.HostToPods[nodeName]
 	if !ok {
-		klog.V(5).Infof("removePod: Host %s not yet cached", nodeName)
+		logger.V(5).Info(fmt.Sprintf("removePod: Host %s not yet cached", nodeName))
 		return
 	}
 	for i, p := range sc.HostToPods[nodeName] {
 		if p.Name == pod.Name {
 			sc.HostToPods[nodeName] = remove(sc.HostToPods[nodeName], i)
-			sc.HostSyscalls[nodeName] = sc.recomputeHostSyscalls(sc.HostToPods[nodeName])
-			c, _ := sc.getHostSyscalls(nodeName)
-			klog.V(5).InfoS("remaining ", "syscalls", c, "node", nodeName)
+			sc.HostSyscalls[nodeName] = sc.recomputeHostSyscalls(logger, sc.HostToPods[nodeName])
+			c, _ := sc.getHostSyscalls(logger, nodeName)
+			logger.V(5).Info("remaining ", "syscalls", c, "node", nodeName)
 			return
 		}
 	}
@@ -360,30 +362,33 @@ func (sc *SySched) removePod(pod *v1.Pod) {
 }
 
 func (sc *SySched) podAdded(obj interface{}) {
+	logger := klog.FromContext(context.TODO())
 	pod := obj.(*v1.Pod)
 
 	// Add already running pod to map
 	// This is for when our scheduler comes up after other pods
 	if pod.Status.Phase == v1.PodRunning {
-		klog.V(10).Infof("POD ADDED: %s/%s phase: %s", pod.Namespace, pod.Name, pod.Status.Phase)
-		sc.addPod(pod)
+		logger.V(10).Info(fmt.Sprintf("POD ADDED: %s/%s phase: %s", pod.Namespace, pod.Name, pod.Status.Phase))
+		sc.addPod(logger, pod)
 	}
 }
 
 func (sc *SySched) podUpdated(old, new interface{}) {
+	logger := klog.FromContext(context.TODO())
 	pod := old.(*v1.Pod)
 
 	// Pod has been assigned to node, now can add to our map
 	if pod.Status.Phase == v1.PodPending && pod.Status.HostIP != "" {
-		klog.V(10).Infof("POD UPDATED. %s/%s", pod.Namespace, pod.Name)
-		sc.addPod(pod)
+		logger.V(10).Info(fmt.Sprintf("POD UPDATED. %s/%s", pod.Namespace, pod.Name))
+		sc.addPod(logger, pod)
 	}
 }
 
 func (sc *SySched) podDeleted(obj interface{}) {
+	logger := klog.FromContext(context.TODO())
 	pod := obj.(*v1.Pod)
-	klog.V(10).Infof("POD DELETED: %s/%s", pod.Namespace, pod.Name)
-	sc.removePod(pod)
+	logger.V(10).Info(fmt.Sprintf("POD DELETED: %s/%s", pod.Namespace, pod.Name))
+	sc.removePod(logger, pod)
 }
 
 // getArgs : returns the arguments for the SySchedArg plugin.
diff --git a/pkg/trimaran/collector.go b/pkg/trimaran/collector.go
index 2208cede..69bb9b65 100644
--- a/pkg/trimaran/collector.go
+++ b/pkg/trimaran/collector.go
@@ -49,11 +49,11 @@ type Collector struct {
 }
 
 // NewCollector : create an instance of a data collector
-func NewCollector(trimaranSpec *pluginConfig.TrimaranSpec) (*Collector, error) {
+func NewCollector(logger klog.Logger, trimaranSpec *pluginConfig.TrimaranSpec) (*Collector, error) {
 	if err := checkSpecs(trimaranSpec); err != nil {
 		return nil, err
 	}
-	klog.V(4).InfoS("Using TrimaranSpec", "type", trimaranSpec.MetricProvider.Type,
+	logger.V(4).Info("Using TrimaranSpec", "type", trimaranSpec.MetricProvider.Type,
 		"address", trimaranSpec.MetricProvider.Address, "watcher", trimaranSpec.WatcherAddress)
 
 	var client loadwatcherapi.Client
@@ -74,17 +74,17 @@ func NewCollector(trimaranSpec *pluginConfig.TrimaranSpec) (*Collector, error) {
 	}
 
 	// populate metrics before returning
-	err := collector.updateMetrics()
+	err := collector.updateMetrics(logger)
 	if err != nil {
-		klog.ErrorS(err, "Unable to populate metrics initially")
+		logger.Error(err, "Unable to populate metrics initially")
 	}
 	// start periodic updates
 	go func() {
 		metricsUpdaterTicker := time.NewTicker(time.Second * metricsUpdateIntervalSeconds)
 		for range metricsUpdaterTicker.C {
-			err = collector.updateMetrics()
+			err = collector.updateMetrics(logger)
 			if err != nil {
-				klog.ErrorS(err, "Unable to update metrics")
+				logger.Error(err, "Unable to update metrics")
 			}
 		}
 	}()
@@ -100,16 +100,16 @@ func (collector *Collector) getAllMetrics() *watcher.WatcherMetrics {
 }
 
 // GetNodeMetrics : get metrics for a node from watcher
-func (collector *Collector) GetNodeMetrics(nodeName string) ([]watcher.Metric, *watcher.WatcherMetrics) {
+func (collector *Collector) GetNodeMetrics(logger klog.Logger, nodeName string) ([]watcher.Metric, *watcher.WatcherMetrics) {
 	allMetrics := collector.getAllMetrics()
 	// This happens if metrics were never populated since scheduler started
 	if allMetrics.Data.NodeMetricsMap == nil {
-		klog.ErrorS(nil, "Metrics not available from watcher")
+		logger.Error(nil, "Metrics not available from watcher")
 		return nil, nil
 	}
 	// Check if node is new (no metrics yet) or metrics are unavailable due to 404 or 500
 	if _, ok := allMetrics.Data.NodeMetricsMap[nodeName]; !ok {
-		klog.ErrorS(nil, "Unable to find metrics for node", "nodeName", nodeName)
+		logger.Error(nil, "Unable to find metrics for node", "nodeName", nodeName)
 		return nil, allMetrics
 	}
 	return allMetrics.Data.NodeMetricsMap[nodeName].Metrics, allMetrics
@@ -130,10 +130,10 @@ func checkSpecs(trimaranSpec *pluginConfig.TrimaranSpec) error {
 }
 
 // updateMetrics : request to load watcher to update all metrics
-func (collector *Collector) updateMetrics() error {
+func (collector *Collector) updateMetrics(logger klog.Logger) error {
 	metrics, err := collector.client.GetLatestWatcherMetrics()
 	if err != nil {
-		klog.ErrorS(err, "Load watcher client failed")
+		logger.Error(err, "Load watcher client failed")
 		return err
 	}
 	collector.mu.Lock()
diff --git a/pkg/trimaran/handler.go b/pkg/trimaran/handler.go
index 9b93cc34..cd672d41 100644
--- a/pkg/trimaran/handler.go
+++ b/pkg/trimaran/handler.go
@@ -21,6 +21,7 @@ Package Trimaran provides common code for plugins developed for real load aware
 package trimaran
 
 import (
+	"context"
 	"fmt"
 	"sort"
 	"sync"
@@ -56,7 +57,7 @@ type podInfo struct {
 	Pod       *v1.Pod
 }
 
-// Returns a new instance of PodAssignEventHandler, after starting a background go routine for cache cleanup
+// New returns a new instance of PodAssignEventHandler, after starting a background go routine for cache cleanup
 func New() *PodAssignEventHandler {
 	p := PodAssignEventHandler{ScheduledPodsCache: make(map[string][]podInfo)}
 	go func() {
@@ -107,6 +108,7 @@ func (p *PodAssignEventHandler) OnUpdate(oldObj, newObj interface{}) {
 }
 
 func (p *PodAssignEventHandler) OnDelete(obj interface{}) {
+	logger := klog.FromContext(context.TODO())
 	pod := obj.(*v1.Pod)
 	nodeName := pod.Spec.NodeName
 	p.Lock()
@@ -117,7 +119,7 @@ func (p *PodAssignEventHandler) OnDelete(obj interface{}) {
 	for i, v := range p.ScheduledPodsCache[nodeName] {
 		n := len(p.ScheduledPodsCache[nodeName])
 		if pod.ObjectMeta.UID == v.Pod.ObjectMeta.UID {
-			klog.V(10).InfoS("Deleting pod", "pod", klog.KObj(v.Pod))
+			logger.V(10).Info("Deleting pod", "pod", klog.KObj(v.Pod))
 			copy(p.ScheduledPodsCache[nodeName][i:], p.ScheduledPodsCache[nodeName][i+1:])
 			p.ScheduledPodsCache[nodeName][n-1] = podInfo{}
 			p.ScheduledPodsCache[nodeName] = p.ScheduledPodsCache[nodeName][:n-1]
diff --git a/pkg/trimaran/loadvariationriskbalancing/analysis.go b/pkg/trimaran/loadvariationriskbalancing/analysis.go
index b0db576c..0b625542 100644
--- a/pkg/trimaran/loadvariationriskbalancing/analysis.go
+++ b/pkg/trimaran/loadvariationriskbalancing/analysis.go
@@ -31,9 +31,9 @@ Calculation of risk score for resources given measured data
 // computeScore : compute score given usage statistics
 // - risk = [ average + margin * stDev^{1/sensitivity} ] / 2
 // - score = ( 1 - risk ) * maxScore
-func computeScore(rs *trimaran.ResourceStats, margin float64, sensitivity float64) float64 {
+func computeScore(logger klog.Logger, rs *trimaran.ResourceStats, margin float64, sensitivity float64) float64 {
 	if rs.Capacity <= 0 {
-		klog.ErrorS(nil, "Invalid resource capacity", "capacity", rs.Capacity)
+		logger.Error(nil, "Invalid resource capacity", "capacity", rs.Capacity)
 		return 0
 	}
 
@@ -55,6 +55,6 @@ func computeScore(rs *trimaran.ResourceStats, margin float64, sensitivity float6
 
 	// evaluate overall risk factor
 	risk := (mu + sigma) / 2
-	klog.V(6).InfoS("Evaluating risk factor", "mu", mu, "sigma", sigma, "margin", margin, "sensitivity", sensitivity, "risk", risk)
+	logger.V(6).Info("Evaluating risk factor", "mu", mu, "sigma", sigma, "margin", margin, "sensitivity", sensitivity, "risk", risk)
 	return (1. - risk) * float64(framework.MaxNodeScore)
 }
diff --git a/pkg/trimaran/loadvariationriskbalancing/loadvariationriskbalancing.go b/pkg/trimaran/loadvariationriskbalancing/loadvariationriskbalancing.go
index 78bcf714..330810de 100644
--- a/pkg/trimaran/loadvariationriskbalancing/loadvariationriskbalancing.go
+++ b/pkg/trimaran/loadvariationriskbalancing/loadvariationriskbalancing.go
@@ -52,18 +52,19 @@ type LoadVariationRiskBalancing struct {
 var _ framework.ScorePlugin = &LoadVariationRiskBalancing{}
 
 // New : create an instance of a LoadVariationRiskBalancing plugin
-func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
-	klog.V(4).InfoS("Creating new instance of the LoadVariationRiskBalancing plugin")
+func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+	logger := klog.FromContext(ctx)
+	logger.V(4).Info("Creating new instance of the LoadVariationRiskBalancing plugin")
 	// cast object into plugin arguments object
 	args, ok := obj.(*pluginConfig.LoadVariationRiskBalancingArgs)
 	if !ok {
 		return nil, fmt.Errorf("want args to be of type LoadVariationRiskBalancingArgs, got %T", obj)
 	}
-	collector, err := trimaran.NewCollector(&args.TrimaranSpec)
+	collector, err := trimaran.NewCollector(logger, &args.TrimaranSpec)
 	if err != nil {
 		return nil, err
 	}
-	klog.V(4).InfoS("Using LoadVariationRiskBalancingArgs", "margin", args.SafeVarianceMargin, "sensitivity", args.SafeVarianceSensitivity)
+	logger.V(4).Info("Using LoadVariationRiskBalancingArgs", "margin", args.SafeVarianceMargin, "sensitivity", args.SafeVarianceSensitivity)
 
 	podAssignEventHandler := trimaran.New()
 	podAssignEventHandler.AddToHandle(handle)
@@ -79,16 +80,17 @@ func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framew
 
 // Score : evaluate score for a node
 func (pl *LoadVariationRiskBalancing) Score(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
-	klog.V(6).InfoS("Calculating score", "pod", klog.KObj(pod), "nodeName", nodeName)
+	logger := klog.FromContext(ctx)
+	logger.V(6).Info("Calculating score", "pod", klog.KObj(pod), "nodeName", nodeName)
 	score := framework.MinNodeScore
 	nodeInfo, err := pl.handle.SnapshotSharedLister().NodeInfos().Get(nodeName)
 	if err != nil {
 		return score, framework.NewStatus(framework.Error, fmt.Sprintf("getting node %q from Snapshot: %v", nodeName, err))
 	}
 	// get node metrics
-	metrics, _ := pl.collector.GetNodeMetrics(nodeName)
+	metrics, _ := pl.collector.GetNodeMetrics(logger, nodeName)
 	if metrics == nil {
-		klog.InfoS("Failed to get metrics for node; using minimum score", "nodeName", nodeName)
+		logger.Info("Failed to get metrics for node; using minimum score", "nodeName", nodeName)
 		return score, nil
 	}
 	podRequest := trimaran.GetResourceRequested(pod)
@@ -96,18 +98,18 @@ func (pl *LoadVariationRiskBalancing) Score(ctx context.Context, cycleState *fra
 
 	// calculate CPU score
 	var cpuScore float64 = 0
-	cpuStats, cpuOK := trimaran.CreateResourceStats(metrics, node, podRequest, v1.ResourceCPU, watcher.CPU)
+	cpuStats, cpuOK := trimaran.CreateResourceStats(logger, metrics, node, podRequest, v1.ResourceCPU, watcher.CPU)
 	if cpuOK {
-		cpuScore = computeScore(cpuStats, pl.args.SafeVarianceMargin, pl.args.SafeVarianceSensitivity)
+		cpuScore = computeScore(logger, cpuStats, pl.args.SafeVarianceMargin, pl.args.SafeVarianceSensitivity)
 	}
-	klog.V(6).InfoS("Calculating CPUScore", "pod", klog.KObj(pod), "nodeName", nodeName, "cpuScore", cpuScore)
+	logger.V(6).Info("Calculating CPUScore", "pod", klog.KObj(pod), "nodeName", nodeName, "cpuScore", cpuScore)
 	// calculate Memory score
 	var memoryScore float64 = 0
-	memoryStats, memoryOK := trimaran.CreateResourceStats(metrics, node, podRequest, v1.ResourceMemory, watcher.Memory)
+	memoryStats, memoryOK := trimaran.CreateResourceStats(logger, metrics, node, podRequest, v1.ResourceMemory, watcher.Memory)
 	if memoryOK {
-		memoryScore = computeScore(memoryStats, pl.args.SafeVarianceMargin, pl.args.SafeVarianceSensitivity)
+		memoryScore = computeScore(logger, memoryStats, pl.args.SafeVarianceMargin, pl.args.SafeVarianceSensitivity)
 	}
-	klog.V(6).InfoS("Calculating MemoryScore", "pod", klog.KObj(pod), "nodeName", nodeName, "memoryScore", memoryScore)
+	logger.V(6).Info("Calculating MemoryScore", "pod", klog.KObj(pod), "nodeName", nodeName, "memoryScore", memoryScore)
 	// calculate total score
 	var totalScore float64 = 0
 	if memoryOK && cpuOK {
@@ -116,7 +118,7 @@ func (pl *LoadVariationRiskBalancing) Score(ctx context.Context, cycleState *fra
 		totalScore = math.Max(memoryScore, cpuScore)
 	}
 	score = int64(math.Round(totalScore))
-	klog.V(6).InfoS("Calculating totalScore", "pod", klog.KObj(pod), "nodeName", nodeName, "totalScore", score)
+	logger.V(6).Info("Calculating totalScore", "pod", klog.KObj(pod), "nodeName", nodeName, "totalScore", score)
 	return score, framework.NewStatus(framework.Success, "")
 }
 
diff --git a/pkg/trimaran/lowriskovercommitment/lowriskovercommitment.go b/pkg/trimaran/lowriskovercommitment/lowriskovercommitment.go
index bf8492b0..ba865154 100644
--- a/pkg/trimaran/lowriskovercommitment/lowriskovercommitment.go
+++ b/pkg/trimaran/lowriskovercommitment/lowriskovercommitment.go
@@ -45,7 +45,7 @@ const (
 	// MaxVarianceAllowance : allowed value from the maximum variance (to avoid zero divisions)
 	MaxVarianceAllowance = 0.99
 
-	// State key used in CycleState
+	// PodResourcesKey State key used in CycleState
 	PodResourcesKey = Name + ".PodResources"
 )
 
@@ -58,14 +58,15 @@ type LowRiskOverCommitment struct {
 }
 
 // New : create an instance of a LowRiskOverCommitment plugin
-func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
-	klog.V(4).InfoS("Creating new instance of the LowRiskOverCommitment plugin")
+func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+	logger := klog.FromContext(ctx)
+	logger.V(4).Info("Creating new instance of the LowRiskOverCommitment plugin")
 	// cast object into plugin arguments object
 	args, ok := obj.(*pluginConfig.LowRiskOverCommitmentArgs)
 	if !ok {
 		return nil, fmt.Errorf("want args to be of type LowRiskOverCommitmentArgs, got %T", obj)
 	}
-	collector, err := trimaran.NewCollector(&args.TrimaranSpec)
+	collector, err := trimaran.NewCollector(logger, &args.TrimaranSpec)
 	if err != nil {
 		return nil, err
 	}
@@ -76,7 +77,7 @@ func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framew
 	for r, w := range args.RiskLimitWeights {
 		m[r] = w
 	}
-	klog.V(4).InfoS("Using LowRiskOverCommitmentArgs", "smoothingWindowSize", args.SmoothingWindowSize,
+	logger.V(4).Info("Using LowRiskOverCommitmentArgs", "smoothingWindowSize", args.SmoothingWindowSize,
 		"riskLimitWeights", m)
 
 	pl := &LowRiskOverCommitment{
@@ -90,7 +91,8 @@ func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framew
 
 // PreScore : calculate pod requests and limits and store as plugin state data to be used during scoring
 func (pl *LowRiskOverCommitment) PreScore(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodes []*framework.NodeInfo) *framework.Status {
-	klog.V(6).InfoS("PreScore: Calculating pod resource requests and limits", "pod", klog.KObj(pod))
+	logger := klog.FromContext(ctx)
+	logger.V(6).Info("PreScore: Calculating pod resource requests and limits", "pod", klog.KObj(pod))
 	podResourcesStateData := CreatePodResourcesStateData(pod)
 	cycleState.Write(PodResourcesKey, podResourcesStateData)
 	return nil
@@ -98,18 +100,19 @@ func (pl *LowRiskOverCommitment) PreScore(ctx context.Context, cycleState *frame
 
 // Score : evaluate score for a node
 func (pl *LowRiskOverCommitment) Score(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
-	klog.V(6).InfoS("Score: Calculating score", "pod", klog.KObj(pod), "nodeName", nodeName)
+	logger := klog.FromContext(ctx)
+	logger.V(6).Info("Score: Calculating score", "pod", klog.KObj(pod), "nodeName", nodeName)
 	score := framework.MinNodeScore
 
 	defer func() {
-		klog.V(6).InfoS("Calculating totalScore", "pod", klog.KObj(pod), "nodeName", nodeName, "totalScore", score)
+		logger.V(6).Info("Calculating totalScore", "pod", klog.KObj(pod), "nodeName", nodeName, "totalScore", score)
 	}()
 
 	// get pod requests and limits
 	podResources, err := getPreScoreState(cycleState)
 	if err != nil {
 		// calculate pod requests and limits, if missing
-		klog.V(6).InfoS(err.Error()+"; recalculating", "pod", klog.KObj(pod))
+		logger.V(6).Info(err.Error()+"; recalculating", "pod", klog.KObj(pod))
 		podResources = CreatePodResourcesStateData(pod)
 	}
 	// exclude scoring for best effort pods; this plugin is not concerned about best effort pods
@@ -117,7 +120,7 @@ func (pl *LowRiskOverCommitment) Score(ctx context.Context, cycleState *framewor
 	podLimits := &podResources.podLimits
 	if podRequests.MilliCPU == 0 && podRequests.Memory == 0 &&
 		podLimits.MilliCPU == 0 && podLimits.Memory == 0 {
-		klog.V(6).InfoS("Skipping scoring best effort pod; using minimum score", "nodeName", nodeName, "pod", klog.KObj(pod))
+		logger.V(6).Info("Skipping scoring best effort pod; using minimum score", "nodeName", nodeName, "pod", klog.KObj(pod))
 		return score, nil
 	}
 	// get node info
@@ -126,13 +129,13 @@ func (pl *LowRiskOverCommitment) Score(ctx context.Context, cycleState *framewor
 		return score, framework.NewStatus(framework.Error, fmt.Sprintf("getting node %q from Snapshot: %v", nodeName, err))
 	}
 	// get node metrics
-	metrics, _ := pl.collector.GetNodeMetrics(nodeName)
+	metrics, _ := pl.collector.GetNodeMetrics(logger, nodeName)
 	if metrics == nil {
-		klog.InfoS("Failed to get metrics for node; using minimum score", "nodeName", nodeName)
+		logger.Info("Failed to get metrics for node; using minimum score", "nodeName", nodeName)
 		return score, nil
 	}
 	// calculate score
-	totalScore := pl.computeRank(metrics, nodeInfo, pod, podRequests, podLimits) * float64(framework.MaxNodeScore)
+	totalScore := pl.computeRank(logger, metrics, nodeInfo, pod, podRequests, podLimits) * float64(framework.MaxNodeScore)
 	score = int64(math.Round(totalScore))
 	return score, framework.NewStatus(framework.Success, "")
 }
@@ -153,27 +156,27 @@ func (pl *LowRiskOverCommitment) NormalizeScore(context.Context, *framework.Cycl
 }
 
 // computeRank : rank function for the LowRiskOverCommitment
-func (pl *LowRiskOverCommitment) computeRank(metrics []watcher.Metric, nodeInfo *framework.NodeInfo, pod *v1.Pod,
+func (pl *LowRiskOverCommitment) computeRank(logger klog.Logger, metrics []watcher.Metric, nodeInfo *framework.NodeInfo, pod *v1.Pod,
 	podRequests *framework.Resource, podLimits *framework.Resource) float64 {
 	node := nodeInfo.Node()
 	// calculate risk based on requests and limits
-	nodeRequestsAndLimits := trimaran.GetNodeRequestsAndLimits(nodeInfo.Pods, node, pod, podRequests, podLimits)
-	riskCPU := pl.computeRisk(metrics, v1.ResourceCPU, watcher.CPU, node, nodeRequestsAndLimits)
-	riskMemory := pl.computeRisk(metrics, v1.ResourceMemory, watcher.Memory, node, nodeRequestsAndLimits)
+	nodeRequestsAndLimits := trimaran.GetNodeRequestsAndLimits(logger, nodeInfo.Pods, node, pod, podRequests, podLimits)
+	riskCPU := pl.computeRisk(logger, metrics, v1.ResourceCPU, watcher.CPU, node, nodeRequestsAndLimits)
+	riskMemory := pl.computeRisk(logger, metrics, v1.ResourceMemory, watcher.Memory, node, nodeRequestsAndLimits)
 	rank := 1 - math.Max(riskCPU, riskMemory)
 
-	klog.V(6).InfoS("Node rank", "nodeName", node.GetName(), "riskCPU", riskCPU, "riskMemory", riskMemory, "rank", rank)
+	logger.V(6).Info("Node rank", "nodeName", node.GetName(), "riskCPU", riskCPU, "riskMemory", riskMemory, "rank", rank)
 
 	return rank
 }
 
 // computeRisk : calculate the risk of scheduling on node for a given resource
-func (pl *LowRiskOverCommitment) computeRisk(metrics []watcher.Metric, resourceName v1.ResourceName,
+func (pl *LowRiskOverCommitment) computeRisk(logger klog.Logger, metrics []watcher.Metric, resourceName v1.ResourceName,
 	resourceType string, node *v1.Node, nodeRequestsAndLimits *trimaran.NodeRequestsAndLimits) float64 {
 	var riskLimit, riskLoad, totalRisk float64
 
 	defer func() {
-		klog.V(6).InfoS("Calculated risk", "node", klog.KObj(node), "resource", resourceName,
+		logger.V(6).Info("Calculated risk", "node", klog.KObj(node), "resource", resourceName,
 			"riskLimit", riskLimit, "riskLoad", riskLoad, "totalRisk", totalRisk)
 	}()
 
@@ -198,7 +201,7 @@ func (pl *LowRiskOverCommitment) computeRisk(metrics []watcher.Metric, resourceN
 		capacity = nodeCapacity.Memory
 	} else {
 		// invalid resource
-		klog.V(6).InfoS("Unexpected resource", "resourceName", resourceName)
+		logger.V(6).Info("Unexpected resource", "resourceName", resourceName)
 		return 0
 	}
 
@@ -206,11 +209,11 @@ func (pl *LowRiskOverCommitment) computeRisk(metrics []watcher.Metric, resourceN
 	if limit > capacity {
 		riskLimit = float64(limit-capacity) / float64(limit-request)
 	}
-	klog.V(6).InfoS("RiskLimit", "node", klog.KObj(node), "resource", resourceName, "riskLimit", riskLimit)
+	logger.V(6).Info("RiskLimit", "node", klog.KObj(node), "resource", resourceName, "riskLimit", riskLimit)
 
 	// (2) riskLoad : calculate measured overcommitment
 	zeroRequest := &framework.Resource{}
-	stats, ok := trimaran.CreateResourceStats(metrics, node, zeroRequest, resourceName, resourceType)
+	stats, ok := trimaran.CreateResourceStats(logger, metrics, node, zeroRequest, resourceName, resourceType)
 	if ok {
 		// fit a beta distribution to the measured load stats
 		mu, sigma := trimaran.GetMuSigma(stats)
@@ -242,7 +245,7 @@ func (pl *LowRiskOverCommitment) computeRisk(metrics []watcher.Metric, resourceN
 
 		// calculate risk
 		riskLoad = 1 - allocProb
-		klog.V(6).InfoS("RiskLoad", "node", klog.KObj(node), "resource", resourceName,
+		logger.V(6).Info("RiskLoad", "node", klog.KObj(node), "resource", resourceName,
 			"allocThreshold", allocThreshold, "allocProb", allocProb, "riskLoad", riskLoad)
 	}
 
diff --git a/pkg/trimaran/resourcestats.go b/pkg/trimaran/resourcestats.go
index 71c28088..f02a49eb 100644
--- a/pkg/trimaran/resourcestats.go
+++ b/pkg/trimaran/resourcestats.go
@@ -43,12 +43,12 @@ type ResourceStats struct {
 }
 
 // CreateResourceStats : get resource statistics data from measurements for a node
-func CreateResourceStats(metrics []watcher.Metric, node *v1.Node, podRequest *framework.Resource,
+func CreateResourceStats(logger klog.Logger, metrics []watcher.Metric, node *v1.Node, podRequest *framework.Resource,
 	resourceName v1.ResourceName, watcherType string) (rs *ResourceStats, isValid bool) {
 	// get resource usage statistics
 	nodeUtil, nodeStd, metricFound := GetResourceData(metrics, watcherType)
 	if !metricFound {
-		klog.V(6).InfoS("Resource usage statistics for node : no valid data", "node", klog.KObj(node))
+		logger.V(6).Info("Resource usage statistics for node : no valid data", "node", klog.KObj(node))
 		return nil, false
 	}
 	// get resource capacity
@@ -69,7 +69,7 @@ func CreateResourceStats(metrics []watcher.Metric, node *v1.Node, podRequest *fr
 	rs.UsedAvg = nodeUtil * rs.Capacity / 100
 	rs.UsedStdev = nodeStd * rs.Capacity / 100
 
-	klog.V(6).InfoS("Resource usage statistics for node", "node", klog.KObj(node), "resource", resourceName,
+	logger.V(6).Info("Resource usage statistics for node", "node", klog.KObj(node), "resource", resourceName,
 		"capacity", rs.Capacity, "required", rs.Req, "usedAvg", rs.UsedAvg, "usedStdev", rs.UsedStdev)
 	return rs, true
 }
@@ -121,7 +121,7 @@ func GetResourceLimits(pod *v1.Pod) *framework.Resource {
 	})
 }
 
-// GetEffectiveResource: calculate effective resources of a pod (CPU and Memory)
+// GetEffectiveResource : calculate effective resources of a pod (CPU and Memory)
 func GetEffectiveResource(pod *v1.Pod, fn func(container *v1.Container) v1.ResourceList) *framework.Resource {
 	result := &framework.Resource{}
 	// add up resources of all containers
@@ -161,7 +161,7 @@ type NodeRequestsAndLimits struct {
 }
 
 // GetNodeRequestsAndLimits : total requested and limits of resources on a given node plus a pod
-func GetNodeRequestsAndLimits(podInfosOnNode []*framework.PodInfo, node *v1.Node, pod *v1.Pod,
+func GetNodeRequestsAndLimits(logger klog.Logger, podInfosOnNode []*framework.PodInfo, node *v1.Node, pod *v1.Pod,
 	podRequests *framework.Resource, podLimits *framework.Resource) *NodeRequestsAndLimits {
 	// initialization
 	nodeRequest := &framework.Resource{}
diff --git a/pkg/trimaran/targetloadpacking/targetloadpacking.go b/pkg/trimaran/targetloadpacking/targetloadpacking.go
index 2f7baf57..79e85f4c 100644
--- a/pkg/trimaran/targetloadpacking/targetloadpacking.go
+++ b/pkg/trimaran/targetloadpacking/targetloadpacking.go
@@ -61,14 +61,15 @@ type TargetLoadPacking struct {
 
 var _ framework.ScorePlugin = &TargetLoadPacking{}
 
-func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
-	klog.V(4).InfoS("Creating new instance of the TargetLoadPacking plugin")
+func New(ctx context.Context, obj runtime.Object, handle framework.Handle) (framework.Plugin, error) {
+	logger := klog.FromContext(ctx)
+	logger.V(4).Info("Creating new instance of the TargetLoadPacking plugin")
 	// cast object into plugin arguments object
 	args, ok := obj.(*pluginConfig.TargetLoadPackingArgs)
 	if !ok {
 		return nil, fmt.Errorf("want args to be of type TargetLoadPackingArgs, got %T", obj)
 	}
-	collector, err := trimaran.NewCollector(&args.TrimaranSpec)
+	collector, err := trimaran.NewCollector(logger, &args.TrimaranSpec)
 	if err != nil {
 		return nil, err
 	}
@@ -80,7 +81,7 @@ func New(_ context.Context, obj runtime.Object, handle framework.Handle) (framew
 		return nil, errors.New("unable to parse DefaultRequestsMultiplier: " + err.Error())
 	}
 
-	klog.V(4).InfoS("Using TargetLoadPackingArgs",
+	logger.V(4).Info("Using TargetLoadPackingArgs",
 		"requestsMilliCores", requestsMilliCores,
 		"requestsMultiplier", requestsMultiplier,
 		"targetUtilization", hostTargetUtilizationPercent)
@@ -102,6 +103,7 @@ func (pl *TargetLoadPacking) Name() string {
 }
 
 func (pl *TargetLoadPacking) Score(ctx context.Context, cycleState *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
+	logger := klog.FromContext(ctx)
 	score := framework.MinNodeScore
 	nodeInfo, err := pl.handle.SnapshotSharedLister().NodeInfos().Get(nodeName)
 	if err != nil {
@@ -109,7 +111,7 @@ func (pl *TargetLoadPacking) Score(ctx context.Context, cycleState *framework.Cy
 	}
 
 	// get node metrics
-	metrics, allMetrics := pl.collector.GetNodeMetrics(nodeName)
+	metrics, allMetrics := pl.collector.GetNodeMetrics(logger, nodeName)
 	if metrics == nil {
 		klog.InfoS("Failed to get metrics for node; using minimum score", "nodeName", nodeName)
 		// Avoid the node by scoring minimum
@@ -122,7 +124,7 @@ func (pl *TargetLoadPacking) Score(ctx context.Context, cycleState *framework.Cy
 	for _, container := range pod.Spec.Containers {
 		curPodCPUUsage += PredictUtilisation(&container)
 	}
-	klog.V(6).InfoS("Predicted utilization for pod", "podName", pod.Name, "cpuUsage", curPodCPUUsage)
+	logger.V(6).Info("Predicted utilization for pod", "podName", pod.Name, "cpuUsage", curPodCPUUsage)
 	if pod.Spec.Overhead != nil {
 		curPodCPUUsage += pod.Spec.Overhead.Cpu().MilliValue()
 	}
@@ -139,13 +141,13 @@ func (pl *TargetLoadPacking) Score(ctx context.Context, cycleState *framework.Cy
 	}
 
 	if !cpuMetricFound {
-		klog.ErrorS(nil, "Cpu metric not found in node metrics", "nodeName", nodeName, "nodeMetrics", metrics)
+		logger.Error(nil, "Cpu metric not found in node metrics", "nodeName", nodeName, "nodeMetrics", metrics)
 		return score, nil
 	}
 	nodeCPUCapMillis := float64(nodeInfo.Node().Status.Capacity.Cpu().MilliValue())
 	nodeCPUUtilMillis := (nodeCPUUtilPercent / 100) * nodeCPUCapMillis
 
-	klog.V(6).InfoS("Calculating CPU utilization and capacity", "nodeName", nodeName, "cpuUtilMillis", nodeCPUUtilMillis, "cpuCapMillis", nodeCPUCapMillis)
+	logger.V(6).Info("Calculating CPU utilization and capacity", "nodeName", nodeName, "cpuUtilMillis", nodeCPUUtilMillis, "cpuCapMillis", nodeCPUCapMillis)
 
 	var missingCPUUtilMillis int64 = 0
 	pl.eventHandler.RLock()
@@ -160,11 +162,11 @@ func (pl *TargetLoadPacking) Score(ctx context.Context, cycleState *framework.Cy
 				missingCPUUtilMillis += PredictUtilisation(&container)
 			}
 			missingCPUUtilMillis += info.Pod.Spec.Overhead.Cpu().MilliValue()
-			klog.V(6).InfoS("Missing utilization for pod", "podName", info.Pod.Name, "missingCPUUtilMillis", missingCPUUtilMillis)
+			logger.V(6).Info("Missing utilization for pod", "podName", info.Pod.Name, "missingCPUUtilMillis", missingCPUUtilMillis)
 		}
 	}
 	pl.eventHandler.RUnlock()
-	klog.V(6).InfoS("Missing utilization for node", "nodeName", nodeName, "missingCPUUtilMillis", missingCPUUtilMillis)
+	logger.V(6).Info("Missing utilization for node", "nodeName", nodeName, "missingCPUUtilMillis", missingCPUUtilMillis)
 
 	var predictedCPUUsage float64
 	if nodeCPUCapMillis != 0 {
@@ -175,13 +177,13 @@ func (pl *TargetLoadPacking) Score(ctx context.Context, cycleState *framework.Cy
 			return score, framework.NewStatus(framework.Success, "")
 		}
 		penalisedScore := int64(math.Round(float64(hostTargetUtilizationPercent) * (100 - predictedCPUUsage) / (100 - float64(hostTargetUtilizationPercent))))
-		klog.V(6).InfoS("Penalised score for host", "nodeName", nodeName, "penalisedScore", penalisedScore)
+		logger.V(6).Info("Penalised score for host", "nodeName", nodeName, "penalisedScore", penalisedScore)
 		return penalisedScore, framework.NewStatus(framework.Success, "")
 	}
 
 	score = int64(math.Round((100-float64(hostTargetUtilizationPercent))*
 		predictedCPUUsage/float64(hostTargetUtilizationPercent) + float64(hostTargetUtilizationPercent)))
-	klog.V(6).InfoS("Score for host", "nodeName", nodeName, "score", score)
+	logger.V(6).Info("Score for host", "nodeName", nodeName, "score", score)
 	return score, framework.NewStatus(framework.Success, "")
 }
 
diff --git a/vendor/go.opentelemetry.io/otel/metric/noop/noop.go b/vendor/go.opentelemetry.io/otel/metric/noop/noop.go
deleted file mode 100644
index acc9a670..00000000
--- a/vendor/go.opentelemetry.io/otel/metric/noop/noop.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright The OpenTelemetry Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package noop provides an implementation of the OpenTelemetry metric API that
-// produces no telemetry and minimizes used computation resources.
-//
-// Using this package to implement the OpenTelemetry metric API will
-// effectively disable OpenTelemetry.
-//
-// This implementation can be embedded in other implementations of the
-// OpenTelemetry metric API. Doing so will mean the implementation defaults to
-// no operation for methods it does not implement.
-package noop // import "go.opentelemetry.io/otel/metric/noop"
-
-import (
-	"context"
-
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/metric/embedded"
-)
-
-var (
-	// Compile-time check this implements the OpenTelemetry API.
-
-	_ metric.MeterProvider                  = MeterProvider{}
-	_ metric.Meter                          = Meter{}
-	_ metric.Observer                       = Observer{}
-	_ metric.Registration                   = Registration{}
-	_ metric.Int64Counter                   = Int64Counter{}
-	_ metric.Float64Counter                 = Float64Counter{}
-	_ metric.Int64UpDownCounter             = Int64UpDownCounter{}
-	_ metric.Float64UpDownCounter           = Float64UpDownCounter{}
-	_ metric.Int64Histogram                 = Int64Histogram{}
-	_ metric.Float64Histogram               = Float64Histogram{}
-	_ metric.Int64ObservableCounter         = Int64ObservableCounter{}
-	_ metric.Float64ObservableCounter       = Float64ObservableCounter{}
-	_ metric.Int64ObservableGauge           = Int64ObservableGauge{}
-	_ metric.Float64ObservableGauge         = Float64ObservableGauge{}
-	_ metric.Int64ObservableUpDownCounter   = Int64ObservableUpDownCounter{}
-	_ metric.Float64ObservableUpDownCounter = Float64ObservableUpDownCounter{}
-	_ metric.Int64Observer                  = Int64Observer{}
-	_ metric.Float64Observer                = Float64Observer{}
-)
-
-// MeterProvider is an OpenTelemetry No-Op MeterProvider.
-type MeterProvider struct{ embedded.MeterProvider }
-
-// NewMeterProvider returns a MeterProvider that does not record any telemetry.
-func NewMeterProvider() MeterProvider {
-	return MeterProvider{}
-}
-
-// Meter returns an OpenTelemetry Meter that does not record any telemetry.
-func (MeterProvider) Meter(string, ...metric.MeterOption) metric.Meter {
-	return Meter{}
-}
-
-// Meter is an OpenTelemetry No-Op Meter.
-type Meter struct{ embedded.Meter }
-
-// Int64Counter returns a Counter used to record int64 measurements that
-// produces no telemetry.
-func (Meter) Int64Counter(string, ...metric.Int64CounterOption) (metric.Int64Counter, error) {
-	return Int64Counter{}, nil
-}
-
-// Int64UpDownCounter returns an UpDownCounter used to record int64
-// measurements that produces no telemetry.
-func (Meter) Int64UpDownCounter(string, ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error) {
-	return Int64UpDownCounter{}, nil
-}
-
-// Int64Histogram returns a Histogram used to record int64 measurements that
-// produces no telemetry.
-func (Meter) Int64Histogram(string, ...metric.Int64HistogramOption) (metric.Int64Histogram, error) {
-	return Int64Histogram{}, nil
-}
-
-// Int64ObservableCounter returns an ObservableCounter used to record int64
-// measurements that produces no telemetry.
-func (Meter) Int64ObservableCounter(string, ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error) {
-	return Int64ObservableCounter{}, nil
-}
-
-// Int64ObservableUpDownCounter returns an ObservableUpDownCounter used to
-// record int64 measurements that produces no telemetry.
-func (Meter) Int64ObservableUpDownCounter(string, ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error) {
-	return Int64ObservableUpDownCounter{}, nil
-}
-
-// Int64ObservableGauge returns an ObservableGauge used to record int64
-// measurements that produces no telemetry.
-func (Meter) Int64ObservableGauge(string, ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error) {
-	return Int64ObservableGauge{}, nil
-}
-
-// Float64Counter returns a Counter used to record int64 measurements that
-// produces no telemetry.
-func (Meter) Float64Counter(string, ...metric.Float64CounterOption) (metric.Float64Counter, error) {
-	return Float64Counter{}, nil
-}
-
-// Float64UpDownCounter returns an UpDownCounter used to record int64
-// measurements that produces no telemetry.
-func (Meter) Float64UpDownCounter(string, ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error) {
-	return Float64UpDownCounter{}, nil
-}
-
-// Float64Histogram returns a Histogram used to record int64 measurements that
-// produces no telemetry.
-func (Meter) Float64Histogram(string, ...metric.Float64HistogramOption) (metric.Float64Histogram, error) {
-	return Float64Histogram{}, nil
-}
-
-// Float64ObservableCounter returns an ObservableCounter used to record int64
-// measurements that produces no telemetry.
-func (Meter) Float64ObservableCounter(string, ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error) {
-	return Float64ObservableCounter{}, nil
-}
-
-// Float64ObservableUpDownCounter returns an ObservableUpDownCounter used to
-// record int64 measurements that produces no telemetry.
-func (Meter) Float64ObservableUpDownCounter(string, ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error) {
-	return Float64ObservableUpDownCounter{}, nil
-}
-
-// Float64ObservableGauge returns an ObservableGauge used to record int64
-// measurements that produces no telemetry.
-func (Meter) Float64ObservableGauge(string, ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error) {
-	return Float64ObservableGauge{}, nil
-}
-
-// RegisterCallback performs no operation.
-func (Meter) RegisterCallback(metric.Callback, ...metric.Observable) (metric.Registration, error) {
-	return Registration{}, nil
-}
-
-// Observer acts as a recorder of measurements for multiple instruments in a
-// Callback, it performing no operation.
-type Observer struct{ embedded.Observer }
-
-// ObserveFloat64 performs no operation.
-func (Observer) ObserveFloat64(metric.Float64Observable, float64, ...metric.ObserveOption) {
-}
-
-// ObserveInt64 performs no operation.
-func (Observer) ObserveInt64(metric.Int64Observable, int64, ...metric.ObserveOption) {
-}
-
-// Registration is the registration of a Callback with a No-Op Meter.
-type Registration struct{ embedded.Registration }
-
-// Unregister unregisters the Callback the Registration represents with the
-// No-Op Meter. This will always return nil because the No-Op Meter performs no
-// operation, including hold any record of registrations.
-func (Registration) Unregister() error { return nil }
-
-// Int64Counter is an OpenTelemetry Counter used to record int64 measurements.
-// It produces no telemetry.
-type Int64Counter struct{ embedded.Int64Counter }
-
-// Add performs no operation.
-func (Int64Counter) Add(context.Context, int64, ...metric.AddOption) {}
-
-// Float64Counter is an OpenTelemetry Counter used to record float64
-// measurements. It produces no telemetry.
-type Float64Counter struct{ embedded.Float64Counter }
-
-// Add performs no operation.
-func (Float64Counter) Add(context.Context, float64, ...metric.AddOption) {}
-
-// Int64UpDownCounter is an OpenTelemetry UpDownCounter used to record int64
-// measurements. It produces no telemetry.
-type Int64UpDownCounter struct{ embedded.Int64UpDownCounter }
-
-// Add performs no operation.
-func (Int64UpDownCounter) Add(context.Context, int64, ...metric.AddOption) {}
-
-// Float64UpDownCounter is an OpenTelemetry UpDownCounter used to record
-// float64 measurements. It produces no telemetry.
-type Float64UpDownCounter struct{ embedded.Float64UpDownCounter }
-
-// Add performs no operation.
-func (Float64UpDownCounter) Add(context.Context, float64, ...metric.AddOption) {}
-
-// Int64Histogram is an OpenTelemetry Histogram used to record int64
-// measurements. It produces no telemetry.
-type Int64Histogram struct{ embedded.Int64Histogram }
-
-// Record performs no operation.
-func (Int64Histogram) Record(context.Context, int64, ...metric.RecordOption) {}
-
-// Float64Histogram is an OpenTelemetry Histogram used to record float64
-// measurements. It produces no telemetry.
-type Float64Histogram struct{ embedded.Float64Histogram }
-
-// Record performs no operation.
-func (Float64Histogram) Record(context.Context, float64, ...metric.RecordOption) {}
-
-// Int64ObservableCounter is an OpenTelemetry ObservableCounter used to record
-// int64 measurements. It produces no telemetry.
-type Int64ObservableCounter struct {
-	metric.Int64Observable
-	embedded.Int64ObservableCounter
-}
-
-// Float64ObservableCounter is an OpenTelemetry ObservableCounter used to record
-// float64 measurements. It produces no telemetry.
-type Float64ObservableCounter struct {
-	metric.Float64Observable
-	embedded.Float64ObservableCounter
-}
-
-// Int64ObservableGauge is an OpenTelemetry ObservableGauge used to record
-// int64 measurements. It produces no telemetry.
-type Int64ObservableGauge struct {
-	metric.Int64Observable
-	embedded.Int64ObservableGauge
-}
-
-// Float64ObservableGauge is an OpenTelemetry ObservableGauge used to record
-// float64 measurements. It produces no telemetry.
-type Float64ObservableGauge struct {
-	metric.Float64Observable
-	embedded.Float64ObservableGauge
-}
-
-// Int64ObservableUpDownCounter is an OpenTelemetry ObservableUpDownCounter
-// used to record int64 measurements. It produces no telemetry.
-type Int64ObservableUpDownCounter struct {
-	metric.Int64Observable
-	embedded.Int64ObservableUpDownCounter
-}
-
-// Float64ObservableUpDownCounter is an OpenTelemetry ObservableUpDownCounter
-// used to record float64 measurements. It produces no telemetry.
-type Float64ObservableUpDownCounter struct {
-	metric.Float64Observable
-	embedded.Float64ObservableUpDownCounter
-}
-
-// Int64Observer is a recorder of int64 measurements that performs no operation.
-type Int64Observer struct{ embedded.Int64Observer }
-
-// Observe performs no operation.
-func (Int64Observer) Observe(int64, ...metric.ObserveOption) {}
-
-// Float64Observer is a recorder of float64 measurements that performs no
-// operation.
-type Float64Observer struct{ embedded.Float64Observer }
-
-// Observe performs no operation.
-func (Float64Observer) Observe(float64, ...metric.ObserveOption) {}
diff --git a/vendor/k8s.io/api/core/v1/generated.proto b/vendor/k8s.io/api/core/v1/generated.proto
index 9ebc9b91..f3b47c72 100644
--- a/vendor/k8s.io/api/core/v1/generated.proto
+++ b/vendor/k8s.io/api/core/v1/generated.proto
@@ -1997,7 +1997,6 @@ message HostAlias {
 // HostIP represents a single IP address allocated to the host.
 message HostIP {
   // IP is the IP address assigned to the host
-  // +required
   optional string ip = 1;
 }
 
@@ -3694,7 +3693,6 @@ message PodExecOptions {
 // PodIP represents a single IP address allocated to the pod.
 message PodIP {
   // IP is the IP address assigned to the pod
-  // +required
   optional string ip = 1;
 }
 
diff --git a/vendor/k8s.io/api/core/v1/types.go b/vendor/k8s.io/api/core/v1/types.go
index d5eca377..328df9a7 100644
--- a/vendor/k8s.io/api/core/v1/types.go
+++ b/vendor/k8s.io/api/core/v1/types.go
@@ -4340,15 +4340,13 @@ type PodDNSConfigOption struct {
 // PodIP represents a single IP address allocated to the pod.
 type PodIP struct {
 	// IP is the IP address assigned to the pod
-	// +required
-	IP string `json:"ip" protobuf:"bytes,1,opt,name=ip"`
+	IP string `json:"ip,omitempty" protobuf:"bytes,1,opt,name=ip"`
 }
 
 // HostIP represents a single IP address allocated to the host.
 type HostIP struct {
 	// IP is the IP address assigned to the host
-	// +required
-	IP string `json:"ip" protobuf:"bytes,1,opt,name=ip"`
+	IP string `json:"ip,omitempty" protobuf:"bytes,1,opt,name=ip"`
 }
 
 // EphemeralContainerCommon is a copy of all fields in Container to be inlined in
diff --git a/vendor/k8s.io/apiserver/pkg/server/options/tracing.go b/vendor/k8s.io/apiserver/pkg/server/options/tracing.go
index 7be62fad..d56e7df5 100644
--- a/vendor/k8s.io/apiserver/pkg/server/options/tracing.go
+++ b/vendor/k8s.io/apiserver/pkg/server/options/tracing.go
@@ -23,9 +23,7 @@ import (
 	"net"
 
 	"github.com/spf13/pflag"
-	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-	"go.opentelemetry.io/otel/metric/noop"
 	"go.opentelemetry.io/otel/sdk/resource"
 	"go.opentelemetry.io/otel/semconv/v1.12.0"
 	"google.golang.org/grpc"
@@ -50,12 +48,6 @@ var (
 	codecs    = serializer.NewCodecFactory(cfgScheme)
 )
 
-func init() {
-	// Prevent memory leak from OTel metrics, which we don't use:
-	// https://github.com/open-telemetry/opentelemetry-go-contrib/issues/5190
-	otel.SetMeterProvider(noop.NewMeterProvider())
-}
-
 func init() {
 	install.Install(cfgScheme)
 }
diff --git a/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go b/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go
index 5cc22c97..47bfb44e 100644
--- a/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go
+++ b/vendor/k8s.io/client-go/applyconfigurations/internal/internal.go
@@ -5661,7 +5661,6 @@ var schemaYAML = typed.YAMLObject(`types:
     - name: ip
       type:
         scalar: string
-      default: ""
 - name: io.k8s.api.core.v1.HostPathVolumeSource
   map:
     fields:
@@ -6748,7 +6747,6 @@ var schemaYAML = typed.YAMLObject(`types:
     - name: ip
       type:
         scalar: string
-      default: ""
 - name: io.k8s.api.core.v1.PodOS
   map:
     fields:
diff --git a/vendor/k8s.io/code-generator/tools.go b/vendor/k8s.io/code-generator/tools.go
index 4080b2c5..d0e2c776 100644
--- a/vendor/k8s.io/code-generator/tools.go
+++ b/vendor/k8s.io/code-generator/tools.go
@@ -31,5 +31,4 @@ import (
 	_ "k8s.io/code-generator/cmd/informer-gen"
 	_ "k8s.io/code-generator/cmd/lister-gen"
 	_ "k8s.io/code-generator/cmd/register-gen"
-	_ "k8s.io/kube-openapi/cmd/openapi-gen"
 )
diff --git a/vendor/k8s.io/kube-openapi/cmd/openapi-gen/args/args.go b/vendor/k8s.io/kube-openapi/cmd/openapi-gen/args/args.go
deleted file mode 100644
index 153784ed..00000000
--- a/vendor/k8s.io/kube-openapi/cmd/openapi-gen/args/args.go
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package args
-
-import (
-	"fmt"
-
-	"github.com/spf13/pflag"
-)
-
-type Args struct {
-	OutputDir  string // must be a directory path
-	OutputPkg  string // must be a Go import-path
-	OutputFile string
-
-	GoHeaderFile string
-
-	// ReportFilename is added to Args for specifying name of report file used
-	// by API linter. If specified, API rule violations will be printed to report file.
-	// Otherwise default value "-" will be used which indicates stdout.
-	ReportFilename string
-}
-
-// New returns default arguments for the generator. Returning the arguments instead
-// of using default flag parsing allows registering custom arguments afterwards
-func New() *Args {
-	args := &Args{}
-
-	// Default value for report filename is "-", which stands for stdout
-	args.ReportFilename = "-"
-
-	return args
-}
-
-// AddFlags add the generator flags to the flag set.
-func (args *Args) AddFlags(fs *pflag.FlagSet) {
-	fs.StringVar(&args.OutputDir, "output-dir", "",
-		"the base directory under which to generate results")
-	fs.StringVar(&args.OutputPkg, "output-pkg", "",
-		"the base Go import-path under which to generate results")
-	fs.StringVar(&args.OutputFile, "output-file", "generated.openapi.go",
-		"the name of the file to be generated")
-	fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
-		"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
-	fs.StringVarP(&args.ReportFilename, "report-filename", "r", args.ReportFilename,
-		"Name of report file used by API linter to print API violations. Default \"-\" stands for standard output. NOTE that if valid filename other than \"-\" is specified, API linter won't return error on detected API violations. This allows further check of existing API violations without stopping the OpenAPI generation toolchain.")
-}
-
-// Validate checks the given arguments.
-func (args *Args) Validate() error {
-	if len(args.OutputDir) == 0 {
-		return fmt.Errorf("--output-dir must be specified")
-	}
-	if len(args.OutputPkg) == 0 {
-		return fmt.Errorf("--output-pkg must be specified")
-	}
-	if len(args.OutputFile) == 0 {
-		return fmt.Errorf("--output-file must be specified")
-	}
-	if len(args.ReportFilename) == 0 {
-		return fmt.Errorf("--report-filename must be specified (use \"-\" for stdout)")
-	}
-	return nil
-}
diff --git a/vendor/k8s.io/kube-openapi/cmd/openapi-gen/openapi-gen.go b/vendor/k8s.io/kube-openapi/cmd/openapi-gen/openapi-gen.go
deleted file mode 100644
index b466019a..00000000
--- a/vendor/k8s.io/kube-openapi/cmd/openapi-gen/openapi-gen.go
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// This package generates openAPI definition file to be used in open API spec generation on API servers. To generate
-// definition for a specific type or package add "+k8s:openapi-gen=true" tag to the type/package comment lines. To
-// exclude a type from a tagged package, add "+k8s:openapi-gen=false" tag to the type comment lines.
-
-package main
-
-import (
-	"flag"
-	"log"
-
-	"github.com/spf13/pflag"
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/generator"
-	"k8s.io/klog/v2"
-	"k8s.io/kube-openapi/cmd/openapi-gen/args"
-	"k8s.io/kube-openapi/pkg/generators"
-)
-
-func main() {
-	klog.InitFlags(nil)
-	args := args.New()
-
-	args.AddFlags(pflag.CommandLine)
-	flag.Set("logtostderr", "true")
-	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
-	pflag.Parse()
-
-	if err := args.Validate(); err != nil {
-		log.Fatalf("Arguments validation error: %v", err)
-	}
-
-	myTargets := func(context *generator.Context) []generator.Target {
-		return generators.GetTargets(context, args)
-	}
-
-	// Generates the code for the OpenAPIDefinitions.
-	if err := gengo.Execute(
-		generators.NameSystems(),
-		generators.DefaultNameSystem(),
-		myTargets,
-		gengo.StdBuildTag,
-		pflag.Args(),
-	); err != nil {
-		log.Fatalf("OpenAPI code generation error: %v", err)
-	}
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/README.md b/vendor/k8s.io/kube-openapi/pkg/generators/README.md
deleted file mode 100644
index 72b4e5fb..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/README.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Generate OpenAPI definitions
-
-- To generate definition for a specific type or package add "+k8s:openapi-gen=true" tag to the type/package comment lines.
-- To exclude a type or a member from a tagged package/type, add "+k8s:openapi-gen=false" tag to the comment lines.
-
-# OpenAPI Extensions
-
-OpenAPI spec can have extensions on types. To define one or more extensions on a type or its member
-add `+k8s:openapi-gen=x-kubernetes-$NAME:$VALUE` to the comment lines before type/member. A type/member can
-have multiple extensions. The rest of the line in the comment will be used as $VALUE so there is no need to
-escape or quote the value string. Extensions can be used to pass more information to client generators or
-documentation generators. For example a type might have a friendly name to be displayed in documentation or
-being used in a client's fluent interface.
-
-# Custom OpenAPI type definitions
-
-Custom types which otherwise don't map directly to OpenAPI can override their
-OpenAPI definition by implementing a function named "OpenAPIDefinition" with
-the following signature:
-
-```go
-	import openapi "k8s.io/kube-openapi/pkg/common"
-
-	// ...
-
-	type Time struct {
-		time.Time
-	}
-
-	func (_ Time) OpenAPIDefinition() openapi.OpenAPIDefinition {
-		return openapi.OpenAPIDefinition{
-			Schema: spec.Schema{
-				SchemaProps: spec.SchemaProps{
-					Type:   []string{"string"},
-					Format: "date-time",
-				},
-			},
-		}
-	}
-```
-
-Alternatively, the type can avoid the "openapi" import by defining the following
-methods. The following example produces the same OpenAPI definition as the
-example above:
-
-```go
-    func (_ Time) OpenAPISchemaType() []string { return []string{"string"} }
-    func (_ Time) OpenAPISchemaFormat() string { return "date-time" }
-```
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/api_linter.go b/vendor/k8s.io/kube-openapi/pkg/generators/api_linter.go
deleted file mode 100644
index 5deff4d5..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/api_linter.go
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"sort"
-
-	"k8s.io/kube-openapi/pkg/generators/rules"
-
-	"k8s.io/gengo/v2/generator"
-	"k8s.io/gengo/v2/types"
-	"k8s.io/klog/v2"
-)
-
-const apiViolationFileType = "api-violation"
-
-type apiViolationFile struct {
-	// Since our file actually is unrelated to the package structure, use a
-	// path that hasn't been mangled by the framework.
-	unmangledPath string
-}
-
-func (a apiViolationFile) AssembleFile(f *generator.File, path string) error {
-	path = a.unmangledPath
-	klog.V(2).Infof("Assembling file %q", path)
-	if path == "-" {
-		_, err := io.Copy(os.Stdout, &f.Body)
-		return err
-	}
-
-	output, err := os.Create(path)
-	if err != nil {
-		return err
-	}
-	defer output.Close()
-	_, err = io.Copy(output, &f.Body)
-	return err
-}
-
-func (a apiViolationFile) VerifyFile(f *generator.File, path string) error {
-	if path == "-" {
-		// Nothing to verify against.
-		return nil
-	}
-	path = a.unmangledPath
-
-	formatted := f.Body.Bytes()
-	existing, err := os.ReadFile(path)
-	if err != nil {
-		return fmt.Errorf("unable to read file %q for comparison: %v", path, err)
-	}
-	if bytes.Compare(formatted, existing) == 0 {
-		return nil
-	}
-
-	// Be nice and find the first place where they differ
-	// (Copied from gengo's default file type)
-	i := 0
-	for i < len(formatted) && i < len(existing) && formatted[i] == existing[i] {
-		i++
-	}
-	eDiff, fDiff := existing[i:], formatted[i:]
-	if len(eDiff) > 100 {
-		eDiff = eDiff[:100]
-	}
-	if len(fDiff) > 100 {
-		fDiff = fDiff[:100]
-	}
-	return fmt.Errorf("output for %q differs; first existing/expected diff: \n  %q\n  %q", path, string(eDiff), string(fDiff))
-}
-
-func newAPIViolationGen() *apiViolationGen {
-	return &apiViolationGen{
-		linter: newAPILinter(),
-	}
-}
-
-type apiViolationGen struct {
-	generator.GoGenerator
-
-	linter *apiLinter
-}
-
-func (v *apiViolationGen) FileType() string { return apiViolationFileType }
-func (v *apiViolationGen) Filename() string {
-	return "this file is ignored by the file assembler"
-}
-
-func (v *apiViolationGen) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
-	klog.V(5).Infof("validating API rules for type %v", t)
-	if err := v.linter.validate(t); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Finalize prints the API rule violations to report file (if specified from
-// arguments) or stdout (default)
-func (v *apiViolationGen) Finalize(c *generator.Context, w io.Writer) error {
-	// NOTE: we don't return error here because we assume that the report file will
-	// get evaluated afterwards to determine if error should be raised. For example,
-	// you can have make rules that compare the report file with existing known
-	// violations (whitelist) and determine no error if no change is detected.
-	v.linter.report(w)
-	return nil
-}
-
-// apiLinter is the framework hosting multiple API rules and recording API rule
-// violations
-type apiLinter struct {
-	// API rules that implement APIRule interface and output API rule violations
-	rules      []APIRule
-	violations []apiViolation
-}
-
-// newAPILinter creates an apiLinter object with API rules in package rules. Please
-// add APIRule here when new API rule is implemented.
-func newAPILinter() *apiLinter {
-	return &apiLinter{
-		rules: []APIRule{
-			&rules.NamesMatch{},
-			&rules.OmitEmptyMatchCase{},
-			&rules.ListTypeMissing{},
-		},
-	}
-}
-
-// apiViolation uniquely identifies single API rule violation
-type apiViolation struct {
-	// Name of rule from APIRule.Name()
-	rule string
-
-	packageName string
-	typeName    string
-
-	// Optional: name of field that violates API rule. Empty fieldName implies that
-	// the entire type violates the rule.
-	field string
-}
-
-// apiViolations implements sort.Interface for []apiViolation based on the fields: rule,
-// packageName, typeName and field.
-type apiViolations []apiViolation
-
-func (a apiViolations) Len() int      { return len(a) }
-func (a apiViolations) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a apiViolations) Less(i, j int) bool {
-	if a[i].rule != a[j].rule {
-		return a[i].rule < a[j].rule
-	}
-	if a[i].packageName != a[j].packageName {
-		return a[i].packageName < a[j].packageName
-	}
-	if a[i].typeName != a[j].typeName {
-		return a[i].typeName < a[j].typeName
-	}
-	return a[i].field < a[j].field
-}
-
-// APIRule is the interface for validating API rule on Go types
-type APIRule interface {
-	// Validate evaluates API rule on type t and returns a list of field names in
-	// the type that violate the rule. Empty field name [""] implies the entire
-	// type violates the rule.
-	Validate(t *types.Type) ([]string, error)
-
-	// Name returns the name of APIRule
-	Name() string
-}
-
-// validate runs all API rules on type t and records any API rule violation
-func (l *apiLinter) validate(t *types.Type) error {
-	for _, r := range l.rules {
-		klog.V(5).Infof("validating API rule %v for type %v", r.Name(), t)
-		fields, err := r.Validate(t)
-		if err != nil {
-			return err
-		}
-		for _, field := range fields {
-			l.violations = append(l.violations, apiViolation{
-				rule:        r.Name(),
-				packageName: t.Name.Package,
-				typeName:    t.Name.Name,
-				field:       field,
-			})
-		}
-	}
-	return nil
-}
-
-// report prints any API rule violation to writer w and returns error if violation exists
-func (l *apiLinter) report(w io.Writer) error {
-	sort.Sort(apiViolations(l.violations))
-	for _, v := range l.violations {
-		fmt.Fprintf(w, "API rule violation: %s,%s,%s,%s\n", v.rule, v.packageName, v.typeName, v.field)
-	}
-	if len(l.violations) > 0 {
-		return fmt.Errorf("API rule violations exist")
-	}
-	return nil
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/config.go b/vendor/k8s.io/kube-openapi/pkg/generators/config.go
deleted file mode 100644
index 1fbd7759..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/config.go
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"path"
-
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/generator"
-	"k8s.io/gengo/v2/namer"
-	"k8s.io/gengo/v2/types"
-	"k8s.io/klog/v2"
-	"k8s.io/kube-openapi/cmd/openapi-gen/args"
-)
-
-type identityNamer struct{}
-
-func (_ identityNamer) Name(t *types.Type) string {
-	return t.Name.String()
-}
-
-var _ namer.Namer = identityNamer{}
-
-// NameSystems returns the name system used by the generators in this package.
-func NameSystems() namer.NameSystems {
-	return namer.NameSystems{
-		"raw":           namer.NewRawNamer("", nil),
-		"sorting_namer": identityNamer{},
-	}
-}
-
-// DefaultNameSystem returns the default name system for ordering the types to be
-// processed by the generators in this package.
-func DefaultNameSystem() string {
-	return "sorting_namer"
-}
-
-func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
-	boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
-	if err != nil {
-		klog.Fatalf("Failed loading boilerplate: %v", err)
-	}
-
-	reportPath := "-"
-	if args.ReportFilename != "" {
-		reportPath = args.ReportFilename
-	}
-	context.FileTypes[apiViolationFileType] = apiViolationFile{
-		unmangledPath: reportPath,
-	}
-
-	return []generator.Target{
-		&generator.SimpleTarget{
-			PkgName:       path.Base(args.OutputPkg), // `path` vs. `filepath` because packages use '/'
-			PkgPath:       args.OutputPkg,
-			PkgDir:        args.OutputDir,
-			HeaderComment: boilerplate,
-			GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
-				return []generator.Generator{
-					newOpenAPIGen(
-						args.OutputFile,
-						args.OutputPkg,
-					),
-					newAPIViolationGen(),
-				}
-			},
-			FilterFunc: apiTypeFilterFunc,
-		},
-	}
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/enum.go b/vendor/k8s.io/kube-openapi/pkg/generators/enum.go
deleted file mode 100644
index 3db034d6..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/enum.go
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
-Copyright 2021 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"fmt"
-	"regexp"
-	"sort"
-	"strings"
-
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/generator"
-	"k8s.io/gengo/v2/types"
-)
-
-const tagEnumType = "enum"
-const enumTypeDescriptionHeader = "Possible enum values:"
-
-type enumValue struct {
-	Name    string
-	Value   string
-	Comment string
-}
-
-type enumType struct {
-	Name   types.Name
-	Values []*enumValue
-}
-
-// enumMap is a map from the name to the matching enum type.
-type enumMap map[types.Name]*enumType
-
-type enumContext struct {
-	enumTypes enumMap
-}
-
-func newEnumContext(c *generator.Context) *enumContext {
-	return &enumContext{enumTypes: parseEnums(c)}
-}
-
-// EnumType checks and finds the enumType for a given type.
-// If the given type is a known enum type, returns the enumType, true
-// Otherwise, returns nil, false
-func (ec *enumContext) EnumType(t *types.Type) (enum *enumType, isEnum bool) {
-	// if t is a pointer, use its underlying type instead
-	if t.Kind == types.Pointer {
-		t = t.Elem
-	}
-	enum, ok := ec.enumTypes[t.Name]
-	return enum, ok
-}
-
-// ValueStrings returns all possible values of the enum type as strings
-// the results are sorted and quoted as Go literals.
-func (et *enumType) ValueStrings() []string {
-	var values []string
-	for _, value := range et.Values {
-		// use "%q" format to generate a Go literal of the string const value
-		values = append(values, fmt.Sprintf("%q", value.Value))
-	}
-	sort.Strings(values)
-	return values
-}
-
-// DescriptionLines returns a description of the enum in this format:
-//
-// Possible enum values:
-//   - `"value1"` description 1
-//   - `"value2"` description 2
-func (et *enumType) DescriptionLines() []string {
-	if len(et.Values) == 0 {
-		return nil
-	}
-	var lines []string
-	for _, value := range et.Values {
-		lines = append(lines, value.Description())
-	}
-	sort.Strings(lines)
-	// Prepend an empty string to initiate a new paragraph.
-	return append([]string{"", enumTypeDescriptionHeader}, lines...)
-}
-
-func parseEnums(c *generator.Context) enumMap {
-	// First, find the builtin "string" type
-	stringType := c.Universe.Type(types.Name{Name: "string"})
-
-	// find all enum types.
-	enumTypes := make(enumMap)
-	for _, p := range c.Universe {
-		for _, t := range p.Types {
-			if isEnumType(stringType, t) {
-				if _, ok := enumTypes[t.Name]; !ok {
-					enumTypes[t.Name] = &enumType{
-						Name: t.Name,
-					}
-				}
-			}
-		}
-	}
-
-	// find all enum values from constants, and try to match each with its type.
-	for _, p := range c.Universe {
-		for _, c := range p.Constants {
-			enumType := c.Underlying
-			if _, ok := enumTypes[enumType.Name]; ok {
-				value := &enumValue{
-					Name:    c.Name.Name,
-					Value:   *c.ConstValue,
-					Comment: strings.Join(c.CommentLines, " "),
-				}
-				enumTypes[enumType.Name].addIfNotPresent(value)
-			}
-		}
-	}
-
-	return enumTypes
-}
-
-func (et *enumType) addIfNotPresent(value *enumValue) {
-	// If we already have an enum case with the same value, then ignore this new
-	// one. This can happen if an enum aliases one from another package and
-	// re-exports the cases.
-	for i, existing := range et.Values {
-		if existing.Value == value.Value {
-
-			// Take the value of the longer comment (or some other deterministic tie breaker)
-			if len(existing.Comment) < len(value.Comment) || (len(existing.Comment) == len(value.Comment) && existing.Comment > value.Comment) {
-				et.Values[i] = value
-			}
-
-			return
-		}
-	}
-	et.Values = append(et.Values, value)
-}
-
-// Description returns the description line for the enumValue
-// with the format:
-//   - `"FooValue"` is the Foo value
-func (ev *enumValue) Description() string {
-	comment := strings.TrimSpace(ev.Comment)
-	// The comment should starts with the type name, trim it first.
-	comment = strings.TrimPrefix(comment, ev.Name)
-	// Trim the possible space after previous step.
-	comment = strings.TrimSpace(comment)
-	// The comment may be multiline, cascade all consecutive whitespaces.
-	comment = whitespaceRegex.ReplaceAllString(comment, " ")
-	return fmt.Sprintf(" - `%q` %s", ev.Value, comment)
-}
-
-// isEnumType checks if a given type is an enum by the definition
-// An enum type should be an alias of string and has tag '+enum' in its comment.
-// Additionally, pass the type of builtin 'string' to check against.
-func isEnumType(stringType *types.Type, t *types.Type) bool {
-	return t.Kind == types.Alias && t.Underlying == stringType && hasEnumTag(t)
-}
-
-func hasEnumTag(t *types.Type) bool {
-	return gengo.ExtractCommentTags("+", t.CommentLines)[tagEnumType] != nil
-}
-
-// whitespaceRegex is the regex for consecutive whitespaces.
-var whitespaceRegex = regexp.MustCompile(`\s+`)
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/extension.go b/vendor/k8s.io/kube-openapi/pkg/generators/extension.go
deleted file mode 100644
index 42d38541..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/extension.go
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/types"
-	"k8s.io/kube-openapi/pkg/util/sets"
-)
-
-const extensionPrefix = "x-kubernetes-"
-
-// extensionAttributes encapsulates common traits for particular extensions.
-type extensionAttributes struct {
-	xName         string
-	kind          types.Kind
-	allowedValues sets.String
-	enforceArray  bool
-}
-
-// Extension tag to openapi extension attributes
-var tagToExtension = map[string]extensionAttributes{
-	"patchMergeKey": {
-		xName: "x-kubernetes-patch-merge-key",
-		kind:  types.Slice,
-	},
-	"patchStrategy": {
-		xName:         "x-kubernetes-patch-strategy",
-		kind:          types.Slice,
-		allowedValues: sets.NewString("merge", "retainKeys"),
-	},
-	"listMapKey": {
-		xName:        "x-kubernetes-list-map-keys",
-		kind:         types.Slice,
-		enforceArray: true,
-	},
-	"listType": {
-		xName:         "x-kubernetes-list-type",
-		kind:          types.Slice,
-		allowedValues: sets.NewString("atomic", "set", "map"),
-	},
-	"mapType": {
-		xName:         "x-kubernetes-map-type",
-		kind:          types.Map,
-		allowedValues: sets.NewString("atomic", "granular"),
-	},
-	"structType": {
-		xName:         "x-kubernetes-map-type",
-		kind:          types.Struct,
-		allowedValues: sets.NewString("atomic", "granular"),
-	},
-	"validations": {
-		xName: "x-kubernetes-validations",
-		kind:  types.Slice,
-	},
-}
-
-// Extension encapsulates information necessary to generate an OpenAPI extension.
-type extension struct {
-	idlTag string   // Example: listType
-	xName  string   // Example: x-kubernetes-list-type
-	values []string // Example: [atomic]
-}
-
-func (e extension) hasAllowedValues() bool {
-	return tagToExtension[e.idlTag].allowedValues.Len() > 0
-}
-
-func (e extension) allowedValues() sets.String {
-	return tagToExtension[e.idlTag].allowedValues
-}
-
-func (e extension) hasKind() bool {
-	return len(tagToExtension[e.idlTag].kind) > 0
-}
-
-func (e extension) kind() types.Kind {
-	return tagToExtension[e.idlTag].kind
-}
-
-func (e extension) validateAllowedValues() error {
-	// allowedValues not set means no restrictions on values.
-	if !e.hasAllowedValues() {
-		return nil
-	}
-	// Check for missing value.
-	if len(e.values) == 0 {
-		return fmt.Errorf("%s needs a value, none given.", e.idlTag)
-	}
-	// For each extension value, validate that it is allowed.
-	allowedValues := e.allowedValues()
-	if !allowedValues.HasAll(e.values...) {
-		return fmt.Errorf("%v not allowed for %s. Allowed values: %v",
-			e.values, e.idlTag, allowedValues.List())
-	}
-	return nil
-}
-
-func (e extension) validateType(kind types.Kind) error {
-	// If this extension class has no kind, then don't validate the type.
-	if !e.hasKind() {
-		return nil
-	}
-	if kind != e.kind() {
-		return fmt.Errorf("tag %s on type %v; only allowed on type %v",
-			e.idlTag, kind, e.kind())
-	}
-	return nil
-}
-
-func (e extension) hasMultipleValues() bool {
-	return len(e.values) > 1
-}
-
-func (e extension) isAlwaysArrayFormat() bool {
-	return tagToExtension[e.idlTag].enforceArray
-}
-
-// Returns sorted list of map keys. Needed for deterministic testing.
-func sortedMapKeys(m map[string][]string) []string {
-	keys := make([]string, len(m))
-	i := 0
-	for k := range m {
-		keys[i] = k
-		i++
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// Parses comments to return openapi extensions. Returns a list of
-// extensions which parsed correctly, as well as a list of the
-// parse errors. Validating extensions is performed separately.
-// NOTE: Non-empty errors does not mean extensions is empty.
-func parseExtensions(comments []string) ([]extension, []error) {
-	extensions := []extension{}
-	errors := []error{}
-	// First, generate extensions from "+k8s:openapi-gen=x-kubernetes-*" annotations.
-	values := getOpenAPITagValue(comments)
-	for _, val := range values {
-		// Example: x-kubernetes-member-tag:member_test
-		if strings.HasPrefix(val, extensionPrefix) {
-			parts := strings.SplitN(val, ":", 2)
-			if len(parts) != 2 {
-				errors = append(errors, fmt.Errorf("invalid extension value: %v", val))
-				continue
-			}
-			e := extension{
-				idlTag: tagName,            // Example: k8s:openapi-gen
-				xName:  parts[0],           // Example: x-kubernetes-member-tag
-				values: []string{parts[1]}, // Example: member_test
-			}
-			extensions = append(extensions, e)
-		}
-	}
-	// Next, generate extensions from "idlTags" (e.g. +listType)
-	tagValues := gengo.ExtractCommentTags("+", comments)
-	for _, idlTag := range sortedMapKeys(tagValues) {
-		xAttrs, exists := tagToExtension[idlTag]
-		if !exists {
-			continue
-		}
-		values := tagValues[idlTag]
-		e := extension{
-			idlTag: idlTag,       // listType
-			xName:  xAttrs.xName, // x-kubernetes-list-type
-			values: values,       // [atomic]
-		}
-		extensions = append(extensions, e)
-	}
-	return extensions, errors
-}
-
-func validateMemberExtensions(extensions []extension, m *types.Member) []error {
-	errors := []error{}
-	for _, e := range extensions {
-		if err := e.validateAllowedValues(); err != nil {
-			errors = append(errors, err)
-		}
-		if err := e.validateType(m.Type.Kind); err != nil {
-			errors = append(errors, err)
-		}
-	}
-	return errors
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/markers.go b/vendor/k8s.io/kube-openapi/pkg/generators/markers.go
deleted file mode 100644
index 7f0fe985..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/markers.go
+++ /dev/null
@@ -1,613 +0,0 @@
-/*
-Copyright 2022 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"k8s.io/gengo/v2/types"
-	openapi "k8s.io/kube-openapi/pkg/common"
-	"k8s.io/kube-openapi/pkg/validation/spec"
-)
-
-type CELTag struct {
-	Rule              string `json:"rule,omitempty"`
-	Message           string `json:"message,omitempty"`
-	MessageExpression string `json:"messageExpression,omitempty"`
-	OptionalOldSelf   *bool  `json:"optionalOldSelf,omitempty"`
-	Reason            string `json:"reason,omitempty"`
-	FieldPath         string `json:"fieldPath,omitempty"`
-}
-
-func (c *CELTag) Validate() error {
-	if c == nil || *c == (CELTag{}) {
-		return fmt.Errorf("empty CEL tag is not allowed")
-	}
-
-	var errs []error
-	if c.Rule == "" {
-		errs = append(errs, fmt.Errorf("rule cannot be empty"))
-	}
-	if c.Message == "" && c.MessageExpression == "" {
-		errs = append(errs, fmt.Errorf("message or messageExpression must be set"))
-	}
-	if c.Message != "" && c.MessageExpression != "" {
-		errs = append(errs, fmt.Errorf("message and messageExpression cannot be set at the same time"))
-	}
-
-	if len(errs) > 0 {
-		return errors.Join(errs...)
-	}
-
-	return nil
-}
-
-// commentTags represents the parsed comment tags for a given type. These types are then used to generate schema validations.
-// These only include the newer prefixed tags. The older tags are still supported,
-// but are not included in this struct. Comment Tags are transformed into a
-// *spec.Schema, which is then combined with the older marker comments to produce
-// the generated OpenAPI spec.
-//
-// List of tags not included in this struct:
-//
-// - +optional
-// - +default
-// - +listType
-// - +listMapKeys
-// - +mapType
-type commentTags struct {
-	spec.SchemaProps
-
-	CEL []CELTag `json:"cel,omitempty"`
-
-	// Future markers can all be parsed into this centralized struct...
-	// Optional bool `json:"optional,omitempty"`
-	// Default  any  `json:"default,omitempty"`
-}
-
-// Returns the schema for the given CommentTags instance.
-// This is the final authoritative schema for the comment tags
-func (c commentTags) ValidationSchema() (*spec.Schema, error) {
-	res := spec.Schema{
-		SchemaProps: c.SchemaProps,
-	}
-
-	if len(c.CEL) > 0 {
-		// Convert the CELTag to a map[string]interface{} via JSON
-		celTagJSON, err := json.Marshal(c.CEL)
-		if err != nil {
-			return nil, fmt.Errorf("failed to marshal CEL tag: %w", err)
-		}
-		var celTagMap []interface{}
-		if err := json.Unmarshal(celTagJSON, &celTagMap); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal CEL tag: %w", err)
-		}
-
-		res.VendorExtensible.AddExtension("x-kubernetes-validations", celTagMap)
-	}
-
-	return &res, nil
-}
-
-// validates the parameters in a CommentTags instance. Returns any errors encountered.
-func (c commentTags) Validate() error {
-
-	var err error
-
-	if c.MinLength != nil && *c.MinLength < 0 {
-		err = errors.Join(err, fmt.Errorf("minLength cannot be negative"))
-	}
-	if c.MaxLength != nil && *c.MaxLength < 0 {
-		err = errors.Join(err, fmt.Errorf("maxLength cannot be negative"))
-	}
-	if c.MinItems != nil && *c.MinItems < 0 {
-		err = errors.Join(err, fmt.Errorf("minItems cannot be negative"))
-	}
-	if c.MaxItems != nil && *c.MaxItems < 0 {
-		err = errors.Join(err, fmt.Errorf("maxItems cannot be negative"))
-	}
-	if c.MinProperties != nil && *c.MinProperties < 0 {
-		err = errors.Join(err, fmt.Errorf("minProperties cannot be negative"))
-	}
-	if c.MaxProperties != nil && *c.MaxProperties < 0 {
-		err = errors.Join(err, fmt.Errorf("maxProperties cannot be negative"))
-	}
-	if c.Minimum != nil && c.Maximum != nil && *c.Minimum > *c.Maximum {
-		err = errors.Join(err, fmt.Errorf("minimum %f is greater than maximum %f", *c.Minimum, *c.Maximum))
-	}
-	if (c.ExclusiveMinimum || c.ExclusiveMaximum) && c.Minimum != nil && c.Maximum != nil && *c.Minimum == *c.Maximum {
-		err = errors.Join(err, fmt.Errorf("exclusiveMinimum/Maximum cannot be set when minimum == maximum"))
-	}
-	if c.MinLength != nil && c.MaxLength != nil && *c.MinLength > *c.MaxLength {
-		err = errors.Join(err, fmt.Errorf("minLength %d is greater than maxLength %d", *c.MinLength, *c.MaxLength))
-	}
-	if c.MinItems != nil && c.MaxItems != nil && *c.MinItems > *c.MaxItems {
-		err = errors.Join(err, fmt.Errorf("minItems %d is greater than maxItems %d", *c.MinItems, *c.MaxItems))
-	}
-	if c.MinProperties != nil && c.MaxProperties != nil && *c.MinProperties > *c.MaxProperties {
-		err = errors.Join(err, fmt.Errorf("minProperties %d is greater than maxProperties %d", *c.MinProperties, *c.MaxProperties))
-	}
-	if c.Pattern != "" {
-		_, e := regexp.Compile(c.Pattern)
-		if e != nil {
-			err = errors.Join(err, fmt.Errorf("invalid pattern %q: %v", c.Pattern, e))
-		}
-	}
-	if c.MultipleOf != nil && *c.MultipleOf == 0 {
-		err = errors.Join(err, fmt.Errorf("multipleOf cannot be 0"))
-	}
-
-	for i, celTag := range c.CEL {
-		celError := celTag.Validate()
-		if celError == nil {
-			continue
-		}
-		err = errors.Join(err, fmt.Errorf("invalid CEL tag at index %d: %w", i, celError))
-	}
-
-	return err
-}
-
-// Performs type-specific validation for CommentTags porameters. Accepts a Type instance and returns any errors encountered during validation.
-func (c commentTags) ValidateType(t *types.Type) error {
-	var err error
-
-	resolvedType := resolveAliasAndPtrType(t)
-	typeString, _ := openapi.OpenAPITypeFormat(resolvedType.String()) // will be empty for complicated types
-
-	// Structs and interfaces may dynamically be any type, so we cant validate them
-	// easily. We may be able to if we check that they don't implement all the
-	// override functions, but for now we just skip them.
-	if resolvedType.Kind == types.Interface || resolvedType.Kind == types.Struct {
-		return nil
-	}
-
-	isArray := resolvedType.Kind == types.Slice || resolvedType.Kind == types.Array
-	isMap := resolvedType.Kind == types.Map
-	isString := typeString == "string"
-	isInt := typeString == "integer"
-	isFloat := typeString == "number"
-
-	if c.MaxItems != nil && !isArray {
-		err = errors.Join(err, fmt.Errorf("maxItems can only be used on array types"))
-	}
-	if c.MinItems != nil && !isArray {
-		err = errors.Join(err, fmt.Errorf("minItems can only be used on array types"))
-	}
-	if c.UniqueItems && !isArray {
-		err = errors.Join(err, fmt.Errorf("uniqueItems can only be used on array types"))
-	}
-	if c.MaxProperties != nil && !isMap {
-		err = errors.Join(err, fmt.Errorf("maxProperties can only be used on map types"))
-	}
-	if c.MinProperties != nil && !isMap {
-		err = errors.Join(err, fmt.Errorf("minProperties can only be used on map types"))
-	}
-	if c.MinLength != nil && !isString {
-		err = errors.Join(err, fmt.Errorf("minLength can only be used on string types"))
-	}
-	if c.MaxLength != nil && !isString {
-		err = errors.Join(err, fmt.Errorf("maxLength can only be used on string types"))
-	}
-	if c.Pattern != "" && !isString {
-		err = errors.Join(err, fmt.Errorf("pattern can only be used on string types"))
-	}
-	if c.Minimum != nil && !isInt && !isFloat {
-		err = errors.Join(err, fmt.Errorf("minimum can only be used on numeric types"))
-	}
-	if c.Maximum != nil && !isInt && !isFloat {
-		err = errors.Join(err, fmt.Errorf("maximum can only be used on numeric types"))
-	}
-	if c.MultipleOf != nil && !isInt && !isFloat {
-		err = errors.Join(err, fmt.Errorf("multipleOf can only be used on numeric types"))
-	}
-	if c.ExclusiveMinimum && !isInt && !isFloat {
-		err = errors.Join(err, fmt.Errorf("exclusiveMinimum can only be used on numeric types"))
-	}
-	if c.ExclusiveMaximum && !isInt && !isFloat {
-		err = errors.Join(err, fmt.Errorf("exclusiveMaximum can only be used on numeric types"))
-	}
-
-	return err
-}
-
-// Parses the given comments into a CommentTags type. Validates the parsed comment tags, and returns the result.
-// Accepts an optional type to validate against, and a prefix to filter out markers not related to validation.
-// Accepts a prefix to filter out markers not related to validation.
-// Returns any errors encountered while parsing or validating the comment tags.
-func ParseCommentTags(t *types.Type, comments []string, prefix string) (*spec.Schema, error) {
-
-	markers, err := parseMarkers(comments, prefix)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse marker comments: %w", err)
-	}
-	nested, err := nestMarkers(markers)
-	if err != nil {
-		return nil, fmt.Errorf("invalid marker comments: %w", err)
-	}
-
-	// Parse the map into a CommentTags type by marshalling and unmarshalling
-	// as JSON in leiu of an unstructured converter.
-	out, err := json.Marshal(nested)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal marker comments: %w", err)
-	}
-
-	var commentTags commentTags
-	if err = json.Unmarshal(out, &commentTags); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal marker comments: %w", err)
-	}
-
-	// Validate the parsed comment tags
-	validationErrors := commentTags.Validate()
-
-	if t != nil {
-		validationErrors = errors.Join(validationErrors, commentTags.ValidateType(t))
-	}
-
-	if validationErrors != nil {
-		return nil, fmt.Errorf("invalid marker comments: %w", validationErrors)
-	}
-
-	return commentTags.ValidationSchema()
-}
-
-var (
-	allowedKeyCharacterSet = `[:_a-zA-Z0-9\[\]\-]`
-	valueEmpty             = regexp.MustCompile(fmt.Sprintf(`^(%s*)$`, allowedKeyCharacterSet))
-	valueAssign            = regexp.MustCompile(fmt.Sprintf(`^(%s*)=(.*)$`, allowedKeyCharacterSet))
-	valueRawString         = regexp.MustCompile(fmt.Sprintf(`^(%s*)>(.*)$`, allowedKeyCharacterSet))
-)
-
-// extractCommentTags parses comments for lines of the form:
-//
-//	'marker' + "key=value"
-//
-//	or to specify truthy boolean keys:
-//
-//	'marker' + "key"
-//
-// Values are optional; "" is the default.  A tag can be specified more than
-// one time and all values are returned.  Returns a map with an entry for
-// for each key and a value.
-//
-// Similar to version from gengo, but this version support only allows one
-// value per key (preferring explicit array indices), supports raw strings
-// with concatenation, and limits the usable characters allowed in a key
-// (for simpler parsing).
-//
-// Assignments and empty values have the same syntax as from gengo. Raw strings
-// have the syntax:
-//
-//	'marker' + "key>value"
-//	'marker' + "key>value"
-//
-// Successive usages of the same raw string key results in concatenating each
-// line with `\n` in between. It is an error to use `=` to assing to a previously
-// assigned key
-// (in contrast to types.ExtractCommentTags which allows array-typed
-// values to be specified using `=`).
-func extractCommentTags(marker string, lines []string) (map[string]string, error) {
-	out := map[string]string{}
-
-	// Used to track the the line immediately prior to the one being iterated.
-	// If there was an invalid or ignored line, these values get reset.
-	lastKey := ""
-	lastIndex := -1
-	lastArrayKey := ""
-
-	var lintErrors []error
-
-	for _, line := range lines {
-		line = strings.Trim(line, " ")
-
-		// Track the current value of the last vars to use in this loop iteration
-		// before they are reset for the next iteration.
-		previousKey := lastKey
-		previousArrayKey := lastArrayKey
-		previousIndex := lastIndex
-
-		// Make sure last vars gets reset if we `continue`
-		lastIndex = -1
-		lastArrayKey = ""
-		lastKey = ""
-
-		if len(line) == 0 {
-			continue
-		} else if !strings.HasPrefix(line, marker) {
-			continue
-		}
-
-		line = strings.TrimPrefix(line, marker)
-
-		key := ""
-		value := ""
-
-		if matches := valueAssign.FindStringSubmatch(line); matches != nil {
-			key = matches[1]
-			value = matches[2]
-
-			// If key exists, throw error.
-			// Some of the old kube open-api gen marker comments like
-			// `+listMapKeys` allowed a list to be specified by writing key=value
-			// multiple times.
-			//
-			// This is not longer supported for the prefixed marker comments.
-			// This is to prevent confusion with the new array syntax which
-			// supports lists of objects.
-			//
-			// The old marker comments like +listMapKeys will remain functional,
-			// but new markers will not support it.
-			if _, ok := out[key]; ok {
-				return nil, fmt.Errorf("cannot have multiple values for key '%v'", key)
-			}
-
-		} else if matches := valueEmpty.FindStringSubmatch(line); matches != nil {
-			key = matches[1]
-			value = ""
-
-		} else if matches := valueRawString.FindStringSubmatch(line); matches != nil {
-			toAdd := strings.Trim(string(matches[2]), " ")
-
-			key = matches[1]
-
-			// First usage as a raw string.
-			if existing, exists := out[key]; !exists {
-
-				// Encode the raw string as JSON to ensure that it is properly escaped.
-				valueBytes, err := json.Marshal(toAdd)
-				if err != nil {
-					return nil, fmt.Errorf("invalid value for key %v: %w", key, err)
-				}
-
-				value = string(valueBytes)
-			} else if key != previousKey {
-				// Successive usages of the same key of a raw string must be
-				// consecutive
-				return nil, fmt.Errorf("concatenations to key '%s' must be consecutive with its assignment", key)
-			} else {
-				// If it is a consecutive repeat usage, concatenate to the
-				// existing value.
-				//
-				// Decode JSON string, append to it, re-encode JSON string.
-				// Kinda janky but this is a code-generator...
-				var unmarshalled string
-				if err := json.Unmarshal([]byte(existing), &unmarshalled); err != nil {
-					return nil, fmt.Errorf("invalid value for key %v: %w", key, err)
-				} else {
-					unmarshalled += "\n" + toAdd
-					valueBytes, err := json.Marshal(unmarshalled)
-					if err != nil {
-						return nil, fmt.Errorf("invalid value for key %v: %w", key, err)
-					}
-
-					value = string(valueBytes)
-				}
-			}
-		} else {
-			// Comment has the correct prefix, but incorrect syntax, so it is an
-			// error
-			return nil, fmt.Errorf("invalid marker comment does not match expected `+key=<json formatted value>` pattern: %v", line)
-		}
-
-		out[key] = value
-		lastKey = key
-
-		// Lint the array subscript for common mistakes. This only lints the last
-		// array index used, (since we do not have a need for nested arrays yet
-		// in markers)
-		if arrayPath, index, hasSubscript, err := extractArraySubscript(key); hasSubscript {
-			// If index is non-zero, check that that previous line was for the same
-			// key and either the same or previous index
-			if err != nil {
-				lintErrors = append(lintErrors, fmt.Errorf("error parsing %v: expected integer index in key '%v'", line, key))
-			} else if previousArrayKey != arrayPath && index != 0 {
-				lintErrors = append(lintErrors, fmt.Errorf("error parsing %v: non-consecutive index %v for key '%v'", line, index, arrayPath))
-			} else if index != previousIndex+1 && index != previousIndex {
-				lintErrors = append(lintErrors, fmt.Errorf("error parsing %v: non-consecutive index %v for key '%v'", line, index, arrayPath))
-			}
-
-			lastIndex = index
-			lastArrayKey = arrayPath
-		}
-	}
-
-	if len(lintErrors) > 0 {
-		return nil, errors.Join(lintErrors...)
-	}
-
-	return out, nil
-}
-
-// Extracts and parses the given marker comments into a map of key -> value.
-// Accepts a prefix to filter out markers not related to validation.
-// The prefix is removed from the key in the returned map.
-// Empty keys and invalid values will return errors, refs are currently unsupported and will be skipped.
-func parseMarkers(markerComments []string, prefix string) (map[string]any, error) {
-	markers, err := extractCommentTags(prefix, markerComments)
-	if err != nil {
-		return nil, err
-	}
-
-	// Parse the values as JSON
-	result := map[string]any{}
-	for key, value := range markers {
-		var unmarshalled interface{}
-
-		if len(key) == 0 {
-			return nil, fmt.Errorf("cannot have empty key for marker comment")
-		} else if _, ok := parseSymbolReference(value, ""); ok {
-			// Skip ref markers
-			continue
-		} else if len(value) == 0 {
-			// Empty value means key is implicitly a bool
-			result[key] = true
-		} else if err := json.Unmarshal([]byte(value), &unmarshalled); err != nil {
-			// Not valid JSON, throw error
-			return nil, fmt.Errorf("failed to parse value for key %v as JSON: %w", key, err)
-		} else {
-			// Is is valid JSON, use as a JSON value
-			result[key] = unmarshalled
-		}
-	}
-	return result, nil
-}
-
-// Converts a map of:
-//
-//	"a:b:c": 1
-//	"a:b:d": 2
-//	"a:e": 3
-//	"f": 4
-//
-// Into:
-//
-//	 map[string]any{
-//	   "a": map[string]any{
-//		      "b": map[string]any{
-//		          "c": 1,
-//				  "d": 2,
-//			   },
-//			   "e": 3,
-//		  },
-//		  "f": 4,
-//	 }
-//
-// Returns a list of joined errors for any invalid keys. See putNestedValue for more details.
-func nestMarkers(markers map[string]any) (map[string]any, error) {
-	nested := make(map[string]any)
-	var errs []error
-	for key, value := range markers {
-		var err error
-		keys := strings.Split(key, ":")
-
-		if err = putNestedValue(nested, keys, value); err != nil {
-			errs = append(errs, err)
-		}
-	}
-
-	if len(errs) > 0 {
-		return nil, errors.Join(errs...)
-	}
-
-	return nested, nil
-}
-
-// Recursively puts a value into the given keypath, creating intermediate maps
-// and slices as needed. If a key is of the form `foo[bar]`, then bar will be
-// treated as an index into the array foo. If bar is not a valid integer, putNestedValue returns an error.
-func putNestedValue(m map[string]any, k []string, v any) error {
-	if len(k) == 0 {
-		return nil
-	}
-
-	key := k[0]
-	rest := k[1:]
-
-	// Array case
-	if arrayKeyWithoutSubscript, index, hasSubscript, err := extractArraySubscript(key); err != nil {
-		return fmt.Errorf("error parsing subscript for key %v: %w", key, err)
-	} else if hasSubscript {
-		key = arrayKeyWithoutSubscript
-		var arrayDestination []any
-		if existing, ok := m[key]; !ok {
-			arrayDestination = make([]any, index+1)
-		} else if existing, ok := existing.([]any); !ok {
-			// Error case. Existing isn't of correct type. Can happen if
-			// someone is subscripting a field that was previously not an array
-			return fmt.Errorf("expected []any at key %v, got %T", key, existing)
-		} else if index >= len(existing) {
-			// Ensure array is big enough
-			arrayDestination = append(existing, make([]any, index-len(existing)+1)...)
-		} else {
-			arrayDestination = existing
-		}
-
-		m[key] = arrayDestination
-		if arrayDestination[index] == nil {
-			// Doesn't exist case, create the destination.
-			// Assumes the destination is a map for now. Theoretically could be
-			// extended to support arrays of arrays, but that's not needed yet.
-			destination := make(map[string]any)
-			arrayDestination[index] = destination
-			if err = putNestedValue(destination, rest, v); err != nil {
-				return err
-			}
-		} else if dst, ok := arrayDestination[index].(map[string]any); ok {
-			// Already exists case, correct type
-			if putNestedValue(dst, rest, v); err != nil {
-				return err
-			}
-		} else {
-			// Already exists, incorrect type. Error
-			// This shouldn't be possible.
-			return fmt.Errorf("expected map at %v[%v], got %T", key, index, arrayDestination[index])
-		}
-
-		return nil
-	} else if len(rest) == 0 {
-		// Base case. Single key. Just set into destination
-		m[key] = v
-		return nil
-	}
-
-	if existing, ok := m[key]; !ok {
-		destination := make(map[string]any)
-		m[key] = destination
-		return putNestedValue(destination, rest, v)
-	} else if destination, ok := existing.(map[string]any); ok {
-		return putNestedValue(destination, rest, v)
-	} else {
-		// Error case. Existing isn't of correct type. Can happen if prior comment
-		// referred to value as an error
-		return fmt.Errorf("expected map[string]any at key %v, got %T", key, existing)
-	}
-}
-
-// extractArraySubscript extracts the left array subscript from a key of
-// the form  `foo[bar][baz]` -> "bar".
-// Returns the key without the subscript, the index, and a bool indicating if
-// the key had a subscript.
-// If the key has a subscript, but the subscript is not a valid integer, returns an error.
-//
-// This can be adapted to support multidimensional subscripts probably fairly
-// easily by retuning a list of ints
-func extractArraySubscript(str string) (string, int, bool, error) {
-	subscriptIdx := strings.Index(str, "[")
-	if subscriptIdx == -1 {
-		return "", -1, false, nil
-	}
-
-	subscript := strings.Split(str[subscriptIdx+1:], "]")[0]
-	if len(subscript) == 0 {
-		return "", -1, false, fmt.Errorf("empty subscript not allowed")
-	}
-
-	index, err := strconv.Atoi(subscript)
-	if err != nil {
-		return "", -1, false, fmt.Errorf("expected integer index in key %v", str)
-	} else if index < 0 {
-		return "", -1, false, fmt.Errorf("subscript '%v' is invalid. index must be positive", subscript)
-	}
-
-	return str[:subscriptIdx], index, true, nil
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go b/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go
deleted file mode 100644
index 743f5b8b..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go
+++ /dev/null
@@ -1,1030 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"path"
-	"reflect"
-	"regexp"
-	"sort"
-	"strings"
-
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/generator"
-	"k8s.io/gengo/v2/namer"
-	"k8s.io/gengo/v2/types"
-	openapi "k8s.io/kube-openapi/pkg/common"
-	"k8s.io/kube-openapi/pkg/validation/spec"
-
-	"k8s.io/klog/v2"
-)
-
-// This is the comment tag that carries parameters for open API generation.
-const tagName = "k8s:openapi-gen"
-const markerPrefix = "+k8s:validation:"
-const tagOptional = "optional"
-const tagRequired = "required"
-const tagDefault = "default"
-
-// Known values for the tag.
-const (
-	tagValueTrue  = "true"
-	tagValueFalse = "false"
-)
-
-// Used for temporary validation of patch struct tags.
-// TODO: Remove patch struct tag validation because they we are now consuming OpenAPI on server.
-var tempPatchTags = [...]string{
-	"patchMergeKey",
-	"patchStrategy",
-}
-
-func getOpenAPITagValue(comments []string) []string {
-	return gengo.ExtractCommentTags("+", comments)[tagName]
-}
-
-func getSingleTagsValue(comments []string, tag string) (string, error) {
-	tags, ok := gengo.ExtractCommentTags("+", comments)[tag]
-	if !ok || len(tags) == 0 {
-		return "", nil
-	}
-	if len(tags) > 1 {
-		return "", fmt.Errorf("multiple values are not allowed for tag %s", tag)
-	}
-	return tags[0], nil
-}
-
-func hasOpenAPITagValue(comments []string, value string) bool {
-	tagValues := getOpenAPITagValue(comments)
-	for _, val := range tagValues {
-		if val == value {
-			return true
-		}
-	}
-	return false
-}
-
-// isOptional returns error if the member has +optional and +required in
-// its comments. If +optional is present it returns true. If +required is present
-// it returns false. Otherwise, it returns true if `omitempty` JSON tag is present
-func isOptional(m *types.Member) (bool, error) {
-	hasOptionalCommentTag := gengo.ExtractCommentTags(
-		"+", m.CommentLines)[tagOptional] != nil
-	hasRequiredCommentTag := gengo.ExtractCommentTags(
-		"+", m.CommentLines)[tagRequired] != nil
-	if hasOptionalCommentTag && hasRequiredCommentTag {
-		return false, fmt.Errorf("member %s cannot be both optional and required", m.Name)
-	} else if hasRequiredCommentTag {
-		return false, nil
-	} else if hasOptionalCommentTag {
-		return true, nil
-	}
-
-	// If neither +optional nor +required is present in the comments,
-	// infer optional from the json tags.
-	return strings.Contains(reflect.StructTag(m.Tags).Get("json"), "omitempty"), nil
-}
-
-func apiTypeFilterFunc(c *generator.Context, t *types.Type) bool {
-	// There is a conflict between this codegen and codecgen, we should avoid types generated for codecgen
-	if strings.HasPrefix(t.Name.Name, "codecSelfer") {
-		return false
-	}
-	pkg := c.Universe.Package(t.Name.Package)
-	if hasOpenAPITagValue(pkg.Comments, tagValueTrue) {
-		return !hasOpenAPITagValue(t.CommentLines, tagValueFalse)
-	}
-	if hasOpenAPITagValue(t.CommentLines, tagValueTrue) {
-		return true
-	}
-	return false
-}
-
-const (
-	specPackagePath          = "k8s.io/kube-openapi/pkg/validation/spec"
-	openAPICommonPackagePath = "k8s.io/kube-openapi/pkg/common"
-)
-
-// openApiGen produces a file with auto-generated OpenAPI functions.
-type openAPIGen struct {
-	generator.GoGenerator
-	// TargetPackage is the package that will get GetOpenAPIDefinitions function returns all open API definitions.
-	targetPackage string
-	imports       namer.ImportTracker
-}
-
-func newOpenAPIGen(outputFilename string, targetPackage string) generator.Generator {
-	return &openAPIGen{
-		GoGenerator: generator.GoGenerator{
-			OutputFilename: outputFilename,
-		},
-		imports:       generator.NewImportTrackerForPackage(targetPackage),
-		targetPackage: targetPackage,
-	}
-}
-
-const nameTmpl = "schema_$.type|private$"
-
-func (g *openAPIGen) Namers(c *generator.Context) namer.NameSystems {
-	// Have the raw namer for this file track what it imports.
-	return namer.NameSystems{
-		"raw": namer.NewRawNamer(g.targetPackage, g.imports),
-		"private": &namer.NameStrategy{
-			Join: func(pre string, in []string, post string) string {
-				return strings.Join(in, "_")
-			},
-			PrependPackageNames: 4, // enough to fully qualify from k8s.io/api/...
-		},
-	}
-}
-
-func (g *openAPIGen) Imports(c *generator.Context) []string {
-	importLines := []string{}
-	for _, singleImport := range g.imports.ImportLines() {
-		importLines = append(importLines, singleImport)
-	}
-	return importLines
-}
-
-func argsFromType(t *types.Type) generator.Args {
-	return generator.Args{
-		"type":              t,
-		"ReferenceCallback": types.Ref(openAPICommonPackagePath, "ReferenceCallback"),
-		"OpenAPIDefinition": types.Ref(openAPICommonPackagePath, "OpenAPIDefinition"),
-		"SpecSchemaType":    types.Ref(specPackagePath, "Schema"),
-	}
-}
-
-func (g *openAPIGen) Init(c *generator.Context, w io.Writer) error {
-	sw := generator.NewSnippetWriter(w, c, "$", "$")
-	sw.Do("func GetOpenAPIDefinitions(ref $.ReferenceCallback|raw$) map[string]$.OpenAPIDefinition|raw$ {\n", argsFromType(nil))
-	sw.Do("return map[string]$.OpenAPIDefinition|raw${\n", argsFromType(nil))
-
-	for _, t := range c.Order {
-		err := newOpenAPITypeWriter(sw, c).generateCall(t)
-		if err != nil {
-			return err
-		}
-	}
-
-	sw.Do("}\n", nil)
-	sw.Do("}\n\n", nil)
-
-	return sw.Error()
-}
-
-func (g *openAPIGen) GenerateType(c *generator.Context, t *types.Type, w io.Writer) error {
-	klog.V(5).Infof("generating for type %v", t)
-	sw := generator.NewSnippetWriter(w, c, "$", "$")
-	err := newOpenAPITypeWriter(sw, c).generate(t)
-	if err != nil {
-		return err
-	}
-	return sw.Error()
-}
-
-func getJsonTags(m *types.Member) []string {
-	jsonTag := reflect.StructTag(m.Tags).Get("json")
-	if jsonTag == "" {
-		return []string{}
-	}
-	return strings.Split(jsonTag, ",")
-}
-
-func getReferableName(m *types.Member) string {
-	jsonTags := getJsonTags(m)
-	if len(jsonTags) > 0 {
-		if jsonTags[0] == "-" {
-			return ""
-		} else {
-			return jsonTags[0]
-		}
-	} else {
-		return m.Name
-	}
-}
-
-func shouldInlineMembers(m *types.Member) bool {
-	jsonTags := getJsonTags(m)
-	return len(jsonTags) > 1 && jsonTags[1] == "inline"
-}
-
-type openAPITypeWriter struct {
-	*generator.SnippetWriter
-	context                *generator.Context
-	refTypes               map[string]*types.Type
-	enumContext            *enumContext
-	GetDefinitionInterface *types.Type
-}
-
-func newOpenAPITypeWriter(sw *generator.SnippetWriter, c *generator.Context) openAPITypeWriter {
-	return openAPITypeWriter{
-		SnippetWriter: sw,
-		context:       c,
-		refTypes:      map[string]*types.Type{},
-		enumContext:   newEnumContext(c),
-	}
-}
-
-func methodReturnsValue(mt *types.Type, pkg, name string) bool {
-	if len(mt.Signature.Parameters) != 0 || len(mt.Signature.Results) != 1 {
-		return false
-	}
-	r := mt.Signature.Results[0]
-	return r.Name.Name == name && r.Name.Package == pkg
-}
-
-func hasOpenAPIV3DefinitionMethod(t *types.Type) bool {
-	for mn, mt := range t.Methods {
-		if mn != "OpenAPIV3Definition" {
-			continue
-		}
-		return methodReturnsValue(mt, openAPICommonPackagePath, "OpenAPIDefinition")
-	}
-	return false
-}
-
-func hasOpenAPIDefinitionMethod(t *types.Type) bool {
-	for mn, mt := range t.Methods {
-		if mn != "OpenAPIDefinition" {
-			continue
-		}
-		return methodReturnsValue(mt, openAPICommonPackagePath, "OpenAPIDefinition")
-	}
-	return false
-}
-
-func hasOpenAPIDefinitionMethods(t *types.Type) bool {
-	var hasSchemaTypeMethod, hasOpenAPISchemaFormat bool
-	for mn, mt := range t.Methods {
-		switch mn {
-		case "OpenAPISchemaType":
-			hasSchemaTypeMethod = methodReturnsValue(mt, "", "[]string")
-		case "OpenAPISchemaFormat":
-			hasOpenAPISchemaFormat = methodReturnsValue(mt, "", "string")
-		}
-	}
-	return hasSchemaTypeMethod && hasOpenAPISchemaFormat
-}
-
-func hasOpenAPIV3OneOfMethod(t *types.Type) bool {
-	for mn, mt := range t.Methods {
-		if mn != "OpenAPIV3OneOfTypes" {
-			continue
-		}
-		return methodReturnsValue(mt, "", "[]string")
-	}
-	return false
-}
-
-// typeShortName returns short package name (e.g. the name x appears in package x definition) dot type name.
-func typeShortName(t *types.Type) string {
-	// `path` vs. `filepath` because packages use '/'
-	return path.Base(t.Name.Package) + "." + t.Name.Name
-}
-
-func (g openAPITypeWriter) generateMembers(t *types.Type, required []string) ([]string, error) {
-	var err error
-	for t.Kind == types.Pointer { // fast-forward to effective type containing members
-		t = t.Elem
-	}
-	for _, m := range t.Members {
-		if hasOpenAPITagValue(m.CommentLines, tagValueFalse) {
-			continue
-		}
-		if shouldInlineMembers(&m) {
-			required, err = g.generateMembers(m.Type, required)
-			if err != nil {
-				return required, err
-			}
-			continue
-		}
-		name := getReferableName(&m)
-		if name == "" {
-			continue
-		}
-		if isOptional, err := isOptional(&m); err != nil {
-			klog.Errorf("Error when generating: %v, %v\n", name, m)
-			return required, err
-		} else if !isOptional {
-			required = append(required, name)
-		}
-		if err = g.generateProperty(&m, t); err != nil {
-			klog.Errorf("Error when generating: %v, %v\n", name, m)
-			return required, err
-		}
-	}
-	return required, nil
-}
-
-func (g openAPITypeWriter) generateCall(t *types.Type) error {
-	// Only generate for struct type and ignore the rest
-	switch t.Kind {
-	case types.Struct:
-		args := argsFromType(t)
-		g.Do("\"$.$\": ", t.Name)
-
-		hasV2Definition := hasOpenAPIDefinitionMethod(t)
-		hasV2DefinitionTypeAndFormat := hasOpenAPIDefinitionMethods(t)
-		hasV3Definition := hasOpenAPIV3DefinitionMethod(t)
-
-		switch {
-		case hasV2DefinitionTypeAndFormat:
-			g.Do(nameTmpl+"(ref),\n", args)
-		case hasV2Definition && hasV3Definition:
-			g.Do("common.EmbedOpenAPIDefinitionIntoV2Extension($.type|raw${}.OpenAPIV3Definition(), $.type|raw${}.OpenAPIDefinition()),\n", args)
-		case hasV2Definition:
-			g.Do("$.type|raw${}.OpenAPIDefinition(),\n", args)
-		case hasV3Definition:
-			g.Do("$.type|raw${}.OpenAPIV3Definition(),\n", args)
-		default:
-			g.Do(nameTmpl+"(ref),\n", args)
-		}
-	}
-	return g.Error()
-}
-
-func (g openAPITypeWriter) generateValueValidations(vs *spec.SchemaProps) error {
-
-	if vs == nil {
-		return nil
-	}
-	args := generator.Args{
-		"ptrTo": &types.Type{
-			Name: types.Name{
-				Package: "k8s.io/utils/ptr",
-				Name:    "To",
-			}},
-		"spec": vs,
-	}
-	if vs.Minimum != nil {
-		g.Do("Minimum: $.ptrTo|raw$[float64]($.spec.Minimum$),\n", args)
-	}
-	if vs.Maximum != nil {
-		g.Do("Maximum: $.ptrTo|raw$[float64]($.spec.Maximum$),\n", args)
-	}
-	if vs.ExclusiveMinimum {
-		g.Do("ExclusiveMinimum: true,\n", args)
-	}
-	if vs.ExclusiveMaximum {
-		g.Do("ExclusiveMaximum: true,\n", args)
-	}
-	if vs.MinLength != nil {
-		g.Do("MinLength: $.ptrTo|raw$[int64]($.spec.MinLength$),\n", args)
-	}
-	if vs.MaxLength != nil {
-		g.Do("MaxLength: $.ptrTo|raw$[int64]($.spec.MaxLength$),\n", args)
-	}
-
-	if vs.MinProperties != nil {
-		g.Do("MinProperties: $.ptrTo|raw$[int64]($.spec.MinProperties$),\n", args)
-	}
-	if vs.MaxProperties != nil {
-		g.Do("MaxProperties: $.ptrTo|raw$[int64]($.spec.MaxProperties$),\n", args)
-	}
-	if len(vs.Pattern) > 0 {
-		p, err := json.Marshal(vs.Pattern)
-		if err != nil {
-			return err
-		}
-		g.Do("Pattern: $.$,\n", string(p))
-	}
-	if vs.MultipleOf != nil {
-		g.Do("MultipleOf: $.ptrTo|raw$[float64]($.spec.MultipleOf$),\n", args)
-	}
-	if vs.MinItems != nil {
-		g.Do("MinItems: $.ptrTo|raw$[int64]($.spec.MinItems$),\n", args)
-	}
-	if vs.MaxItems != nil {
-		g.Do("MaxItems: $.ptrTo|raw$[int64]($.spec.MaxItems$),\n", args)
-	}
-	if vs.UniqueItems {
-		g.Do("UniqueItems: true,\n", nil)
-	}
-
-	return nil
-}
-
-func (g openAPITypeWriter) generate(t *types.Type) error {
-	// Only generate for struct type and ignore the rest
-	switch t.Kind {
-	case types.Struct:
-		validationSchema, err := ParseCommentTags(t, t.CommentLines, markerPrefix)
-		if err != nil {
-			return err
-		}
-
-		hasV2Definition := hasOpenAPIDefinitionMethod(t)
-		hasV2DefinitionTypeAndFormat := hasOpenAPIDefinitionMethods(t)
-		hasV3OneOfTypes := hasOpenAPIV3OneOfMethod(t)
-		hasV3Definition := hasOpenAPIV3DefinitionMethod(t)
-
-		if hasV2Definition || (hasV3Definition && !hasV2DefinitionTypeAndFormat) {
-			// already invoked directly
-			return nil
-		}
-
-		args := argsFromType(t)
-		g.Do("func "+nameTmpl+"(ref $.ReferenceCallback|raw$) $.OpenAPIDefinition|raw$ {\n", args)
-		switch {
-		case hasV2DefinitionTypeAndFormat && hasV3Definition:
-			g.Do("return common.EmbedOpenAPIDefinitionIntoV2Extension($.type|raw${}.OpenAPIV3Definition(), $.OpenAPIDefinition|raw${\n"+
-				"Schema: spec.Schema{\n"+
-				"SchemaProps: spec.SchemaProps{\n", args)
-			g.generateDescription(t.CommentLines)
-			g.Do("Type:$.type|raw${}.OpenAPISchemaType(),\n"+
-				"Format:$.type|raw${}.OpenAPISchemaFormat(),\n", args)
-			err = g.generateValueValidations(&validationSchema.SchemaProps)
-			if err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			if err := g.generateStructExtensions(t, validationSchema.Extensions); err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			g.Do("})\n}\n\n", args)
-			return nil
-		case hasV2DefinitionTypeAndFormat && hasV3OneOfTypes:
-			// generate v3 def.
-			g.Do("return common.EmbedOpenAPIDefinitionIntoV2Extension($.OpenAPIDefinition|raw${\n"+
-				"Schema: spec.Schema{\n"+
-				"SchemaProps: spec.SchemaProps{\n", args)
-			g.generateDescription(t.CommentLines)
-			g.Do("OneOf:common.GenerateOpenAPIV3OneOfSchema($.type|raw${}.OpenAPIV3OneOfTypes()),\n"+
-				"Format:$.type|raw${}.OpenAPISchemaFormat(),\n", args)
-			err = g.generateValueValidations(&validationSchema.SchemaProps)
-			if err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			if err := g.generateStructExtensions(t, validationSchema.Extensions); err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			g.Do("},", args)
-			// generate v2 def.
-			g.Do("$.OpenAPIDefinition|raw${\n"+
-				"Schema: spec.Schema{\n"+
-				"SchemaProps: spec.SchemaProps{\n", args)
-			g.generateDescription(t.CommentLines)
-			g.Do("Type:$.type|raw${}.OpenAPISchemaType(),\n"+
-				"Format:$.type|raw${}.OpenAPISchemaFormat(),\n", args)
-			err = g.generateValueValidations(&validationSchema.SchemaProps)
-			if err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			if err := g.generateStructExtensions(t, validationSchema.Extensions); err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			g.Do("})\n}\n\n", args)
-			return nil
-		case hasV2DefinitionTypeAndFormat:
-			g.Do("return $.OpenAPIDefinition|raw${\n"+
-				"Schema: spec.Schema{\n"+
-				"SchemaProps: spec.SchemaProps{\n", args)
-			g.generateDescription(t.CommentLines)
-			g.Do("Type:$.type|raw${}.OpenAPISchemaType(),\n"+
-				"Format:$.type|raw${}.OpenAPISchemaFormat(),\n", args)
-			err = g.generateValueValidations(&validationSchema.SchemaProps)
-			if err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			if err := g.generateStructExtensions(t, validationSchema.Extensions); err != nil {
-				return err
-			}
-			g.Do("},\n", nil)
-			g.Do("}\n}\n\n", args)
-			return nil
-		case hasV3OneOfTypes:
-			// having v3 oneOf types without custom v2 type or format does not make sense.
-			return fmt.Errorf("type %q has v3 one of types but not v2 type or format", t.Name)
-		}
-
-		g.Do("return $.OpenAPIDefinition|raw${\nSchema: spec.Schema{\nSchemaProps: spec.SchemaProps{\n", args)
-		g.generateDescription(t.CommentLines)
-		g.Do("Type: []string{\"object\"},\n", nil)
-		err = g.generateValueValidations(&validationSchema.SchemaProps)
-		if err != nil {
-			return err
-		}
-
-		// write members into a temporary buffer, in order to postpone writing out the Properties field. We only do
-		// that if it is not empty.
-		propertiesBuf := bytes.Buffer{}
-		bsw := g
-		bsw.SnippetWriter = generator.NewSnippetWriter(&propertiesBuf, g.context, "$", "$")
-		required, err := bsw.generateMembers(t, []string{})
-		if err != nil {
-			return err
-		}
-		if propertiesBuf.Len() > 0 {
-			g.Do("Properties: map[string]$.SpecSchemaType|raw${\n", args)
-			g.Do(strings.Replace(propertiesBuf.String(), "$", "$\"$\"$", -1), nil) // escape $ (used as delimiter of the templates)
-			g.Do("},\n", nil)
-		}
-
-		if len(required) > 0 {
-			g.Do("Required: []string{\"$.$\"},\n", strings.Join(required, "\",\""))
-		}
-		g.Do("},\n", nil)
-		if err := g.generateStructExtensions(t, validationSchema.Extensions); err != nil {
-			return err
-		}
-		g.Do("},\n", nil)
-
-		// Map order is undefined, sort them or we may get a different file generated each time.
-		keys := []string{}
-		for k := range g.refTypes {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		deps := []string{}
-		for _, k := range keys {
-			v := g.refTypes[k]
-			if t, _ := openapi.OpenAPITypeFormat(v.String()); t != "" {
-				// This is a known type, we do not need a reference to it
-				// Will eliminate special case of time.Time
-				continue
-			}
-			deps = append(deps, k)
-		}
-		if len(deps) > 0 {
-			g.Do("Dependencies: []string{\n", args)
-			for _, k := range deps {
-				g.Do("\"$.$\",", k)
-			}
-			g.Do("},\n", nil)
-		}
-		g.Do("}\n}\n\n", nil)
-	}
-	return nil
-}
-
-func (g openAPITypeWriter) generateStructExtensions(t *types.Type, otherExtensions map[string]interface{}) error {
-	extensions, errors := parseExtensions(t.CommentLines)
-	// Initially, we will only log struct extension errors.
-	if len(errors) > 0 {
-		for _, e := range errors {
-			klog.Errorf("[%s]: %s\n", t.String(), e)
-		}
-	}
-	unions, errors := parseUnions(t)
-	if len(errors) > 0 {
-		for _, e := range errors {
-			klog.Errorf("[%s]: %s\n", t.String(), e)
-		}
-	}
-
-	// TODO(seans3): Validate struct extensions here.
-	g.emitExtensions(extensions, unions, otherExtensions)
-	return nil
-}
-
-func (g openAPITypeWriter) generateMemberExtensions(m *types.Member, parent *types.Type, otherExtensions map[string]interface{}) error {
-	extensions, parseErrors := parseExtensions(m.CommentLines)
-	validationErrors := validateMemberExtensions(extensions, m)
-	errors := append(parseErrors, validationErrors...)
-	// Initially, we will only log member extension errors.
-	if len(errors) > 0 {
-		errorPrefix := fmt.Sprintf("[%s] %s:", parent.String(), m.String())
-		for _, e := range errors {
-			klog.V(2).Infof("%s %s\n", errorPrefix, e)
-		}
-	}
-	g.emitExtensions(extensions, nil, otherExtensions)
-	return nil
-}
-
-func (g openAPITypeWriter) emitExtensions(extensions []extension, unions []union, otherExtensions map[string]interface{}) {
-	// If any extensions exist, then emit code to create them.
-	if len(extensions) == 0 && len(unions) == 0 && len(otherExtensions) == 0 {
-		return
-	}
-	g.Do("VendorExtensible: spec.VendorExtensible{\nExtensions: spec.Extensions{\n", nil)
-	for _, extension := range extensions {
-		g.Do("\"$.$\": ", extension.xName)
-		if extension.hasMultipleValues() || extension.isAlwaysArrayFormat() {
-			g.Do("[]interface{}{\n", nil)
-		}
-		for _, value := range extension.values {
-			g.Do("\"$.$\",\n", value)
-		}
-		if extension.hasMultipleValues() || extension.isAlwaysArrayFormat() {
-			g.Do("},\n", nil)
-		}
-	}
-	if len(unions) > 0 {
-		g.Do("\"x-kubernetes-unions\": []interface{}{\n", nil)
-		for _, u := range unions {
-			u.emit(g)
-		}
-		g.Do("},\n", nil)
-	}
-
-	if len(otherExtensions) > 0 {
-		for k, v := range otherExtensions {
-			g.Do("$.key$: $.value$,\n", map[string]interface{}{
-				"key":   fmt.Sprintf("%#v", k),
-				"value": fmt.Sprintf("%#v", v),
-			})
-		}
-	}
-
-	g.Do("},\n},\n", nil)
-}
-
-// TODO(#44005): Move this validation outside of this generator (probably to policy verifier)
-func (g openAPITypeWriter) validatePatchTags(m *types.Member, parent *types.Type) error {
-	// TODO: Remove patch struct tag validation because they we are now consuming OpenAPI on server.
-	for _, tagKey := range tempPatchTags {
-		structTagValue := reflect.StructTag(m.Tags).Get(tagKey)
-		commentTagValue, err := getSingleTagsValue(m.CommentLines, tagKey)
-		if err != nil {
-			return err
-		}
-		if structTagValue != commentTagValue {
-			return fmt.Errorf("Tags in comment and struct should match for member (%s) of (%s)",
-				m.Name, parent.Name.String())
-		}
-	}
-	return nil
-}
-
-func defaultFromComments(comments []string, commentPath string, t *types.Type) (interface{}, *types.Name, error) {
-	var tag string
-
-	for {
-		var err error
-		tag, err = getSingleTagsValue(comments, tagDefault)
-		if err != nil {
-			return nil, nil, err
-		}
-
-		if t == nil || len(tag) > 0 {
-			break
-		}
-
-		comments = t.CommentLines
-		commentPath = t.Name.Package
-		switch t.Kind {
-		case types.Pointer:
-			t = t.Elem
-		case types.Alias:
-			t = t.Underlying
-		default:
-			t = nil
-		}
-	}
-
-	if tag == "" {
-		return nil, nil, nil
-	}
-
-	var i interface{}
-	if id, ok := parseSymbolReference(tag, commentPath); ok {
-		klog.Errorf("%v, %v", id, commentPath)
-		return nil, &id, nil
-	} else if err := json.Unmarshal([]byte(tag), &i); err != nil {
-		return nil, nil, fmt.Errorf("failed to unmarshal default: %v", err)
-	}
-	return i, nil, nil
-}
-
-var refRE = regexp.MustCompile(`^ref\((?P<reference>[^"]+)\)$`)
-var refREIdentIndex = refRE.SubexpIndex("reference")
-
-// parseSymbolReference looks for strings that match one of the following:
-//   - ref(Ident)
-//   - ref(pkgpath.Ident)
-//     If the input string matches either of these, it will return the (optional)
-//     pkgpath, the Ident, and true.  Otherwise it will return empty strings and
-//     false.
-//
-// This is borrowed from k8s.io/code-generator.
-func parseSymbolReference(s, sourcePackage string) (types.Name, bool) {
-	matches := refRE.FindStringSubmatch(s)
-	if len(matches) < refREIdentIndex || matches[refREIdentIndex] == "" {
-		return types.Name{}, false
-	}
-
-	contents := matches[refREIdentIndex]
-	name := types.ParseFullyQualifiedName(contents)
-	if len(name.Package) == 0 {
-		name.Package = sourcePackage
-	}
-	return name, true
-}
-
-func implementsCustomUnmarshalling(t *types.Type) bool {
-	switch t.Kind {
-	case types.Pointer:
-		unmarshaller, isUnmarshaller := t.Elem.Methods["UnmarshalJSON"]
-		return isUnmarshaller && unmarshaller.Signature.Receiver.Kind == types.Pointer
-	case types.Struct:
-		_, isUnmarshaller := t.Methods["UnmarshalJSON"]
-		return isUnmarshaller
-	default:
-		return false
-	}
-}
-
-func mustEnforceDefault(t *types.Type, omitEmpty bool) (interface{}, error) {
-	// Treat types with custom unmarshalling as a value
-	// (Can be alias, struct, or pointer)
-	if implementsCustomUnmarshalling(t) {
-		// Since Go JSON deserializer always feeds `null` when present
-		// to structs with custom UnmarshalJSON, the zero value for
-		// these structs is also null.
-		//
-		// In general, Kubernetes API types with custom marshalling should
-		// marshal their empty values to `null`.
-		return nil, nil
-	}
-
-	switch t.Kind {
-	case types.Alias:
-		return mustEnforceDefault(t.Underlying, omitEmpty)
-	case types.Pointer, types.Map, types.Slice, types.Array, types.Interface:
-		return nil, nil
-	case types.Struct:
-		if len(t.Members) == 1 && t.Members[0].Embedded {
-			// Treat a struct with a single embedded member the same as an alias
-			return mustEnforceDefault(t.Members[0].Type, omitEmpty)
-		}
-
-		return map[string]interface{}{}, nil
-	case types.Builtin:
-		if !omitEmpty {
-			if zero, ok := openapi.OpenAPIZeroValue(t.String()); ok {
-				return zero, nil
-			} else {
-				return nil, fmt.Errorf("please add type %v to getOpenAPITypeFormat function", t)
-			}
-		}
-		return nil, nil
-	default:
-		return nil, fmt.Errorf("not sure how to enforce default for %v", t.Kind)
-	}
-}
-
-func (g openAPITypeWriter) generateDefault(comments []string, t *types.Type, omitEmpty bool, commentOwningType *types.Type) error {
-	def, ref, err := defaultFromComments(comments, commentOwningType.Name.Package, t)
-	if err != nil {
-		return err
-	}
-	if enforced, err := mustEnforceDefault(t, omitEmpty); err != nil {
-		return err
-	} else if enforced != nil {
-		if def == nil {
-			def = enforced
-		} else if !reflect.DeepEqual(def, enforced) {
-			enforcedJson, _ := json.Marshal(enforced)
-			return fmt.Errorf("invalid default value (%#v) for non-pointer/non-omitempty. If specified, must be: %v", def, string(enforcedJson))
-		}
-	}
-	if def != nil {
-		g.Do("Default: $.$,\n", fmt.Sprintf("%#v", def))
-	} else if ref != nil {
-		g.Do("Default: $.|raw$,\n", &types.Type{Name: *ref})
-	}
-	return nil
-}
-
-func (g openAPITypeWriter) generateDescription(CommentLines []string) {
-	var buffer bytes.Buffer
-	delPrevChar := func() {
-		if buffer.Len() > 0 {
-			buffer.Truncate(buffer.Len() - 1) // Delete the last " " or "\n"
-		}
-	}
-
-	for _, line := range CommentLines {
-		// Ignore all lines after ---
-		if line == "---" {
-			break
-		}
-		line = strings.TrimRight(line, " ")
-		leading := strings.TrimLeft(line, " ")
-		switch {
-		case len(line) == 0: // Keep paragraphs
-			delPrevChar()
-			buffer.WriteString("\n\n")
-		case strings.HasPrefix(leading, "TODO"): // Ignore one line TODOs
-		case strings.HasPrefix(leading, "+"): // Ignore instructions to go2idl
-		default:
-			if strings.HasPrefix(line, " ") || strings.HasPrefix(line, "\t") {
-				delPrevChar()
-				line = "\n" + line + "\n" // Replace it with newline. This is useful when we have a line with: "Example:\n\tJSON-something..."
-			} else {
-				line += " "
-			}
-			buffer.WriteString(line)
-		}
-	}
-
-	postDoc := strings.TrimLeft(buffer.String(), "\n")
-	postDoc = strings.TrimRight(postDoc, "\n")
-	postDoc = strings.Replace(postDoc, "\\\"", "\"", -1) // replace user's \" to "
-	postDoc = strings.Replace(postDoc, "\"", "\\\"", -1) // Escape "
-	postDoc = strings.Replace(postDoc, "\n", "\\n", -1)
-	postDoc = strings.Replace(postDoc, "\t", "\\t", -1)
-	postDoc = strings.Trim(postDoc, " ")
-	if postDoc != "" {
-		g.Do("Description: \"$.$\",\n", postDoc)
-	}
-}
-
-func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type) error {
-	name := getReferableName(m)
-	if name == "" {
-		return nil
-	}
-	validationSchema, err := ParseCommentTags(m.Type, m.CommentLines, markerPrefix)
-	if err != nil {
-		return err
-	}
-	if err := g.validatePatchTags(m, parent); err != nil {
-		return err
-	}
-	g.Do("\"$.$\": {\n", name)
-	if err := g.generateMemberExtensions(m, parent, validationSchema.Extensions); err != nil {
-		return err
-	}
-	g.Do("SchemaProps: spec.SchemaProps{\n", nil)
-	var extraComments []string
-	if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum {
-		extraComments = enumType.DescriptionLines()
-	}
-	g.generateDescription(append(m.CommentLines, extraComments...))
-	jsonTags := getJsonTags(m)
-	if len(jsonTags) > 1 && jsonTags[1] == "string" {
-		g.generateSimpleProperty("string", "")
-		g.Do("},\n},\n", nil)
-		return nil
-	}
-	omitEmpty := strings.Contains(reflect.StructTag(m.Tags).Get("json"), "omitempty")
-	if err := g.generateDefault(m.CommentLines, m.Type, omitEmpty, parent); err != nil {
-		return fmt.Errorf("failed to generate default in %v: %v: %v", parent, m.Name, err)
-	}
-	err = g.generateValueValidations(&validationSchema.SchemaProps)
-	if err != nil {
-		return err
-	}
-	t := resolveAliasAndPtrType(m.Type)
-	// If we can get a openAPI type and format for this type, we consider it to be simple property
-	typeString, format := openapi.OpenAPITypeFormat(t.String())
-	if typeString != "" {
-		g.generateSimpleProperty(typeString, format)
-		if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum {
-			// original type is an enum, add "Enum: " and the values
-			g.Do("Enum: []interface{}{$.$},\n", strings.Join(enumType.ValueStrings(), ", "))
-		}
-		g.Do("},\n},\n", nil)
-		return nil
-	}
-	switch t.Kind {
-	case types.Builtin:
-		return fmt.Errorf("please add type %v to getOpenAPITypeFormat function", t)
-	case types.Map:
-		if err := g.generateMapProperty(t); err != nil {
-			return fmt.Errorf("failed to generate map property in %v: %v: %v", parent, m.Name, err)
-		}
-	case types.Slice, types.Array:
-		if err := g.generateSliceProperty(t); err != nil {
-			return fmt.Errorf("failed to generate slice property in %v: %v: %v", parent, m.Name, err)
-		}
-	case types.Struct, types.Interface:
-		g.generateReferenceProperty(t)
-	default:
-		return fmt.Errorf("cannot generate spec for type %v", t)
-	}
-	g.Do("},\n},\n", nil)
-	return g.Error()
-}
-
-func (g openAPITypeWriter) generateSimpleProperty(typeString, format string) {
-	g.Do("Type: []string{\"$.$\"},\n", typeString)
-	g.Do("Format: \"$.$\",\n", format)
-}
-
-func (g openAPITypeWriter) generateReferenceProperty(t *types.Type) {
-	g.refTypes[t.Name.String()] = t
-	g.Do("Ref: ref(\"$.$\"),\n", t.Name.String())
-}
-
-func resolveAliasAndPtrType(t *types.Type) *types.Type {
-	var prev *types.Type
-	for prev != t {
-		prev = t
-		if t.Kind == types.Alias {
-			t = t.Underlying
-		}
-		if t.Kind == types.Pointer {
-			t = t.Elem
-		}
-	}
-	return t
-}
-
-func (g openAPITypeWriter) generateMapProperty(t *types.Type) error {
-	keyType := resolveAliasAndPtrType(t.Key)
-	elemType := resolveAliasAndPtrType(t.Elem)
-
-	// According to OpenAPI examples, only map from string is supported
-	if keyType.Name.Name != "string" {
-		return fmt.Errorf("map with non-string keys are not supported by OpenAPI in %v", t)
-	}
-
-	g.Do("Type: []string{\"object\"},\n", nil)
-	g.Do("AdditionalProperties: &spec.SchemaOrBool{\nAllows: true,\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
-	if err := g.generateDefault(t.Elem.CommentLines, t.Elem, false, t.Elem); err != nil {
-		return err
-	}
-	typeString, format := openapi.OpenAPITypeFormat(elemType.String())
-	if typeString != "" {
-		g.generateSimpleProperty(typeString, format)
-		if enumType, isEnum := g.enumContext.EnumType(t.Elem); isEnum {
-			// original type is an enum, add "Enum: " and the values
-			g.Do("Enum: []interface{}{$.$},\n", strings.Join(enumType.ValueStrings(), ", "))
-		}
-		g.Do("},\n},\n},\n", nil)
-		return nil
-	}
-	switch elemType.Kind {
-	case types.Builtin:
-		return fmt.Errorf("please add type %v to getOpenAPITypeFormat function", elemType)
-	case types.Struct:
-		g.generateReferenceProperty(elemType)
-	case types.Slice, types.Array:
-		if err := g.generateSliceProperty(elemType); err != nil {
-			return err
-		}
-	case types.Map:
-		if err := g.generateMapProperty(elemType); err != nil {
-			return err
-		}
-	default:
-		return fmt.Errorf("map Element kind %v is not supported in %v", elemType.Kind, t.Name)
-	}
-	g.Do("},\n},\n},\n", nil)
-	return nil
-}
-
-func (g openAPITypeWriter) generateSliceProperty(t *types.Type) error {
-	elemType := resolveAliasAndPtrType(t.Elem)
-	g.Do("Type: []string{\"array\"},\n", nil)
-	g.Do("Items: &spec.SchemaOrArray{\nSchema: &spec.Schema{\nSchemaProps: spec.SchemaProps{\n", nil)
-	if err := g.generateDefault(t.Elem.CommentLines, t.Elem, false, t.Elem); err != nil {
-		return err
-	}
-	typeString, format := openapi.OpenAPITypeFormat(elemType.String())
-	if typeString != "" {
-		g.generateSimpleProperty(typeString, format)
-		if enumType, isEnum := g.enumContext.EnumType(t.Elem); isEnum {
-			// original type is an enum, add "Enum: " and the values
-			g.Do("Enum: []interface{}{$.$},\n", strings.Join(enumType.ValueStrings(), ", "))
-		}
-		g.Do("},\n},\n},\n", nil)
-		return nil
-	}
-	switch elemType.Kind {
-	case types.Builtin:
-		return fmt.Errorf("please add type %v to getOpenAPITypeFormat function", elemType)
-	case types.Struct:
-		g.generateReferenceProperty(elemType)
-	case types.Slice, types.Array:
-		if err := g.generateSliceProperty(elemType); err != nil {
-			return err
-		}
-	case types.Map:
-		if err := g.generateMapProperty(elemType); err != nil {
-			return err
-		}
-	default:
-		return fmt.Errorf("slice Element kind %v is not supported in %v", elemType.Kind, t)
-	}
-	g.Do("},\n},\n},\n", nil)
-	return nil
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/rules/OWNERS b/vendor/k8s.io/kube-openapi/pkg/generators/rules/OWNERS
deleted file mode 100644
index 235bc545..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/rules/OWNERS
+++ /dev/null
@@ -1,4 +0,0 @@
-reviewers:
-- roycaihw
-approvers:
-- roycaihw
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/rules/doc.go b/vendor/k8s.io/kube-openapi/pkg/generators/rules/doc.go
deleted file mode 100644
index 384a44dc..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/rules/doc.go
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Package rules contains API rules that are enforced in OpenAPI spec generation
-// as part of the machinery. Files under this package implement APIRule interface
-// which evaluates Go type and produces list of API rule violations.
-//
-// Implementations of APIRule should be added to API linter under openAPIGen code-
-// generator to get integrated in the generation process.
-package rules
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/rules/idl_tag.go b/vendor/k8s.io/kube-openapi/pkg/generators/rules/idl_tag.go
deleted file mode 100644
index e4b0f7cd..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/rules/idl_tag.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package rules
-
-import (
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/types"
-)
-
-const ListTypeIDLTag = "listType"
-
-// ListTypeMissing implements APIRule interface.
-// A list type is required for inlined list.
-type ListTypeMissing struct{}
-
-// Name returns the name of APIRule
-func (l *ListTypeMissing) Name() string {
-	return "list_type_missing"
-}
-
-// Validate evaluates API rule on type t and returns a list of field names in
-// the type that violate the rule. Empty field name [""] implies the entire
-// type violates the rule.
-func (l *ListTypeMissing) Validate(t *types.Type) ([]string, error) {
-	fields := make([]string, 0)
-
-	switch t.Kind {
-	case types.Struct:
-		for _, m := range t.Members {
-			hasListType := gengo.ExtractCommentTags("+", m.CommentLines)[ListTypeIDLTag] != nil
-
-			if m.Name == "Items" && m.Type.Kind == types.Slice && hasNamedMember(t, "ListMeta") {
-				if hasListType {
-					fields = append(fields, m.Name)
-				}
-				continue
-			}
-
-			// All slice fields must have a list-type tag except []byte
-			if m.Type.Kind == types.Slice && m.Type.Elem != types.Byte && !hasListType {
-				fields = append(fields, m.Name)
-				continue
-			}
-		}
-	}
-
-	return fields, nil
-}
-
-func hasNamedMember(t *types.Type, name string) bool {
-	for _, m := range t.Members {
-		if m.Name == name {
-			return true
-		}
-	}
-	return false
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/rules/names_match.go b/vendor/k8s.io/kube-openapi/pkg/generators/rules/names_match.go
deleted file mode 100644
index af30edc5..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/rules/names_match.go
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package rules
-
-import (
-	"reflect"
-	"strings"
-
-	"k8s.io/kube-openapi/pkg/util/sets"
-
-	"k8s.io/gengo/v2/types"
-)
-
-var (
-	// Blacklist of JSON tags that should skip match evaluation
-	jsonTagBlacklist = sets.NewString(
-		// Omitted field is ignored by the package
-		"-",
-	)
-
-	// Blacklist of JSON names that should skip match evaluation
-	jsonNameBlacklist = sets.NewString(
-		// Empty name is used for inline struct field (e.g. metav1.TypeMeta)
-		"",
-		// Special case for object and list meta
-		"metadata",
-	)
-
-	// List of substrings that aren't allowed in Go name and JSON name
-	disallowedNameSubstrings = sets.NewString(
-		// Underscore is not allowed in either name
-		"_",
-		// Dash is not allowed in either name. Note that since dash is a valid JSON tag, this should be checked
-		// after JSON tag blacklist check.
-		"-",
-	)
-)
-
-/*
-NamesMatch implements APIRule interface.
-Go field names must be CamelCase. JSON field names must be camelCase. Other than capitalization of the
-initial letter, the two should almost always match. No underscores nor dashes in either.
-This rule verifies the convention "Other than capitalization of the initial letter, the two should almost always match."
-Examples (also in unit test):
-
-	Go name      | JSON name    | match
-	               podSpec        false
-	PodSpec        podSpec        true
-	PodSpec        PodSpec        false
-	podSpec        podSpec        false
-	PodSpec        spec           false
-	Spec           podSpec        false
-	JSONSpec       jsonSpec       true
-	JSONSpec       jsonspec       false
-	HTTPJSONSpec   httpJSONSpec   true
-
-NOTE: this validator cannot tell two sequential all-capital words from one word, therefore the case below
-is also considered matched.
-
-	HTTPJSONSpec   httpjsonSpec   true
-
-NOTE: JSON names in jsonNameBlacklist should skip evaluation
-
-	                              true
-	podSpec                       true
-	podSpec        -              true
-	podSpec        metadata       true
-*/
-type NamesMatch struct{}
-
-// Name returns the name of APIRule
-func (n *NamesMatch) Name() string {
-	return "names_match"
-}
-
-// Validate evaluates API rule on type t and returns a list of field names in
-// the type that violate the rule. Empty field name [""] implies the entire
-// type violates the rule.
-func (n *NamesMatch) Validate(t *types.Type) ([]string, error) {
-	fields := make([]string, 0)
-
-	// Only validate struct type and ignore the rest
-	switch t.Kind {
-	case types.Struct:
-		for _, m := range t.Members {
-			goName := m.Name
-			jsonTag, ok := reflect.StructTag(m.Tags).Lookup("json")
-			// Distinguish empty JSON tag and missing JSON tag. Empty JSON tag / name is
-			// allowed (in JSON name blacklist) but missing JSON tag is invalid.
-			if !ok {
-				fields = append(fields, goName)
-				continue
-			}
-			if jsonTagBlacklist.Has(jsonTag) {
-				continue
-			}
-			jsonName := strings.Split(jsonTag, ",")[0]
-			if !namesMatch(goName, jsonName) {
-				fields = append(fields, goName)
-			}
-		}
-	}
-	return fields, nil
-}
-
-// namesMatch evaluates if goName and jsonName match the API rule
-// TODO: Use an off-the-shelf CamelCase solution instead of implementing this logic. The following existing
-//
-//	      packages have been tried out:
-//			github.com/markbates/inflect
-//			github.com/segmentio/go-camelcase
-//			github.com/iancoleman/strcase
-//			github.com/fatih/camelcase
-//		 Please see https://github.com/kubernetes/kube-openapi/pull/83#issuecomment-400842314 for more details
-//		 about why they don't satisfy our need. What we need can be a function that detects an acronym at the
-//		 beginning of a string.
-func namesMatch(goName, jsonName string) bool {
-	if jsonNameBlacklist.Has(jsonName) {
-		return true
-	}
-	if !isAllowedName(goName) || !isAllowedName(jsonName) {
-		return false
-	}
-	if !strings.EqualFold(goName, jsonName) {
-		return false
-	}
-	// Go field names must be CamelCase. JSON field names must be camelCase.
-	if !isCapital(goName[0]) || isCapital(jsonName[0]) {
-		return false
-	}
-	for i := 0; i < len(goName); i++ {
-		if goName[i] == jsonName[i] {
-			// goName[0:i-1] is uppercase and jsonName[0:i-1] is lowercase, goName[i:]
-			// and jsonName[i:] should match;
-			// goName[i] should be lowercase if i is equal to 1, e.g.:
-			//	goName   | jsonName
-			//	PodSpec     podSpec
-			// or uppercase if i is greater than 1, e.g.:
-			//      goname   | jsonName
-			//      JSONSpec   jsonSpec
-			// This is to rule out cases like:
-			//      goname   | jsonName
-			//      JSONSpec   jsonspec
-			return goName[i:] == jsonName[i:] && (i == 1 || isCapital(goName[i]))
-		}
-	}
-	return true
-}
-
-// isCapital returns true if one character is capital
-func isCapital(b byte) bool {
-	return b >= 'A' && b <= 'Z'
-}
-
-// isAllowedName checks the list of disallowedNameSubstrings and returns true if name doesn't contain
-// any disallowed substring.
-func isAllowedName(name string) bool {
-	for _, substr := range disallowedNameSubstrings.UnsortedList() {
-		if strings.Contains(name, substr) {
-			return false
-		}
-	}
-	return true
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/rules/omitempty_match_case.go b/vendor/k8s.io/kube-openapi/pkg/generators/rules/omitempty_match_case.go
deleted file mode 100644
index d8387596..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/rules/omitempty_match_case.go
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-Copyright 2018 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package rules
-
-import (
-	"reflect"
-	"strings"
-
-	"k8s.io/gengo/v2/types"
-)
-
-// OmitEmptyMatchCase implements APIRule interface.
-// "omitempty" must appear verbatim (no case variants).
-type OmitEmptyMatchCase struct{}
-
-func (n *OmitEmptyMatchCase) Name() string {
-	return "omitempty_match_case"
-}
-
-func (n *OmitEmptyMatchCase) Validate(t *types.Type) ([]string, error) {
-	fields := make([]string, 0)
-
-	// Only validate struct type and ignore the rest
-	switch t.Kind {
-	case types.Struct:
-		for _, m := range t.Members {
-			goName := m.Name
-			jsonTag, ok := reflect.StructTag(m.Tags).Lookup("json")
-			if !ok {
-				continue
-			}
-
-			parts := strings.Split(jsonTag, ",")
-			if len(parts) < 2 {
-				// no tags other than name
-				continue
-			}
-			if parts[0] == "-" {
-				// not serialized
-				continue
-			}
-			for _, part := range parts[1:] {
-				if strings.EqualFold(part, "omitempty") && part != "omitempty" {
-					fields = append(fields, goName)
-				}
-			}
-		}
-	}
-	return fields, nil
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/generators/union.go b/vendor/k8s.io/kube-openapi/pkg/generators/union.go
deleted file mode 100644
index bfcba1ad..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/generators/union.go
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-Copyright 2016 The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package generators
-
-import (
-	"fmt"
-	"sort"
-
-	"k8s.io/gengo/v2"
-	"k8s.io/gengo/v2/types"
-)
-
-const tagUnionMember = "union"
-const tagUnionDeprecated = "unionDeprecated"
-const tagUnionDiscriminator = "unionDiscriminator"
-
-type union struct {
-	discriminator         string
-	fieldsToDiscriminated map[string]string
-}
-
-// emit prints the union, can be called on a nil union (emits nothing)
-func (u *union) emit(g openAPITypeWriter) {
-	if u == nil {
-		return
-	}
-	g.Do("map[string]interface{}{\n", nil)
-	if u.discriminator != "" {
-		g.Do("\"discriminator\": \"$.$\",\n", u.discriminator)
-	}
-	g.Do("\"fields-to-discriminateBy\": map[string]interface{}{\n", nil)
-	keys := []string{}
-	for field := range u.fieldsToDiscriminated {
-		keys = append(keys, field)
-	}
-	sort.Strings(keys)
-	for _, field := range keys {
-		g.Do("\"$.$\": ", field)
-		g.Do("\"$.$\",\n", u.fieldsToDiscriminated[field])
-	}
-	g.Do("},\n", nil)
-	g.Do("},\n", nil)
-}
-
-// Sets the discriminator if it's not set yet, otherwise return an error
-func (u *union) setDiscriminator(value string) []error {
-	errors := []error{}
-	if u.discriminator != "" {
-		errors = append(errors, fmt.Errorf("at least two discriminators found: %v and %v", value, u.discriminator))
-	}
-	u.discriminator = value
-	return errors
-}
-
-// Add a new member to the union
-func (u *union) addMember(jsonName, variableName string) {
-	if _, ok := u.fieldsToDiscriminated[jsonName]; ok {
-		panic(fmt.Errorf("same field (%v) found multiple times", jsonName))
-	}
-	u.fieldsToDiscriminated[jsonName] = variableName
-}
-
-// Makes sure that the union is valid, specifically looking for re-used discriminated
-func (u *union) isValid() []error {
-	errors := []error{}
-	// Case 1: discriminator but no fields
-	if u.discriminator != "" && len(u.fieldsToDiscriminated) == 0 {
-		errors = append(errors, fmt.Errorf("discriminator set with no fields in union"))
-	}
-	// Case 2: two fields have the same discriminated value
-	discriminated := map[string]struct{}{}
-	for _, d := range u.fieldsToDiscriminated {
-		if _, ok := discriminated[d]; ok {
-			errors = append(errors, fmt.Errorf("discriminated value is used twice: %v", d))
-		}
-		discriminated[d] = struct{}{}
-	}
-	// Case 3: a field is both discriminator AND part of the union
-	if u.discriminator != "" {
-		if _, ok := u.fieldsToDiscriminated[u.discriminator]; ok {
-			errors = append(errors, fmt.Errorf("%v can't be both discriminator and part of the union", u.discriminator))
-		}
-	}
-	return errors
-}
-
-// Find unions either directly on the members (or inlined members, not
-// going across types) or on the type itself, or on embedded types.
-func parseUnions(t *types.Type) ([]union, []error) {
-	errors := []error{}
-	unions := []union{}
-	su, err := parseUnionStruct(t)
-	if su != nil {
-		unions = append(unions, *su)
-	}
-	errors = append(errors, err...)
-	eu, err := parseEmbeddedUnion(t)
-	unions = append(unions, eu...)
-	errors = append(errors, err...)
-	mu, err := parseUnionMembers(t)
-	if mu != nil {
-		unions = append(unions, *mu)
-	}
-	errors = append(errors, err...)
-	return unions, errors
-}
-
-// Find unions in embedded types, unions shouldn't go across types.
-func parseEmbeddedUnion(t *types.Type) ([]union, []error) {
-	errors := []error{}
-	unions := []union{}
-	for _, m := range t.Members {
-		if hasOpenAPITagValue(m.CommentLines, tagValueFalse) {
-			continue
-		}
-		if !shouldInlineMembers(&m) {
-			continue
-		}
-		u, err := parseUnions(m.Type)
-		unions = append(unions, u...)
-		errors = append(errors, err...)
-	}
-	return unions, errors
-}
-
-// Look for union tag on a struct, and then include all the fields
-// (except the discriminator if there is one). The struct shouldn't have
-// embedded types.
-func parseUnionStruct(t *types.Type) (*union, []error) {
-	errors := []error{}
-	if gengo.ExtractCommentTags("+", t.CommentLines)[tagUnionMember] == nil {
-		return nil, nil
-	}
-
-	u := &union{fieldsToDiscriminated: map[string]string{}}
-
-	for _, m := range t.Members {
-		jsonName := getReferableName(&m)
-		if jsonName == "" {
-			continue
-		}
-		if shouldInlineMembers(&m) {
-			errors = append(errors, fmt.Errorf("union structures can't have embedded fields: %v.%v", t.Name, m.Name))
-			continue
-		}
-		if gengo.ExtractCommentTags("+", m.CommentLines)[tagUnionDeprecated] != nil {
-			errors = append(errors, fmt.Errorf("union struct can't have unionDeprecated members: %v.%v", t.Name, m.Name))
-			continue
-		}
-		if gengo.ExtractCommentTags("+", m.CommentLines)[tagUnionDiscriminator] != nil {
-			errors = append(errors, u.setDiscriminator(jsonName)...)
-		} else {
-			if optional, err := isOptional(&m); !optional || err != nil {
-				errors = append(errors, fmt.Errorf("union members must be optional: %v.%v", t.Name, m.Name))
-			}
-			u.addMember(jsonName, m.Name)
-		}
-	}
-
-	return u, errors
-}
-
-// Find unions specifically on members.
-func parseUnionMembers(t *types.Type) (*union, []error) {
-	errors := []error{}
-	u := &union{fieldsToDiscriminated: map[string]string{}}
-
-	for _, m := range t.Members {
-		jsonName := getReferableName(&m)
-		if jsonName == "" {
-			continue
-		}
-		if shouldInlineMembers(&m) {
-			continue
-		}
-		if gengo.ExtractCommentTags("+", m.CommentLines)[tagUnionDiscriminator] != nil {
-			errors = append(errors, u.setDiscriminator(jsonName)...)
-		}
-		if gengo.ExtractCommentTags("+", m.CommentLines)[tagUnionMember] != nil {
-			errors = append(errors, fmt.Errorf("union tag is not accepted on struct members: %v.%v", t.Name, m.Name))
-			continue
-		}
-		if gengo.ExtractCommentTags("+", m.CommentLines)[tagUnionDeprecated] != nil {
-			if optional, err := isOptional(&m); !optional || err != nil {
-				errors = append(errors, fmt.Errorf("union members must be optional: %v.%v", t.Name, m.Name))
-			}
-			u.addMember(jsonName, m.Name)
-		}
-	}
-	if len(u.fieldsToDiscriminated) == 0 {
-		return nil, nil
-	}
-	return u, append(errors, u.isValid()...)
-}
diff --git a/vendor/k8s.io/kube-openapi/pkg/util/sets/empty.go b/vendor/k8s.io/kube-openapi/pkg/util/sets/empty.go
deleted file mode 100644
index 13303ea8..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/util/sets/empty.go
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by set-gen. DO NOT EDIT.
-
-// NOTE: This file is copied from k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/sets/empty.go
-// because in Kubernetes we don't allowed vendor code to import staging code. See
-// https://github.com/kubernetes/kube-openapi/pull/90 for more details.
-
-package sets
-
-// Empty is public since it is used by some internal API objects for conversions between external
-// string arrays and internal sets, and conversion logic requires public types today.
-type Empty struct{}
diff --git a/vendor/k8s.io/kube-openapi/pkg/util/sets/string.go b/vendor/k8s.io/kube-openapi/pkg/util/sets/string.go
deleted file mode 100644
index 53f2bc12..00000000
--- a/vendor/k8s.io/kube-openapi/pkg/util/sets/string.go
+++ /dev/null
@@ -1,207 +0,0 @@
-/*
-Copyright The Kubernetes Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-// Code generated by set-gen. DO NOT EDIT.
-
-// NOTE: This file is copied from k8s.io/kubernetes/vendor/k8s.io/apimachinery/pkg/util/sets/string.go
-// because in Kubernetes we don't allowed vendor code to import staging code. See
-// https://github.com/kubernetes/kube-openapi/pull/90 for more details.
-
-package sets
-
-import (
-	"reflect"
-	"sort"
-)
-
-// sets.String is a set of strings, implemented via map[string]struct{} for minimal memory consumption.
-type String map[string]Empty
-
-// NewString creates a String from a list of values.
-func NewString(items ...string) String {
-	ss := String{}
-	ss.Insert(items...)
-	return ss
-}
-
-// StringKeySet creates a String from a keys of a map[string](? extends interface{}).
-// If the value passed in is not actually a map, this will panic.
-func StringKeySet(theMap interface{}) String {
-	v := reflect.ValueOf(theMap)
-	ret := String{}
-
-	for _, keyValue := range v.MapKeys() {
-		ret.Insert(keyValue.Interface().(string))
-	}
-	return ret
-}
-
-// Insert adds items to the set.
-func (s String) Insert(items ...string) {
-	for _, item := range items {
-		s[item] = Empty{}
-	}
-}
-
-// Delete removes all items from the set.
-func (s String) Delete(items ...string) {
-	for _, item := range items {
-		delete(s, item)
-	}
-}
-
-// Has returns true if and only if item is contained in the set.
-func (s String) Has(item string) bool {
-	_, contained := s[item]
-	return contained
-}
-
-// HasAll returns true if and only if all items are contained in the set.
-func (s String) HasAll(items ...string) bool {
-	for _, item := range items {
-		if !s.Has(item) {
-			return false
-		}
-	}
-	return true
-}
-
-// HasAny returns true if any items are contained in the set.
-func (s String) HasAny(items ...string) bool {
-	for _, item := range items {
-		if s.Has(item) {
-			return true
-		}
-	}
-	return false
-}
-
-// Difference returns a set of objects that are not in s2
-// For example:
-// s1 = {a1, a2, a3}
-// s2 = {a1, a2, a4, a5}
-// s1.Difference(s2) = {a3}
-// s2.Difference(s1) = {a4, a5}
-func (s String) Difference(s2 String) String {
-	result := NewString()
-	for key := range s {
-		if !s2.Has(key) {
-			result.Insert(key)
-		}
-	}
-	return result
-}
-
-// Union returns a new set which includes items in either s1 or s2.
-// For example:
-// s1 = {a1, a2}
-// s2 = {a3, a4}
-// s1.Union(s2) = {a1, a2, a3, a4}
-// s2.Union(s1) = {a1, a2, a3, a4}
-func (s1 String) Union(s2 String) String {
-	result := NewString()
-	for key := range s1 {
-		result.Insert(key)
-	}
-	for key := range s2 {
-		result.Insert(key)
-	}
-	return result
-}
-
-// Intersection returns a new set which includes the item in BOTH s1 and s2
-// For example:
-// s1 = {a1, a2}
-// s2 = {a2, a3}
-// s1.Intersection(s2) = {a2}
-func (s1 String) Intersection(s2 String) String {
-	var walk, other String
-	result := NewString()
-	if s1.Len() < s2.Len() {
-		walk = s1
-		other = s2
-	} else {
-		walk = s2
-		other = s1
-	}
-	for key := range walk {
-		if other.Has(key) {
-			result.Insert(key)
-		}
-	}
-	return result
-}
-
-// IsSuperset returns true if and only if s1 is a superset of s2.
-func (s1 String) IsSuperset(s2 String) bool {
-	for item := range s2 {
-		if !s1.Has(item) {
-			return false
-		}
-	}
-	return true
-}
-
-// Equal returns true if and only if s1 is equal (as a set) to s2.
-// Two sets are equal if their membership is identical.
-// (In practice, this means same elements, order doesn't matter)
-func (s1 String) Equal(s2 String) bool {
-	return len(s1) == len(s2) && s1.IsSuperset(s2)
-}
-
-type sortableSliceOfString []string
-
-func (s sortableSliceOfString) Len() int           { return len(s) }
-func (s sortableSliceOfString) Less(i, j int) bool { return lessString(s[i], s[j]) }
-func (s sortableSliceOfString) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
-// List returns the contents as a sorted string slice.
-func (s String) List() []string {
-	res := make(sortableSliceOfString, 0, len(s))
-	for key := range s {
-		res = append(res, key)
-	}
-	sort.Sort(res)
-	return []string(res)
-}
-
-// UnsortedList returns the slice with contents in random order.
-func (s String) UnsortedList() []string {
-	res := make([]string, 0, len(s))
-	for key := range s {
-		res = append(res, key)
-	}
-	return res
-}
-
-// Returns a single element from the set.
-func (s String) PopAny() (string, bool) {
-	for key := range s {
-		s.Delete(key)
-		return key, true
-	}
-	var zeroValue string
-	return zeroValue, false
-}
-
-// Len returns the size of the set.
-func (s String) Len() int {
-	return len(s)
-}
-
-func lessString(lhs, rhs string) bool {
-	return lhs < rhs
-}
diff --git a/vendor/k8s.io/kubernetes/pkg/scheduler/framework/preemption/preemption.go b/vendor/k8s.io/kubernetes/pkg/scheduler/framework/preemption/preemption.go
index 25ee8b47..29864adb 100644
--- a/vendor/k8s.io/kubernetes/pkg/scheduler/framework/preemption/preemption.go
+++ b/vendor/k8s.io/kubernetes/pkg/scheduler/framework/preemption/preemption.go
@@ -369,7 +369,7 @@ func (ev *Evaluator) prepareCandidate(ctx context.Context, c Candidate, pod *v1.
 					Reason:  v1.PodReasonPreemptionByScheduler,
 					Message: fmt.Sprintf("%s: preempting to accommodate a higher priority pod", pod.Spec.SchedulerName),
 				}
-				newStatus := victim.Status.DeepCopy()
+				newStatus := pod.Status.DeepCopy()
 				updated := apipod.UpdatePodCondition(newStatus, condition)
 				if updated {
 					if err := util.PatchPodStatus(ctx, cs, victim, newStatus); err != nil {
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 808c2c4d..1bbcb4b1 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -342,7 +342,6 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry
 ## explicit; go 1.20
 go.opentelemetry.io/otel/metric
 go.opentelemetry.io/otel/metric/embedded
-go.opentelemetry.io/otel/metric/noop
 # go.opentelemetry.io/otel/sdk v1.21.0 => go.opentelemetry.io/otel/sdk v1.21.0
 ## explicit; go 1.20
 go.opentelemetry.io/otel/sdk
@@ -636,7 +635,7 @@ gopkg.in/yaml.v2
 # gopkg.in/yaml.v3 v3.0.1
 ## explicit
 gopkg.in/yaml.v3
-# k8s.io/api v0.30.6 => k8s.io/api v0.30.6
+# k8s.io/api v0.30.4 => k8s.io/api v0.30.4
 ## explicit; go 1.22.0
 k8s.io/api/admission/v1
 k8s.io/api/admission/v1beta1
@@ -694,7 +693,7 @@ k8s.io/api/storage/v1
 k8s.io/api/storage/v1alpha1
 k8s.io/api/storage/v1beta1
 k8s.io/api/storagemigration/v1alpha1
-# k8s.io/apiextensions-apiserver v0.30.6 => k8s.io/apiextensions-apiserver v0.30.6
+# k8s.io/apiextensions-apiserver v0.30.4 => k8s.io/apiextensions-apiserver v0.30.4
 ## explicit; go 1.22.0
 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions
 k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1
@@ -706,7 +705,7 @@ k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/scheme
 k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1
 k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/typed/apiextensions/v1beta1
 k8s.io/apiextensions-apiserver/pkg/features
-# k8s.io/apimachinery v0.30.6 => k8s.io/apimachinery v0.30.6
+# k8s.io/apimachinery v0.30.4 => k8s.io/apimachinery v0.30.4
 ## explicit; go 1.22.0
 k8s.io/apimachinery/pkg/api/equality
 k8s.io/apimachinery/pkg/api/errors
@@ -767,7 +766,7 @@ k8s.io/apimachinery/pkg/version
 k8s.io/apimachinery/pkg/watch
 k8s.io/apimachinery/third_party/forked/golang/json
 k8s.io/apimachinery/third_party/forked/golang/reflect
-# k8s.io/apiserver v0.30.6 => k8s.io/apiserver v0.30.6
+# k8s.io/apiserver v0.30.4 => k8s.io/apiserver v0.30.4
 ## explicit; go 1.22.0
 k8s.io/apiserver/pkg/admission
 k8s.io/apiserver/pkg/admission/configuration
@@ -915,7 +914,7 @@ k8s.io/apiserver/plugin/pkg/audit/webhook
 k8s.io/apiserver/plugin/pkg/authenticator/token/webhook
 k8s.io/apiserver/plugin/pkg/authorizer/webhook
 k8s.io/apiserver/plugin/pkg/authorizer/webhook/metrics
-# k8s.io/client-go v0.30.6 => k8s.io/client-go v0.30.6
+# k8s.io/client-go v0.30.4 => k8s.io/client-go v0.30.4
 ## explicit; go 1.22.0
 k8s.io/client-go/applyconfigurations/admissionregistration/v1
 k8s.io/client-go/applyconfigurations/admissionregistration/v1alpha1
@@ -1236,7 +1235,7 @@ k8s.io/client-go/util/homedir
 k8s.io/client-go/util/keyutil
 k8s.io/client-go/util/retry
 k8s.io/client-go/util/workqueue
-# k8s.io/cloud-provider v0.30.6 => k8s.io/cloud-provider v0.30.6
+# k8s.io/cloud-provider v0.30.4 => k8s.io/cloud-provider v0.30.4
 ## explicit; go 1.22.0
 k8s.io/cloud-provider
 k8s.io/cloud-provider/app/config
@@ -1251,7 +1250,7 @@ k8s.io/cloud-provider/names
 k8s.io/cloud-provider/options
 k8s.io/cloud-provider/volume
 k8s.io/cloud-provider/volume/helpers
-# k8s.io/code-generator v0.30.6 => k8s.io/code-generator v0.30.6
+# k8s.io/code-generator v0.30.4 => k8s.io/code-generator v0.30.4
 ## explicit; go 1.22.0
 k8s.io/code-generator
 k8s.io/code-generator/cmd/applyconfiguration-gen
@@ -1287,7 +1286,7 @@ k8s.io/code-generator/cmd/register-gen/generators
 k8s.io/code-generator/pkg/namer
 k8s.io/code-generator/pkg/util
 k8s.io/code-generator/third_party/forked/golang/reflect
-# k8s.io/component-base v0.30.6 => k8s.io/component-base v0.30.6
+# k8s.io/component-base v0.30.4 => k8s.io/component-base v0.30.4
 ## explicit; go 1.22.0
 k8s.io/component-base/cli
 k8s.io/component-base/cli/flag
@@ -1319,7 +1318,7 @@ k8s.io/component-base/tracing
 k8s.io/component-base/tracing/api/v1
 k8s.io/component-base/version
 k8s.io/component-base/version/verflag
-# k8s.io/component-helpers v0.30.6 => k8s.io/component-helpers v0.30.6
+# k8s.io/component-helpers v0.30.4 => k8s.io/component-helpers v0.30.4
 ## explicit; go 1.22.0
 k8s.io/component-helpers/node/topology
 k8s.io/component-helpers/node/util/sysctl
@@ -1327,7 +1326,7 @@ k8s.io/component-helpers/scheduling/corev1
 k8s.io/component-helpers/scheduling/corev1/nodeaffinity
 k8s.io/component-helpers/storage/ephemeral
 k8s.io/component-helpers/storage/volume
-# k8s.io/controller-manager v0.30.6 => k8s.io/controller-manager v0.30.6
+# k8s.io/controller-manager v0.30.4 => k8s.io/controller-manager v0.30.4
 ## explicit; go 1.22.0
 k8s.io/controller-manager/config
 k8s.io/controller-manager/config/v1
@@ -1339,11 +1338,11 @@ k8s.io/controller-manager/pkg/features
 k8s.io/controller-manager/pkg/features/register
 k8s.io/controller-manager/pkg/leadermigration/config
 k8s.io/controller-manager/pkg/leadermigration/options
-# k8s.io/csi-translation-lib v0.30.6 => k8s.io/csi-translation-lib v0.30.6
+# k8s.io/csi-translation-lib v0.30.4 => k8s.io/csi-translation-lib v0.30.4
 ## explicit; go 1.22.0
 k8s.io/csi-translation-lib
 k8s.io/csi-translation-lib/plugins
-# k8s.io/dynamic-resource-allocation v0.30.6 => k8s.io/dynamic-resource-allocation v0.30.6
+# k8s.io/dynamic-resource-allocation v0.30.4 => k8s.io/dynamic-resource-allocation v0.30.4
 ## explicit; go 1.22.0
 k8s.io/dynamic-resource-allocation/resourceclaim
 k8s.io/dynamic-resource-allocation/structured/namedresources/cel
@@ -1370,7 +1369,7 @@ k8s.io/klog/v2/internal/verbosity
 k8s.io/klog/v2/klogr
 k8s.io/klog/v2/ktesting
 k8s.io/klog/v2/textlogger
-# k8s.io/kms v0.30.6 => k8s.io/kms v0.30.6
+# k8s.io/kms v0.30.4 => k8s.io/kms v0.30.4
 ## explicit; go 1.22.0
 k8s.io/kms/apis/v1beta1
 k8s.io/kms/apis/v2
@@ -1378,16 +1377,12 @@ k8s.io/kms/pkg/service
 k8s.io/kms/pkg/util
 # k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340
 ## explicit; go 1.20
-k8s.io/kube-openapi/cmd/openapi-gen
-k8s.io/kube-openapi/cmd/openapi-gen/args
 k8s.io/kube-openapi/pkg/builder
 k8s.io/kube-openapi/pkg/builder3
 k8s.io/kube-openapi/pkg/builder3/util
 k8s.io/kube-openapi/pkg/cached
 k8s.io/kube-openapi/pkg/common
 k8s.io/kube-openapi/pkg/common/restfuladapter
-k8s.io/kube-openapi/pkg/generators
-k8s.io/kube-openapi/pkg/generators/rules
 k8s.io/kube-openapi/pkg/handler
 k8s.io/kube-openapi/pkg/handler3
 k8s.io/kube-openapi/pkg/internal
@@ -1397,19 +1392,18 @@ k8s.io/kube-openapi/pkg/schemamutation
 k8s.io/kube-openapi/pkg/spec3
 k8s.io/kube-openapi/pkg/util
 k8s.io/kube-openapi/pkg/util/proto
-k8s.io/kube-openapi/pkg/util/sets
 k8s.io/kube-openapi/pkg/validation/errors
 k8s.io/kube-openapi/pkg/validation/spec
 k8s.io/kube-openapi/pkg/validation/strfmt
 k8s.io/kube-openapi/pkg/validation/strfmt/bson
-# k8s.io/kube-scheduler v0.30.6 => k8s.io/kube-scheduler v0.30.6
+# k8s.io/kube-scheduler v0.30.4 => k8s.io/kube-scheduler v0.30.4
 ## explicit; go 1.22.0
 k8s.io/kube-scheduler/config/v1
 k8s.io/kube-scheduler/extender/v1
-# k8s.io/kubelet v0.30.6 => k8s.io/kubelet v0.30.6
+# k8s.io/kubelet v0.30.4 => k8s.io/kubelet v0.30.4
 ## explicit; go 1.22.0
 k8s.io/kubelet/pkg/apis
-# k8s.io/kubernetes v1.30.6 => k8s.io/kubernetes v1.30.6
+# k8s.io/kubernetes v1.30.4 => k8s.io/kubernetes v1.30.4
 ## explicit; go 1.22.0
 k8s.io/kubernetes/cmd/kube-scheduler/app
 k8s.io/kubernetes/cmd/kube-scheduler/app/config
@@ -1498,7 +1492,7 @@ k8s.io/kubernetes/pkg/volume/util/volumepathhandler
 k8s.io/kubernetes/test/e2e/framework/testfiles
 k8s.io/kubernetes/test/e2e/testing-manifests
 k8s.io/kubernetes/test/utils/image
-# k8s.io/metrics v0.30.6 => k8s.io/metrics v0.30.6
+# k8s.io/metrics v0.30.4 => k8s.io/metrics v0.30.4
 ## explicit; go 1.22.0
 k8s.io/metrics/pkg/apis/metrics
 k8s.io/metrics/pkg/apis/metrics/v1alpha1
@@ -1507,7 +1501,7 @@ k8s.io/metrics/pkg/client/clientset/versioned
 k8s.io/metrics/pkg/client/clientset/versioned/scheme
 k8s.io/metrics/pkg/client/clientset/versioned/typed/metrics/v1alpha1
 k8s.io/metrics/pkg/client/clientset/versioned/typed/metrics/v1beta1
-# k8s.io/mount-utils v0.30.6 => k8s.io/mount-utils v0.30.6
+# k8s.io/mount-utils v0.30.4 => k8s.io/mount-utils v0.30.4
 ## explicit; go 1.22.0
 k8s.io/mount-utils
 # k8s.io/utils v0.0.0-20230726121419-3b25d923346b
@@ -1617,32 +1611,32 @@ sigs.k8s.io/yaml
 # go.opentelemetry.io/otel/metric => go.opentelemetry.io/otel/metric v1.21.0
 # go.opentelemetry.io/otel/sdk => go.opentelemetry.io/otel/sdk v1.21.0
 # go.opentelemetry.io/otel/trace => go.opentelemetry.io/otel/trace v1.21.0
-# k8s.io/api => k8s.io/api v0.30.6
-# k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.30.6
-# k8s.io/apimachinery => k8s.io/apimachinery v0.30.6
-# k8s.io/apiserver => k8s.io/apiserver v0.30.6
-# k8s.io/cli-runtime => k8s.io/cli-runtime v0.30.6
-# k8s.io/client-go => k8s.io/client-go v0.30.6
-# k8s.io/cloud-provider => k8s.io/cloud-provider v0.30.6
-# k8s.io/cluster-bootstrap => k8s.io/cluster-bootstrap v0.30.6
-# k8s.io/code-generator => k8s.io/code-generator v0.30.6
-# k8s.io/component-base => k8s.io/component-base v0.30.6
-# k8s.io/component-helpers => k8s.io/component-helpers v0.30.6
-# k8s.io/controller-manager => k8s.io/controller-manager v0.30.6
-# k8s.io/cri-api => k8s.io/cri-api v0.30.6
-# k8s.io/csi-translation-lib => k8s.io/csi-translation-lib v0.30.6
-# k8s.io/dynamic-resource-allocation => k8s.io/dynamic-resource-allocation v0.30.6
-# k8s.io/endpointslice => k8s.io/endpointslice v0.30.6
-# k8s.io/kms => k8s.io/kms v0.30.6
-# k8s.io/kube-aggregator => k8s.io/kube-aggregator v0.30.6
-# k8s.io/kube-controller-manager => k8s.io/kube-controller-manager v0.30.6
-# k8s.io/kube-proxy => k8s.io/kube-proxy v0.30.6
-# k8s.io/kube-scheduler => k8s.io/kube-scheduler v0.30.6
-# k8s.io/kubectl => k8s.io/kubectl v0.30.6
-# k8s.io/kubelet => k8s.io/kubelet v0.30.6
-# k8s.io/kubernetes => k8s.io/kubernetes v1.30.6
-# k8s.io/legacy-cloud-providers => k8s.io/legacy-cloud-providers v0.30.6
-# k8s.io/metrics => k8s.io/metrics v0.30.6
-# k8s.io/mount-utils => k8s.io/mount-utils v0.30.6
-# k8s.io/pod-security-admission => k8s.io/pod-security-admission v0.30.6
-# k8s.io/sample-apiserver => k8s.io/sample-apiserver v0.30.6
+# k8s.io/api => k8s.io/api v0.30.4
+# k8s.io/apiextensions-apiserver => k8s.io/apiextensions-apiserver v0.30.4
+# k8s.io/apimachinery => k8s.io/apimachinery v0.30.4
+# k8s.io/apiserver => k8s.io/apiserver v0.30.4
+# k8s.io/cli-runtime => k8s.io/cli-runtime v0.30.4
+# k8s.io/client-go => k8s.io/client-go v0.30.4
+# k8s.io/cloud-provider => k8s.io/cloud-provider v0.30.4
+# k8s.io/cluster-bootstrap => k8s.io/cluster-bootstrap v0.30.4
+# k8s.io/code-generator => k8s.io/code-generator v0.30.4
+# k8s.io/component-base => k8s.io/component-base v0.30.4
+# k8s.io/component-helpers => k8s.io/component-helpers v0.30.4
+# k8s.io/controller-manager => k8s.io/controller-manager v0.30.4
+# k8s.io/cri-api => k8s.io/cri-api v0.30.4
+# k8s.io/csi-translation-lib => k8s.io/csi-translation-lib v0.30.4
+# k8s.io/dynamic-resource-allocation => k8s.io/dynamic-resource-allocation v0.30.4
+# k8s.io/endpointslice => k8s.io/endpointslice v0.30.4
+# k8s.io/kms => k8s.io/kms v0.30.4
+# k8s.io/kube-aggregator => k8s.io/kube-aggregator v0.30.4
+# k8s.io/kube-controller-manager => k8s.io/kube-controller-manager v0.30.4
+# k8s.io/kube-proxy => k8s.io/kube-proxy v0.30.4
+# k8s.io/kube-scheduler => k8s.io/kube-scheduler v0.30.4
+# k8s.io/kubectl => k8s.io/kubectl v0.30.4
+# k8s.io/kubelet => k8s.io/kubelet v0.30.4
+# k8s.io/kubernetes => k8s.io/kubernetes v1.30.4
+# k8s.io/legacy-cloud-providers => k8s.io/legacy-cloud-providers v0.30.4
+# k8s.io/metrics => k8s.io/metrics v0.30.4
+# k8s.io/mount-utils => k8s.io/mount-utils v0.30.4
+# k8s.io/pod-security-admission => k8s.io/pod-security-admission v0.30.4
+# k8s.io/sample-apiserver => k8s.io/sample-apiserver v0.30.4


Test patch:
diff --git a/pkg/capacityscheduling/capacity_scheduling_test.go b/pkg/capacityscheduling/capacity_scheduling_test.go
index 43f0e000..bfd1d87e 100644
--- a/pkg/capacityscheduling/capacity_scheduling_test.go
+++ b/pkg/capacityscheduling/capacity_scheduling_test.go
@@ -469,7 +469,7 @@ func TestReserve(t *testing.T) {
 
 			state := framework.NewCycleState()
 			for i, pod := range tt.pods {
-				got := cs.Reserve(nil, state, pod, "node-a")
+				got := cs.Reserve(context.TODO(), state, pod, "node-a")
 				if got.Code() != tt.expectedCodes[i] {
 					t.Errorf("expected %v, got %v : %v", tt.expected[i], got.Code(), got.Message())
 				}
@@ -591,7 +591,7 @@ func TestUnreserve(t *testing.T) {
 
 			state := framework.NewCycleState()
 			for i, pod := range tt.pods {
-				cs.Unreserve(nil, state, pod, "node-a")
+				cs.Unreserve(context.TODO(), state, pod, "node-a")
 				if !reflect.DeepEqual(cs.elasticQuotaInfos["ns1"], tt.expected[i]["ns1"]) {
 					t.Errorf("expected %#v, got %#v", tt.expected[i]["ns1"].Used, cs.elasticQuotaInfos["ns1"].Used)
 				}
diff --git a/pkg/sysched/sysched_test.go b/pkg/sysched/sysched_test.go
index 012c6199..1eea8c39 100644
--- a/pkg/sysched/sysched_test.go
+++ b/pkg/sysched/sysched_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -14,6 +15,7 @@ import (
 	clientsetfake "k8s.io/client-go/kubernetes/fake"
 	clientscheme "k8s.io/client-go/kubernetes/scheme"
 	restclient "k8s.io/client-go/rest"
+	"k8s.io/klog/v2"
 	"k8s.io/kubernetes/pkg/scheduler/framework"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/queuesort"
@@ -311,7 +313,8 @@ func TestGetSyscalls(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			syscalls := sys.getSyscalls(tt.pod)
+			logger := klog.FromContext(context.TODO())
+			syscalls := sys.getSyscalls(logger, tt.pod)
 			assert.NotNil(t, syscalls)
 			assert.EqualValues(t, tt.expected, syscalls.Len())
 		})
@@ -333,7 +336,8 @@ func TestCalcScore(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			score := sys.calcScore(tt.syscalls)
+			logger := klog.FromContext(context.TODO())
+			score := sys.calcScore(logger, tt.syscalls)
 			assert.EqualValues(t, tt.expected, score)
 		})
 	}
@@ -351,6 +355,7 @@ func TestScore(t *testing.T) {
 	// fake out the framework handle
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	logger := klog.FromContext(ctx)
 	fr, err := tf.NewFramework(ctx, registeredPlugins, Name,
 		frameworkruntime.WithClientSet(clientsetfake.NewSimpleClientset(node.Obj())))
 	if err != nil {
@@ -381,7 +386,7 @@ func TestScore(t *testing.T) {
 	sys.ExSAvg = 0
 	sys.ExSAvgCount = 0
 
-	sys.addPod(pod)
+	sys.addPod(logger, pod)
 
 	tests := []struct {
 		name     string
@@ -479,14 +484,15 @@ func TestGetHostSyscalls(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			logger := klog.FromContext(context.TODO())
 			sys, _ := mockSysched()
 			sys.ExSAvgCount = 0
 
 			for i := range tt.pods {
-				sys.addPod(tt.pods[i])
+				sys.addPod(logger, tt.pods[i])
 			}
 
-			cnt, _ := sys.getHostSyscalls(tt.nodeName)
+			cnt, _ := sys.getHostSyscalls(logger, tt.nodeName)
 			assert.EqualValues(t, tt.expected, cnt)
 		})
 	}
@@ -524,6 +530,7 @@ func TestUpdateHostSyscalls(t *testing.T) {
 			// fake out the framework handle
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
+			logger := klog.FromContext(ctx)
 			nodeItems := []v1.Node{}
 			for _, node := range tt.nodes {
 				nodeItems = append(nodeItems, *node)
@@ -559,13 +566,13 @@ func TestUpdateHostSyscalls(t *testing.T) {
 			sys.ExSAvgCount = 0
 
 			for i := range tt.basePods {
-				sys.addPod(tt.basePods[i])
+				sys.addPod(logger, tt.basePods[i])
 			}
 
 			for i := range tt.newPods {
-				sys.updateHostSyscalls(tt.newPods[i])
+				sys.updateHostSyscalls(logger, tt.newPods[i])
 			}
-			sc, _ := sys.getHostSyscalls("test")
+			sc, _ := sys.getHostSyscalls(logger, "test")
 			assert.EqualValues(t, tt.expected, sc)
 		})
 	}
@@ -591,8 +598,9 @@ func TestAddPod(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			logger := klog.FromContext(context.TODO())
 			for i := range tt.pods {
-				sys.addPod(tt.pods[i])
+				sys.addPod(logger, tt.pods[i])
 			}
 			for i := range sys.HostToPods["test"] {
 				assert.EqualValues(t, tt.pods[i], sys.HostToPods["test"][i])
@@ -623,7 +631,8 @@ func TestRecomputeHostSyscalls(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			syscalls := sys.recomputeHostSyscalls(tt.pods)
+			logger := klog.FromContext(context.TODO())
+			syscalls := sys.recomputeHostSyscalls(logger, tt.pods)
 			assert.EqualValues(t, tt.expected, len(syscalls))
 		})
 	}
@@ -655,12 +664,13 @@ func TestRemovePod(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			logger := klog.FromContext(context.TODO())
 			for i := range tt.pods {
-				sys.addPod(tt.pods[i])
+				sys.addPod(logger, tt.pods[i])
 			}
 
 			for i := range tt.removePods {
-				sys.removePod(tt.removePods[i])
+				sys.removePod(logger, tt.removePods[i])
 			}
 
 			assert.EqualValues(t, tt.expectedPodNum, len(sys.HostToPods["test"]))
@@ -729,8 +739,9 @@ func TestPodUpdated(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			logger := klog.FromContext(context.TODO())
 			for i := range tt.basePods {
-				sys.addPod(tt.basePods[i])
+				sys.addPod(logger, tt.basePods[i])
 			}
 
 			for i := range tt.updatedPods {
@@ -769,8 +780,9 @@ func TestPodDeleted(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			logger := klog.FromContext(context.TODO())
 			for i := range tt.basePods {
-				sys.addPod(tt.basePods[i])
+				sys.addPod(logger, tt.basePods[i])
 			}
 
 			for i := range tt.deletedPods {
diff --git a/pkg/trimaran/collector_test.go b/pkg/trimaran/collector_test.go
index 96c0feb9..f3c7209e 100644
--- a/pkg/trimaran/collector_test.go
+++ b/pkg/trimaran/collector_test.go
@@ -17,6 +17,7 @@ limitations under the License.
 package trimaran
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
@@ -24,6 +25,7 @@ import (
 
 	"github.com/paypal/load-watcher/pkg/watcher"
 	"github.com/stretchr/testify/assert"
+	"k8s.io/klog/v2"
 
 	pluginConfig "sigs.k8s.io/scheduler-plugins/apis/config"
 )
@@ -74,7 +76,8 @@ var (
 )
 
 func TestNewCollector(t *testing.T) {
-	col, err := NewCollector(&args)
+	logger := klog.FromContext(context.TODO())
+	col, err := NewCollector(logger, &args)
 	assert.NotNil(t, col)
 	assert.Nil(t, err)
 }
@@ -94,8 +97,8 @@ func TestNewCollectorSpecs(t *testing.T) {
 		WatcherAddress: "",
 		MetricProvider: metricProvider,
 	}
-
-	col, err := NewCollector(&trimaranSpec)
+	logger := klog.FromContext(context.TODO())
+	col, err := NewCollector(logger, &trimaranSpec)
 	assert.Nil(t, col)
 	expectedErr := "invalid MetricProvider.Type, got " + string(metricProvider.Type)
 	assert.EqualError(t, err, expectedErr)
@@ -112,7 +115,8 @@ func TestGetAllMetrics(t *testing.T) {
 	trimaranSpec := pluginConfig.TrimaranSpec{
 		WatcherAddress: server.URL,
 	}
-	collector, err := NewCollector(&trimaranSpec)
+	logger := klog.FromContext(context.TODO())
+	collector, err := NewCollector(logger, &trimaranSpec)
 	assert.NotNil(t, collector)
 	assert.Nil(t, err)
 
@@ -133,11 +137,12 @@ func TestUpdateMetrics(t *testing.T) {
 	trimaranSpec := pluginConfig.TrimaranSpec{
 		WatcherAddress: server.URL,
 	}
-	collector, err := NewCollector(&trimaranSpec)
+	logger := klog.FromContext(context.TODO())
+	collector, err := NewCollector(logger, &trimaranSpec)
 	assert.NotNil(t, collector)
 	assert.Nil(t, err)
 
-	err = collector.updateMetrics()
+	err = collector.updateMetrics(logger)
 	assert.Nil(t, err)
 }
 
@@ -152,11 +157,12 @@ func TestGetNodeMetrics(t *testing.T) {
 	trimaranSpec := pluginConfig.TrimaranSpec{
 		WatcherAddress: server.URL,
 	}
-	collector, err := NewCollector(&trimaranSpec)
+	logger := klog.FromContext(context.TODO())
+	collector, err := NewCollector(logger, &trimaranSpec)
 	assert.NotNil(t, collector)
 	assert.Nil(t, err)
 	nodeName := "node-1"
-	metrics, allMetrics := collector.GetNodeMetrics(nodeName)
+	metrics, allMetrics := collector.GetNodeMetrics(logger, nodeName)
 	expectedMetrics := watcherResponse.Data.NodeMetricsMap[nodeName].Metrics
 	assert.EqualValues(t, expectedMetrics, metrics)
 	expectedAllMetrics := &watcherResponse
@@ -174,11 +180,12 @@ func TestGetNodeMetricsNilForNode(t *testing.T) {
 	trimaranSpec := pluginConfig.TrimaranSpec{
 		WatcherAddress: server.URL,
 	}
-	collector, err := NewCollector(&trimaranSpec)
+	logger := klog.FromContext(context.TODO())
+	collector, err := NewCollector(logger, &trimaranSpec)
 	assert.NotNil(t, collector)
 	assert.Nil(t, err)
 	nodeName := "node-1"
-	metrics, allMetrics := collector.GetNodeMetrics(nodeName)
+	metrics, allMetrics := collector.GetNodeMetrics(logger, nodeName)
 	expectedMetrics := noWatcherResponseForNode.Data.NodeMetricsMap[nodeName].Metrics
 	assert.EqualValues(t, expectedMetrics, metrics)
 	assert.NotNil(t, allMetrics)
@@ -203,8 +210,8 @@ func TestNewCollectorLoadWatcher(t *testing.T) {
 		WatcherAddress: "",
 		MetricProvider: metricProvider,
 	}
-
-	col, err := NewCollector(&trimaranSpec)
+	logger := klog.FromContext(context.TODO())
+	col, err := NewCollector(logger, &trimaranSpec)
 	assert.NotNil(t, col)
 	assert.Nil(t, err)
 }
diff --git a/pkg/trimaran/loadvariationriskbalancing/analysis_test.go b/pkg/trimaran/loadvariationriskbalancing/analysis_test.go
index 72643fb5..2b08631c 100644
--- a/pkg/trimaran/loadvariationriskbalancing/analysis_test.go
+++ b/pkg/trimaran/loadvariationriskbalancing/analysis_test.go
@@ -17,10 +17,13 @@ limitations under the License.
 package loadvariationriskbalancing
 
 import (
+	"context"
 	"math"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"k8s.io/klog/v2"
+
 	"sigs.k8s.io/scheduler-plugins/pkg/trimaran"
 )
 
@@ -156,7 +159,8 @@ func TestComputeScore(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			response := int64(math.Round(computeScore(tt.rs, tt.margin, tt.sensitivity)))
+			logger := klog.FromContext(context.TODO())
+			response := int64(math.Round(computeScore(logger, tt.rs, tt.margin, tt.sensitivity)))
 			assert.Equal(t, tt.expected, response)
 		})
 	}
diff --git a/pkg/trimaran/lowriskovercommitment/lowriskovercommitment_test.go b/pkg/trimaran/lowriskovercommitment/lowriskovercommitment_test.go
index 93c267ad..63c6c765 100644
--- a/pkg/trimaran/lowriskovercommitment/lowriskovercommitment_test.go
+++ b/pkg/trimaran/lowriskovercommitment/lowriskovercommitment_test.go
@@ -27,6 +27,7 @@ import (
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/client-go/informers"
 	testClientSet "k8s.io/client-go/kubernetes/fake"
+	"k8s.io/klog/v2"
 	schedConfig "k8s.io/kubernetes/pkg/scheduler/apis/config"
 	"k8s.io/kubernetes/pkg/scheduler/framework"
 	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder"
@@ -376,7 +377,8 @@ func TestLowRiskOverCommitment_computeRisk(t *testing.T) {
 	metrics := watcherData_A.NodeMetricsMap[node_A.Name].Metrics
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := pl.computeRisk(metrics, tt.resourceName, tt.resourceType, node_A, tt.nodeRequestsAndLimits); got != tt.want {
+			logger := klog.FromContext(context.TODO())
+			if got := pl.computeRisk(logger, metrics, tt.resourceName, tt.resourceType, node_A, tt.nodeRequestsAndLimits); got != tt.want {
 				t.Errorf("LowRiskOverCommitment.computeRisk() = %v, want %v", got, tt.want)
 			}
 		})
diff --git a/pkg/trimaran/resourcestats_test.go b/pkg/trimaran/resourcestats_test.go
index a8376206..da50ef3a 100644
--- a/pkg/trimaran/resourcestats_test.go
+++ b/pkg/trimaran/resourcestats_test.go
@@ -17,6 +17,7 @@ limitations under the License.
 package trimaran
 
 import (
+	"context"
 	"math"
 	"reflect"
 	"strconv"
@@ -26,6 +27,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
+	"k8s.io/klog/v2"
 	"k8s.io/kubernetes/pkg/scheduler/framework"
 	st "k8s.io/kubernetes/pkg/scheduler/testing"
 )
@@ -147,7 +149,8 @@ func TestCreateResourceStats(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			gotRs, gotIsValid := CreateResourceStats(tt.args.metrics, tt.args.node, tt.args.podRequest, tt.args.resourceName, tt.args.watcherType)
+			logger := klog.FromContext(context.TODO())
+			gotRs, gotIsValid := CreateResourceStats(logger, tt.args.metrics, tt.args.node, tt.args.podRequest, tt.args.resourceName, tt.args.watcherType)
 			if !reflect.DeepEqual(gotRs, tt.wantRs) {
 				t.Errorf("createResourceStats() gotRs = %v, want %v", gotRs, tt.wantRs)
 			}
@@ -580,9 +583,10 @@ func TestGetNodeRequestsAndLimits(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			logger := klog.FromContext(context.TODO())
 			var got *NodeRequestsAndLimits
 			SetMaxLimits(tt.args.podRequests, tt.args.podLimits)
-			if got = GetNodeRequestsAndLimits(tt.args.podsOnNode, tt.args.node, tt.args.pod,
+			if got = GetNodeRequestsAndLimits(logger, tt.args.podsOnNode, tt.args.node, tt.args.pod,
 				tt.args.podRequests, tt.args.podLimits); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("GetNodeRequestsAndLimits(): got = {%+v, %+v, %+v, %+v, %+v}, want = {%+v, %+v, %+v, %+v, %+v}",
 					*got.NodeRequest, *got.NodeLimit, *got.NodeRequestMinusPod, *got.NodeLimitMinusPod, *got.Nodecapacity,
diff --git a/vendor/k8s.io/kubernetes/test/utils/image/manifest.go b/vendor/k8s.io/kubernetes/test/utils/image/manifest.go
index af1893b9..9fae113f 100644
--- a/vendor/k8s.io/kubernetes/test/utils/image/manifest.go
+++ b/vendor/k8s.io/kubernetes/test/utils/image/manifest.go
@@ -237,8 +237,8 @@ func initImageConfigs(list RegistryList) (map[ImageID]Config, map[ImageID]Config
 	configs[BusyBox] = Config{list.PromoterE2eRegistry, "busybox", "1.36.1-1"}
 	configs[CudaVectorAdd] = Config{list.PromoterE2eRegistry, "cuda-vector-add", "1.0"}
 	configs[CudaVectorAdd2] = Config{list.PromoterE2eRegistry, "cuda-vector-add", "2.3"}
-	configs[DistrolessIptables] = Config{list.BuildImageRegistry, "distroless-iptables", "v0.5.9"}
-	configs[Etcd] = Config{list.GcEtcdRegistry, "etcd", "3.5.15-0"}
+	configs[DistrolessIptables] = Config{list.BuildImageRegistry, "distroless-iptables", "v0.5.6"}
+	configs[Etcd] = Config{list.GcEtcdRegistry, "etcd", "3.5.12-0"}
 	configs[Httpd] = Config{list.PromoterE2eRegistry, "httpd", "2.4.38-4"}
 	configs[HttpdNew] = Config{list.PromoterE2eRegistry, "httpd", "2.4.39-4"}
 	configs[InvalidRegistryImage] = Config{list.InvalidRegistry, "alpine", "3.1"}