Repository: Kong/kubernetes-ingress-controller
Pull request #5043 (2023-10-31 19:16:10)

fix: remove HTTP ports from discovery config
**What this PR does / why we need it**:

Remove the HTTP port names from the default list of accepted Service ports for discovery. 

**Which issue this PR fixes**:

Discovery is [hard-coded to support HTTPS only](https://github.com/Kong/kubernetes-ingress-controller/blob/513db87cbf94ce66207f74365b502e8cde841357/internal/adminapi/endpoints.go#L186), and would unsuccessfully attempt to use HTTP ports when available. The client generator code [builds clients for all admissable port names](https://github.com/Kong/kubernetes-ingress-controller/blob/c102cea90961347259846b134c958a4f155b2af3/internal/adminapi/endpoints.go#L101-L151) and has no filters by protocol.

In DB mode this could prevent the controller from talking to Kong at all if it chose an HTTP port from the list, as it only selects a single client from the list (at least as of the current draft in https://github.com/Kong/kubernetes-ingress-controller/pull/4828).

**Special notes for your reviewer**:

AFAIK there should not be any reason to add HTTP support for discovery. I had only been using it to simplify manual requests in a debugging session.

**PR Readiness Checklist**:

Complete these before marking the PR as `ready to review`:

- [x] the `CHANGELOG.md` release notes have been updated to reflect any significant (and particularly user-facing) changes introduced by this PR


codecov[bot]: ## [Codecov](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/pull/5043?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong) Report
All modified and coverable lines are covered by tests :white_check_mark:
> Comparison is base [(`0e71283`)](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/commit/0e712832cd52d8732e0bc22652b856b5a98b0812?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong) 75.4% compared to head [(`f65e408`)](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/pull/5043?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong) 75.4%.

<details><summary>Additional details and impacted files</summary>


```diff
@@           Coverage Diff           @@
##            main   #5043     +/-   ##
=======================================
- Coverage   75.4%   75.4%   -0.1%     
=======================================
  Files        167     167             
  Lines      18881   18881             
=======================================
- Hits       14253   14252      -1     
- Misses      3796    3799      +3     
+ Partials     832     830      -2     
```


| [Files](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/pull/5043?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong) | Coverage Δ | |
|---|---|---|
| [internal/manager/config.go](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/pull/5043?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong#diff-aW50ZXJuYWwvbWFuYWdlci9jb25maWcuZ28=) | `93.3% <100.0%> (ø)` | |

... and [5 files with indirect coverage changes](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/pull/5043/indirect-changes?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong)


</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/Kong/kubernetes-ingress-controller/pull/5043?src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Kong).


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 79aa91b5c..58b382f0c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -174,10 +174,11 @@ Adding a new version? You'll need three changes:
 - Docker images now use UID and GID 1000 to match Kong images. This should have
   no user-facing effect.
   [#4911](https://github.com/Kong/kubernetes-ingress-controller/pull/4911)
-- Bump version of gateway API to `1.0.0-rc2` and support `Gateway`, `GatewayClass`
+- Bump version of gateway API to `1.0.0` and support `Gateway`, `GatewayClass`
   and `HTTPRoute` in API version `gateway.networking.k8s.io/v1`.
   [#4893](https://github.com/Kong/kubernetes-ingress-controller/pull/4893)
   [#4981](https://github.com/Kong/kubernetes-ingress-controller/pull/4981)
+  [#5041](https://github.com/Kong/kubernetes-ingress-controller/pull/5041)
 - Update `Gateway`s, `GatewayClass`es and `HTTPRoute`s in examples to API
   version `gateway.networking.k8s.io/v1`.
   [#4935](https://github.com/Kong/kubernetes-ingress-controller/pull/4935)
@@ -197,6 +198,12 @@ Adding a new version? You'll need three changes:
 - Count `HTTPRoute` to gateway's number of attached route if the gateway is
   present in its `status.parents`, even if the gateway has unresolved refs.
   [#4987](https://github.com/Kong/kubernetes-ingress-controller/pull/4987)
+- The default value for `--kong-admin-svc-port-names` is now `"admin-tls,kong-admin-tls"`
+  instead of `"admin,admin-tls,kong-admin,kong-admin-tls"`. HTTP port names
+  have been removed as discovery does not support plaintext HTTP connections.
+  Instances configured with both HTTP and HTTPS admin ports resulted in
+  discovery unsuccessfully trying to use HTTPS to talk to HTTP ports.
+  [#5043](https://github.com/Kong/kubernetes-ingress-controller/pull/5043)
 
 ### Added
 
diff --git a/Makefile b/Makefile
index bd657b17a..e177ce42e 100644
--- a/Makefile
+++ b/Makefile
@@ -382,14 +382,9 @@ use-setup-envtest:
 
 ENVTEST_TIMEOUT ?= 5m
 
-# TODO: remove when Gateway API v1 gets released and updated in go.mod
-.PHONY: go-get-gateway-api
-go-get-gateway-api:
-	go mod download -x $(GATEWAY_API_PACKAGE)@v1.0.0-rc2
-
 .PHONY: _test.envtest
 .ONESHELL: _test.envtest
-_test.envtest: gotestsum setup-envtest use-setup-envtest go-get-gateway-api
+_test.envtest: gotestsum setup-envtest use-setup-envtest
 	KUBEBUILDER_ASSETS="$(shell $(SETUP_ENVTEST) use -p path)" \
 		GOTESTSUM_FORMAT=$(GOTESTSUM_FORMAT) \
 		$(GOTESTSUM) -- \
diff --git a/docs/cli-arguments.md b/docs/cli-arguments.md
index d65c311f2..2afbe910e 100644
--- a/docs/cli-arguments.md
+++ b/docs/cli-arguments.md
@@ -46,7 +46,7 @@
 | `--kong-admin-init-retries` | `uint` | Number of attempts that will be made initially on controller startup to connect to the Kong Admin API. | `60` |
 | `--kong-admin-init-retry-delay` | `duration` | The time delay between every attempt (on controller startup) to connect to the Kong Admin API. | `1s` |
 | `--kong-admin-svc` | `namespaced-name` | Kong Admin API Service namespaced name in "namespace/name" format, to use for Kong Gateway service discovery. |  |
-| `--kong-admin-svc-port-names` | `strings` | Name(s) of ports on Kong Admin API service in comma-separated format (or specify this flag multiple times) to take into account when doing gateway discovery. | `[admin,admin-tls,kong-admin,kong-admin-tls]` |
+| `--kong-admin-svc-port-names` | `strings` | Name(s) of ports on Kong Admin API service in comma-separated format (or specify this flag multiple times) to take into account when doing gateway discovery. | `[admin-tls,kong-admin-tls]` |
 | `--kong-admin-tls-client-cert` | `string` | Mutual TLS (mTLS) client certificate for authentication. Mutually exclusive with --kong-admin-tls-client-cert-file. |  |
 | `--kong-admin-tls-client-cert-file` | `string` | Mutual TLS (mTLS) client certificate file for authentication. Mutually exclusive with --kong-admin-tls-client-cert. |  |
 | `--kong-admin-tls-client-key` | `string` | Mutual TLS (mTLS) client key for authentication. Mutually exclusive with --kong-admin-tls-client-key-file. |  |
diff --git a/go.mod b/go.mod
index ac35d33d3..f63e64e09 100644
--- a/go.mod
+++ b/go.mod
@@ -31,7 +31,7 @@ require (
 	github.com/jpillora/backoff v1.0.0
 	github.com/kong/deck v1.28.0
 	github.com/kong/go-kong v0.48.0
-	github.com/kong/kubernetes-telemetry v0.1.1
+	github.com/kong/kubernetes-telemetry v0.1.2
 	github.com/kong/kubernetes-testing-framework v0.41.1
 	github.com/lithammer/dedent v1.1.0
 	github.com/miekg/dns v1.1.56
@@ -49,7 +49,7 @@ require (
 	github.com/stretchr/testify v1.8.4
 	github.com/testcontainers/testcontainers-go v0.26.0
 	go.uber.org/zap v1.26.0
-	google.golang.org/api v0.148.0
+	google.golang.org/api v0.149.0
 	k8s.io/api v0.28.3
 	k8s.io/apiextensions-apiserver v0.28.3
 	k8s.io/apimachinery v0.28.3
@@ -89,14 +89,14 @@ require (
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	go4.org/netipx v0.0.0-20230728184502-ec4c8b891b28 // indirect
 	golang.org/x/net v0.17.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20231002182017-d307bd883b97 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20231016165738-49dd2c1f3d0b // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b // indirect
 	gopkg.in/evanphx/json-patch.v5 v5.6.0 // indirect
 	k8s.io/klog/v2 v2.100.1 // indirect
 )
 
 require (
-	cloud.google.com/go/compute v1.23.0 // indirect
+	cloud.google.com/go/compute v1.23.1 // indirect
 	cloud.google.com/go/compute/metadata v0.2.3 // indirect
 	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
 	github.com/Kong/go-diff v1.2.2 // indirect
@@ -136,7 +136,7 @@ require (
 	github.com/google/go-querystring v1.1.0 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
-	github.com/googleapis/enterprise-certificate-proxy v0.3.1 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect
 	github.com/googleapis/gax-go/v2 v2.12.0 // indirect
 	github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
@@ -205,7 +205,7 @@ require (
 	golang.org/x/tools v0.14.0 // indirect
 	gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect
 	google.golang.org/appengine v1.6.8 // indirect
-	google.golang.org/genproto v0.0.0-20231002182017-d307bd883b97 // indirect
+	google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b // indirect
 	google.golang.org/grpc v1.59.0
 	google.golang.org/protobuf v1.31.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
diff --git a/go.sum b/go.sum
index 9a25b0d3e..1483166d0 100644
--- a/go.sum
+++ b/go.sum
@@ -1,8 +1,8 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.110.8 h1:tyNdfIxjzaWctIiLYOTalaLKZ17SI44SKFW26QbOhME=
 cloud.google.com/go v0.110.8/go.mod h1:Iz8AkXJf1qmxC3Oxoep8R1T36w8B92yU29PcBhHO5fk=
-cloud.google.com/go/compute v1.23.0 h1:tP41Zoavr8ptEqaW6j+LQOnyBBhO7OkOMAGrgLopTwY=
-cloud.google.com/go/compute v1.23.0/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM=
+cloud.google.com/go/compute v1.23.1 h1:V97tBoDaZHb6leicZ1G6DLK2BAaZLJ/7+9BB/En3hR0=
+cloud.google.com/go/compute v1.23.1/go.mod h1:CqB3xpmPKKt3OJpW2ndFIXnA9A4xAy/F3Xp1ixncW78=
 cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
 cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
 cloud.google.com/go/container v1.27.0 h1:j6LI+ksEPksacqbOgcRjRV0f4wdgYhDKR5yobJ1+CjU=
@@ -195,8 +195,8 @@ github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4=
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/enterprise-certificate-proxy v0.3.1 h1:SBWmZhjUDRorQxrN0nwzf+AHBxnbFjViHQS4P0yVpmQ=
-github.com/googleapis/enterprise-certificate-proxy v0.3.1/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0=
+github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs=
+github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0=
 github.com/googleapis/gax-go/v2 v2.12.0 h1:A+gCJKdRfqXkr+BIRGtZLibNXf0m1f9E4HG56etFpas=
 github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
@@ -248,8 +248,8 @@ github.com/kong/deck v1.28.0 h1:D3JeiKhgHi6GbnM/yybtw1w+NFHDC/UtOrBiZ0CDKa8=
 github.com/kong/deck v1.28.0/go.mod h1:SrJqHqLTBTSJpIjWsyDR4kC88w7Px1EQDOGt0joVvoE=
 github.com/kong/go-kong v0.48.0 h1:vK1OpoxO50qlKdwPfmx9ChvkTKRsoCCB3b3iHo1umLc=
 github.com/kong/go-kong v0.48.0/go.mod h1:qH4CEFqT83ywmu1TlMZX09clQH4B8/dX88CtT/jdv/E=
-github.com/kong/kubernetes-telemetry v0.1.1 h1:q8iABCuonO16p5q6QVygr7J39G5o5jK5Y3w3ZlE8JC4=
-github.com/kong/kubernetes-telemetry v0.1.1/go.mod h1:0yzRZVPwKeOQUFMWbROEJzUE1z8WWngWiujoYtdEEPA=
+github.com/kong/kubernetes-telemetry v0.1.2 h1:fxKdEbFQ+aGrh+3x0LIEgRmyQ4wP/ZWv8QucqTI4Jcs=
+github.com/kong/kubernetes-telemetry v0.1.2/go.mod h1:2p6ZiwVM6pqDMwfRpbUuJrw6oqFrKFvGzX4Ft+LwGNA=
 github.com/kong/kubernetes-testing-framework v0.41.1 h1:rYPOUZu7961lNApLkr4QaqsKaJBuY9HClCa0r7K4P+8=
 github.com/kong/kubernetes-testing-framework v0.41.1/go.mod h1:LjiFKRG/Nk/W3kL+qWr60iUeIuXGOzykUEWlzkc0wtE=
 github.com/kong/semver/v4 v4.0.1 h1:DIcNR8W3gfx0KabFBADPalxxsp+q/5COwIFkkhrFQ2Y=
@@ -579,8 +579,8 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gomodules.xyz/jsonpatch/v2 v2.4.0 h1:Ci3iUJyx9UeRx7CeFN8ARgGbkESwJK+KB9lLcWxY/Zw=
 gomodules.xyz/jsonpatch/v2 v2.4.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY=
-google.golang.org/api v0.148.0 h1:HBq4TZlN4/1pNcu0geJZ/Q50vIwIXT532UIMYoo0vOs=
-google.golang.org/api v0.148.0/go.mod h1:8/TBgwaKjfqTdacOJrOv2+2Q6fBDU1uHKK06oGSkxzU=
+google.golang.org/api v0.149.0 h1:b2CqT6kG+zqJIVKRQ3ELJVLN1PwHZ6DJ3dW8yl82rgY=
+google.golang.org/api v0.149.0/go.mod h1:Mwn1B7JTXrzXtnvmzQE2BD6bYZQ8DShKZDZbeN9I7qI=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
@@ -588,12 +588,12 @@ google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJ
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20231002182017-d307bd883b97 h1:SeZZZx0cP0fqUyA+oRzP9k7cSwJlvDFiROO72uwD6i0=
-google.golang.org/genproto v0.0.0-20231002182017-d307bd883b97/go.mod h1:t1VqOqqvce95G3hIDCT5FeO3YUc6Q4Oe24L/+rNMxRk=
-google.golang.org/genproto/googleapis/api v0.0.0-20231002182017-d307bd883b97 h1:W18sezcAYs+3tDZX4F80yctqa12jcP1PUS2gQu1zTPU=
-google.golang.org/genproto/googleapis/api v0.0.0-20231002182017-d307bd883b97/go.mod h1:iargEX0SFPm3xcfMI0d1domjg0ZF4Aa0p2awqyxhvF0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a h1:a2MQQVoTo96JC9PMGtGBymLp7+/RzpFc2yX/9WfFg1c=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:4cYg8o5yUbm77w8ZX00LhMVNl/YVBFJRYWDc0uYWMs0=
+google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b h1:+YaDE2r2OG8t/z5qmsh7Y+XXwCbvadxxZ0YY6mTdrVA=
+google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:CgAqfJo+Xmu0GwA0411Ht3OU3OntXwsGmrmjI8ioGXI=
+google.golang.org/genproto/googleapis/api v0.0.0-20231016165738-49dd2c1f3d0b h1:CIC2YMXmIhYw6evmhPxBKJ4fmLbOFtXQN/GV3XOZR8k=
+google.golang.org/genproto/googleapis/api v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:IBQ646DjkDkvUIsVq/cc03FUFQ9wbZu7yE396YcL870=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b h1:ZlWIi1wSK56/8hn4QcBp/j9M7Gt3U/3hZw3mC7vDICo=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:swOH3j0KzcDDgGUWr+SNpyTen5YrXjS3eyPzFYKc6lc=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
diff --git a/hack/generators/controllers/networking/main.go b/hack/generators/controllers/networking/main.go
index 13df5ea01..d57fb3056 100644
--- a/hack/generators/controllers/networking/main.go
+++ b/hack/generators/controllers/networking/main.go
@@ -527,7 +527,7 @@ func (r *{{.PackageAlias}}{{.Kind}}Reconciler) SetupWithManager(mgr ctrl.Manager
 func (r *{{.PackageAlias}}{{.Kind}}Reconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &{{.PackageImportAlias}}.{{.Kind}}List{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless {{.Plural}}")
+		r.Log.Error(err, "Failed to list classless {{.Plural}}")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -576,11 +576,11 @@ func (r *{{.PackageAlias}}{{.Kind}}Reconciler) Reconcile(ctx context.Context, re
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "{{.Kind}}", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "{{.Kind}}", "namespace", req.Namespace, "name", req.Name)
 		{{if .NeedsUpdateReferences}}
 		// remove reference record where the {{.Kind}} is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -607,7 +607,7 @@ func (r *{{.PackageAlias}}{{.Kind}}Reconciler) Reconcile(ctx context.Context, re
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
diff --git a/internal/adminapi/backoff_strategy_konnect.go b/internal/adminapi/backoff_strategy_konnect.go
index 75b26f635..6b407c6a5 100644
--- a/internal/adminapi/backoff_strategy_konnect.go
+++ b/internal/adminapi/backoff_strategy_konnect.go
@@ -154,7 +154,7 @@ func (s *KonnectBackoffStrategy) whyCannotUpdate(
 
 	if isTheSameFaultyConfig {
 		reasons = append(reasons, fmt.Sprintf(
-			"config has to be changed: %q hash has already failed to be pushed with a client error",
+			"Config has to be changed: %q hash has already failed to be pushed with a client error",
 			hex.EncodeToString(s.lastFailedConfigHash),
 		))
 	}
diff --git a/internal/admission/handler.go b/internal/admission/handler.go
index 507b2a9d9..dff3e7836 100644
--- a/internal/admission/handler.go
+++ b/internal/admission/handler.go
@@ -33,28 +33,28 @@ type RequestHandler struct {
 // with the validation result of the entity.
 func (h RequestHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if r.Body == nil {
-		h.Logger.Error(nil, "received request with empty body")
-		http.Error(w, "admission review object is missing",
+		h.Logger.Error(nil, "Received request with empty body")
+		http.Error(w, "Admission review object is missing",
 			http.StatusBadRequest)
 		return
 	}
 
 	review := admissionv1.AdmissionReview{}
 	if err := json.NewDecoder(r.Body).Decode(&review); err != nil {
-		h.Logger.Error(err, "failed to decode admission review")
+		h.Logger.Error(err, "Failed to decode admission review")
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 	response, err := h.handleValidation(r.Context(), *review.Request)
 	if err != nil {
-		h.Logger.Error(err, "failed to run validation")
+		h.Logger.Error(err, "Failed to run validation")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 	review.Response = response
 
 	if err := json.NewEncoder(w).Encode(&review); err != nil {
-		h.Logger.Error(err, "failed to encode response")
+		h.Logger.Error(err, "Failed to encode response")
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
diff --git a/internal/admission/server.go b/internal/admission/server.go
index 33804e6c6..7b52e1609 100644
--- a/internal/admission/server.go
+++ b/internal/admission/server.go
@@ -91,7 +91,7 @@ func serverConfigToTLSConfig(ctx context.Context, sc *ServerConfig, logger logr.
 
 	go func() {
 		if err := watcher.Start(ctx); err != nil {
-			logger.Error(err, "certificate watcher error")
+			logger.Error(err, "Certificate watcher error")
 		}
 	}()
 	return &tls.Config{
diff --git a/internal/admission/validation/gateway/httproute.go b/internal/admission/validation/gateway/httproute.go
index c5d231722..d91e115e7 100644
--- a/internal/admission/validation/gateway/httproute.go
+++ b/internal/admission/validation/gateway/httproute.go
@@ -34,7 +34,7 @@ func ValidateHTTPRoute(
 ) (bool, string, error) {
 	// validate that no unsupported features are in use
 	if err := validateHTTPRouteFeatures(httproute, parserFeatures); err != nil {
-		return false, "httproute spec did not pass validation", err
+		return false, "HTTPRoute spec did not pass validation", err
 	}
 
 	// perform Gateway validations for the HTTPRoute (e.g. listener validation, namespace validation, e.t.c.)
@@ -45,19 +45,19 @@ func ValidateHTTPRoute(
 		// determine the parentRef for this gateway
 		parentRef, err := getParentRefForHTTPRouteGateway(httproute, gateway)
 		if err != nil {
-			return false, "couldn't determine parentRefs for httproute", err
+			return false, "Couldn't determine parentRefs for httproute", err
 		}
 
 		// gather the relevant gateway listeners for the httproute
 		listeners, err := getListenersForHTTPRouteValidation(parentRef.SectionName, gateway)
 		if err != nil {
-			return false, "couldn't find gateway listeners for httproute", err
+			return false, "Couldn't find gateway listeners for httproute", err
 		}
 
 		// perform validation of this route against it's linked gateway listeners
 		for _, listener := range listeners {
 			if err := validateHTTPRouteListener(listener); err != nil {
-				return false, "httproute linked gateway listeners did not pass validation", err
+				return false, "HTTPRoute linked Gateway listeners did not pass validation", err
 			}
 		}
 	}
@@ -218,7 +218,7 @@ func validateWithKongGateway(
 		kg := kg
 		ok, msg, err := routesValidator.Validate(ctx, &kg)
 		if err != nil {
-			return false, fmt.Sprintf("unable to validate HTTPRoute schema: %s", err.Error()), nil
+			return false, fmt.Sprintf("Unable to validate HTTPRoute schema: %s", err.Error()), nil
 		}
 		if !ok {
 			errMsgs = append(errMsgs, msg)
diff --git a/internal/admission/validation/ingress/ingress.go b/internal/admission/validation/ingress/ingress.go
index f7576d3d1..f0911abf3 100644
--- a/internal/admission/validation/ingress/ingress.go
+++ b/internal/admission/validation/ingress/ingress.go
@@ -28,7 +28,7 @@ func ValidateIngress(
 		kg := kg
 		ok, msg, err := routesValidator.Validate(ctx, &kg)
 		if err != nil {
-			return false, fmt.Sprintf("unable to validate Ingress schema: %s", err.Error()), nil
+			return false, fmt.Sprintf("Unable to validate Ingress schema: %s", err.Error()), nil
 		}
 		if !ok {
 			errMsgs = append(errMsgs, msg)
diff --git a/internal/admission/validator.go b/internal/admission/validator.go
index a46bd2860..6b04951f8 100644
--- a/internal/admission/validator.go
+++ b/internal/admission/validator.go
@@ -194,12 +194,12 @@ func (validator KongHTTPValidator) ValidateConsumerGroup(
 	}
 	info, err := infoSvc.Get(ctx)
 	if err != nil {
-		validator.Logger.V(util.DebugLevel).Info("failed to fetch Kong info", "error", err)
+		validator.Logger.V(util.DebugLevel).Info("Failed to fetch Kong info", "error", err)
 		return false, ErrTextAdminAPIUnavailable, nil
 	}
 	version, err := kong.NewVersion(info.Version)
 	if err != nil {
-		validator.Logger.V(util.DebugLevel).Info("failed to parse Kong version", "error", err)
+		validator.Logger.V(util.DebugLevel).Info("Failed to parse Kong version", "error", err)
 	} else {
 		if !version.IsKongGatewayEnterprise() {
 			return false, ErrTextConsumerGroupUnsupported, nil
@@ -404,13 +404,13 @@ func (validator KongHTTPValidator) ValidateHTTPRoute(
 			Namespace: namespace,
 			Name:      string(parentRef.Name),
 		}, &gateway); err != nil {
-			return false, fmt.Sprintf("couldn't retrieve referenced gateway %s/%s", namespace, parentRef.Name), err
+			return false, fmt.Sprintf("Couldn't retrieve referenced gateway %s/%s", namespace, parentRef.Name), err
 		}
 
 		// pull the referenced GatewayClass object from the Gateway
 		gatewayClass := gatewayapi.GatewayClass{}
 		if err := validator.ManagerClient.Get(ctx, client.ObjectKey{Name: string(gateway.Spec.GatewayClassName)}, &gatewayClass); err != nil {
-			return false, fmt.Sprintf("couldn't retrieve referenced gatewayclass %s", gateway.Spec.GatewayClassName), err
+			return false, fmt.Sprintf("Couldn't retrieve referenced gatewayclass %s", gateway.Spec.GatewayClassName), err
 		}
 
 		// determine ultimately whether the Gateway is managed by this controller implementation
@@ -494,7 +494,7 @@ func (validator KongHTTPValidator) ensureConsumerDoesNotExistInGateway(ctx conte
 		c, err := consumerSvc.Get(ctx, &username)
 		if err != nil {
 			if !kong.IsNotFoundErr(err) {
-				validator.Logger.Error(err, "failed to fetch consumer from kong")
+				validator.Logger.Error(err, "Failed to fetch consumer from kong")
 				return ErrTextConsumerUnretrievable, err
 			}
 		}
diff --git a/internal/clients/manager.go b/internal/clients/manager.go
index cabcd6fe9..72d78945b 100644
--- a/internal/clients/manager.go
+++ b/internal/clients/manager.go
@@ -214,7 +214,7 @@ func (c *AdminAPIClientsManager) gatewayClientsReconciliationLoop() {
 	for {
 		select {
 		case <-c.ctx.Done():
-			c.logger.V(util.InfoLevel).Info("closing AdminAPIClientsManager", "reason", c.ctx.Err())
+			c.logger.V(util.InfoLevel).Info("Closing AdminAPIClientsManager", "reason", c.ctx.Err())
 			c.closeGatewayClientsSubscribers()
 			return
 		case discoveredAdminAPIs := <-c.discoveredAdminAPIsNotifyChan:
@@ -229,7 +229,7 @@ func (c *AdminAPIClientsManager) gatewayClientsReconciliationLoop() {
 // It will adjust lists of gateway clients and notify subscribers about the change if readyGatewayClients list has
 // changed.
 func (c *AdminAPIClientsManager) onDiscoveredAdminAPIsNotification(discoveredAdminAPIs []adminapi.DiscoveredAdminAPI) {
-	c.logger.V(util.DebugLevel).Info("received notification about Admin API addresses change")
+	c.logger.V(util.DebugLevel).Info("Received notification about Admin API addresses change")
 
 	clientsChanged := c.adjustGatewayClients(discoveredAdminAPIs)
 	readinessChanged := c.reconcileGatewayClientsReadiness()
@@ -241,7 +241,7 @@ func (c *AdminAPIClientsManager) onDiscoveredAdminAPIsNotification(discoveredAdm
 // onReadinessReconciliationTick is called on every readinessReconciliationTicker tick. It will reconcile readiness
 // of all gateway clients and notify subscribers about the change if readyGatewayClients list has changed.
 func (c *AdminAPIClientsManager) onReadinessReconciliationTick() {
-	c.logger.V(util.DebugLevel).Info("reconciling readiness of gateway clients")
+	c.logger.V(util.DebugLevel).Info("Reconciling readiness of gateway clients")
 
 	if changed := c.reconcileGatewayClientsReadiness(); changed {
 		c.notifyGatewayClientsSubscribers()
@@ -338,11 +338,11 @@ func (c *AdminAPIClientsManager) reconcileGatewayClientsReadiness() bool {
 
 // notifyGatewayClientsSubscribers sends notifications to all subscribers that have called SubscribeToGatewayClientsChanges.
 func (c *AdminAPIClientsManager) notifyGatewayClientsSubscribers() {
-	c.logger.V(util.DebugLevel).Info("notifying subscribers about gateway clients change")
+	c.logger.V(util.DebugLevel).Info("Notifying subscribers about gateway clients change")
 	for _, sub := range c.gatewayClientsChangesSubscribers {
 		select {
 		case <-c.ctx.Done():
-			c.logger.V(util.InfoLevel).Info("not sending notification to subscribers as the context is done")
+			c.logger.V(util.InfoLevel).Info("Not sending notification to subscribers as the context is done")
 			return
 		case sub <- struct{}{}:
 		}
diff --git a/internal/clients/readiness.go b/internal/clients/readiness.go
index c9d471ec9..8abe640c7 100644
--- a/internal/clients/readiness.go
+++ b/internal/clients/readiness.go
@@ -95,7 +95,7 @@ func (c DefaultReadinessChecker) checkPendingClient(
 ) (client *adminapi.Client) {
 	defer func() {
 		c.logger.V(util.DebugLevel).
-			Info(fmt.Sprintf("checking readiness of pending client for %q", pendingClient.Address),
+			Info(fmt.Sprintf("Checking readiness of pending client for %q", pendingClient.Address),
 				"ok", client != nil,
 			)
 	}()
@@ -105,7 +105,7 @@ func (c DefaultReadinessChecker) checkPendingClient(
 	client, err := c.factory.CreateAdminAPIClient(ctx, pendingClient)
 	if err != nil {
 		// Despite the error reason we still want to keep the client in the pending list to retry later.
-		c.logger.V(util.DebugLevel).Info("pending client is not ready yet",
+		c.logger.V(util.DebugLevel).Info("Pending client is not ready yet",
 			"reason", err.Error(),
 			"address", pendingClient.Address,
 		)
@@ -126,7 +126,7 @@ func (c DefaultReadinessChecker) checkAlreadyExistingClients(ctx context.Context
 				// This should never happen, but if it does, we want to log it.
 				c.logger.Error(
 					errors.New("missing pod reference"),
-					"failed to get PodReference for client",
+					"Failed to get PodReference for client",
 					"address", client.BaseRootURL(),
 				)
 				continue
@@ -143,7 +143,7 @@ func (c DefaultReadinessChecker) checkAlreadyExistingClients(ctx context.Context
 func (c DefaultReadinessChecker) checkAlreadyCreatedClient(ctx context.Context, client AlreadyCreatedClient) (ready bool) {
 	defer func() {
 		c.logger.V(util.DebugLevel).Info(
-			fmt.Sprintf("checking readiness of already created client for %q", client.BaseRootURL()),
+			fmt.Sprintf("Checking readiness of already created client for %q", client.BaseRootURL()),
 			"ok", ready,
 		)
 	}()
@@ -153,7 +153,7 @@ func (c DefaultReadinessChecker) checkAlreadyCreatedClient(ctx context.Context,
 	if err := client.IsReady(ctx); err != nil {
 		// Despite the error reason we still want to keep the client in the pending list to retry later.
 		c.logger.V(util.DebugLevel).Info(
-			"already created client is not ready, moving to pending",
+			"Already created client is not ready, moving to pending",
 			"address", client.BaseRootURL(),
 			"reason", err.Error(),
 		)
diff --git a/internal/cmd/rootcmd/servers.go b/internal/cmd/rootcmd/servers.go
index cd3ec6f2d..54e825784 100644
--- a/internal/cmd/rootcmd/servers.go
+++ b/internal/cmd/rootcmd/servers.go
@@ -28,10 +28,10 @@ func StartDiagnosticsServer(
 	logger logr.Logger,
 ) (diagnostics.Server, error) {
 	if !c.EnableProfiling && !c.EnableConfigDumps {
-		logger.Info("diagnostics server disabled")
+		logger.Info("Diagnostics server disabled")
 		return diagnostics.Server{}, nil
 	}
-	logger.Info("starting diagnostics server")
+	logger.Info("Starting diagnostics server")
 
 	s := diagnostics.Server{
 		Logger:           logger,
diff --git a/internal/controllers/configuration/kongadminapi_controller.go b/internal/controllers/configuration/kongadminapi_controller.go
index f27c0284f..06cd0c6de 100644
--- a/internal/controllers/configuration/kongadminapi_controller.go
+++ b/internal/controllers/configuration/kongadminapi_controller.go
@@ -121,7 +121,7 @@ func (r *KongAdminAPIServiceReconciler) Reconcile(ctx context.Context, req ctrl.
 		}
 		return ctrl.Result{}, err
 	}
-	r.Log.Info("reconciling Admin API EndpointSlice", "namespace", req.Namespace, "name", req.Name)
+	r.Log.Info("Reconciling Admin API EndpointSlice", "namespace", req.Namespace, "name", req.Name)
 
 	if !endpoints.DeletionTimestamp.IsZero() {
 		r.Log.V(util.DebugLevel).Info("EndpointSlice is being deleted",
@@ -176,7 +176,7 @@ func (r *KongAdminAPIServiceReconciler) notify() {
 	discovered := flattenDiscoveredAdminAPIs(r.Cache)
 	addresses := lo.Map(discovered, func(d adminapi.DiscoveredAdminAPI, _ int) string { return d.Address })
 	r.Log.V(util.DebugLevel).
-		Info("notifying about newly detected Admin APIs", "admin_apis", addresses)
+		Info("Notifying about newly detected Admin APIs", "admin_apis", addresses)
 	r.EndpointsNotifier.Notify(discovered)
 }
 
diff --git a/internal/controllers/configuration/secret_controller.go b/internal/controllers/configuration/secret_controller.go
index 1b03384bd..16243b11e 100644
--- a/internal/controllers/configuration/secret_controller.go
+++ b/internal/controllers/configuration/secret_controller.go
@@ -89,7 +89,7 @@ func (r *CoreV1SecretReconciler) shouldReconcileSecret(obj client.Object) bool {
 
 	referred, err := r.ReferenceIndexers.ObjectReferred(secret)
 	if err != nil {
-		r.Log.Error(err, "failed to check whether secret referred",
+		r.Log.Error(err, "Failed to check whether secret referred",
 			"namespace", secret.Namespace, "name", secret.Name)
 		return false
 	}
@@ -114,11 +114,11 @@ func (r *CoreV1SecretReconciler) Reconcile(ctx context.Context, req ctrl.Request
 		return ctrl.Result{}, err
 	}
 
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !secret.DeletionTimestamp.IsZero() && time.Now().After(secret.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "Secret", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "Secret", "namespace", req.Namespace, "name", req.Name)
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(secret)
 		if err != nil {
 			return ctrl.Result{}, err
diff --git a/internal/controllers/configuration/zz_generated_controllers.go b/internal/controllers/configuration/zz_generated_controllers.go
index dd9cab798..cb41e1748 100644
--- a/internal/controllers/configuration/zz_generated_controllers.go
+++ b/internal/controllers/configuration/zz_generated_controllers.go
@@ -114,11 +114,11 @@ func (r *CoreV1ServiceReconciler) Reconcile(ctx context.Context, req ctrl.Reques
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "Service", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "Service", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the Service is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -213,11 +213,11 @@ func (r *DiscoveryV1EndpointSliceReconciler) Reconcile(ctx context.Context, req
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "EndpointSlice", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "EndpointSlice", "namespace", req.Namespace, "name", req.Name)
 
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj)
 		if err != nil {
@@ -310,7 +310,7 @@ func (r *NetV1IngressReconciler) SetupWithManager(mgr ctrl.Manager) error {
 func (r *NetV1IngressReconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &netv1.IngressList{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless ingresses")
+		r.Log.Error(err, "Failed to list classless ingresses")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -356,11 +356,11 @@ func (r *NetV1IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "Ingress", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "Ingress", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the Ingress is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -387,7 +387,7 @@ func (r *NetV1IngressReconciler) Reconcile(ctx context.Context, req ctrl.Request
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
@@ -500,11 +500,11 @@ func (r *NetV1IngressClassReconciler) Reconcile(ctx context.Context, req ctrl.Re
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "IngressClass", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "IngressClass", "namespace", req.Namespace, "name", req.Name)
 
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj)
 		if err != nil {
@@ -585,11 +585,11 @@ func (r *KongV1KongIngressReconciler) Reconcile(ctx context.Context, req ctrl.Re
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "KongIngress", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "KongIngress", "namespace", req.Namespace, "name", req.Name)
 
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj)
 		if err != nil {
@@ -670,11 +670,11 @@ func (r *KongV1beta1KongUpstreamPolicyReconciler) Reconcile(ctx context.Context,
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "KongUpstreamPolicy", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "KongUpstreamPolicy", "namespace", req.Namespace, "name", req.Name)
 
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj)
 		if err != nil {
@@ -761,11 +761,11 @@ func (r *KongV1KongPluginReconciler) Reconcile(ctx context.Context, req ctrl.Req
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "KongPlugin", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "KongPlugin", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the KongPlugin is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -857,7 +857,7 @@ func (r *KongV1KongClusterPluginReconciler) SetupWithManager(mgr ctrl.Manager) e
 func (r *KongV1KongClusterPluginReconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &kongv1.KongClusterPluginList{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless kongclusterplugins")
+		r.Log.Error(err, "Failed to list classless kongclusterplugins")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -903,11 +903,11 @@ func (r *KongV1KongClusterPluginReconciler) Reconcile(ctx context.Context, req c
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "KongClusterPlugin", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "KongClusterPlugin", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the KongClusterPlugin is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -934,7 +934,7 @@ func (r *KongV1KongClusterPluginReconciler) Reconcile(ctx context.Context, req c
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
@@ -1033,7 +1033,7 @@ func (r *KongV1KongConsumerReconciler) SetupWithManager(mgr ctrl.Manager) error
 func (r *KongV1KongConsumerReconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &kongv1.KongConsumerList{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless kongconsumers")
+		r.Log.Error(err, "Failed to list classless kongconsumers")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -1079,11 +1079,11 @@ func (r *KongV1KongConsumerReconciler) Reconcile(ctx context.Context, req ctrl.R
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "KongConsumer", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "KongConsumer", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the KongConsumer is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -1110,7 +1110,7 @@ func (r *KongV1KongConsumerReconciler) Reconcile(ctx context.Context, req ctrl.R
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
@@ -1220,7 +1220,7 @@ func (r *KongV1Beta1KongConsumerGroupReconciler) SetupWithManager(mgr ctrl.Manag
 func (r *KongV1Beta1KongConsumerGroupReconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &kongv1beta1.KongConsumerGroupList{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless kongconsumergroups")
+		r.Log.Error(err, "Failed to list classless kongconsumergroups")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -1266,11 +1266,11 @@ func (r *KongV1Beta1KongConsumerGroupReconciler) Reconcile(ctx context.Context,
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "KongConsumerGroup", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "KongConsumerGroup", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the KongConsumerGroup is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -1297,7 +1297,7 @@ func (r *KongV1Beta1KongConsumerGroupReconciler) Reconcile(ctx context.Context,
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
@@ -1409,7 +1409,7 @@ func (r *KongV1Beta1TCPIngressReconciler) SetupWithManager(mgr ctrl.Manager) err
 func (r *KongV1Beta1TCPIngressReconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &kongv1beta1.TCPIngressList{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless tcpingresses")
+		r.Log.Error(err, "Failed to list classless tcpingresses")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -1455,11 +1455,11 @@ func (r *KongV1Beta1TCPIngressReconciler) Reconcile(ctx context.Context, req ctr
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "TCPIngress", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "TCPIngress", "namespace", req.Namespace, "name", req.Name)
 
 		// remove reference record where the TCPIngress is the referrer
 		if err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, obj); err != nil {
@@ -1486,7 +1486,7 @@ func (r *KongV1Beta1TCPIngressReconciler) Reconcile(ctx context.Context, req ctr
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
@@ -1611,7 +1611,7 @@ func (r *KongV1Beta1UDPIngressReconciler) SetupWithManager(mgr ctrl.Manager) err
 func (r *KongV1Beta1UDPIngressReconciler) listClassless(ctx context.Context, obj client.Object) []reconcile.Request {
 	resourceList := &kongv1beta1.UDPIngressList{}
 	if err := r.Client.List(ctx, resourceList); err != nil {
-		r.Log.Error(err, "failed to list classless udpingresses")
+		r.Log.Error(err, "Failed to list classless udpingresses")
 		return nil
 	}
 	var recs []reconcile.Request
@@ -1652,11 +1652,11 @@ func (r *KongV1Beta1UDPIngressReconciler) Reconcile(ctx context.Context, req ctr
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "UDPIngress", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "UDPIngress", "namespace", req.Namespace, "name", req.Name)
 
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj)
 		if err != nil {
@@ -1678,7 +1678,7 @@ func (r *KongV1Beta1UDPIngressReconciler) Reconcile(ctx context.Context, req ctr
 			// used the class annotation and did not create a corresponding IngressClass. We only need this to determine
 			// if the IngressClass is default or to configure default settings, and can assume no/no additional defaults
 			// if none exists.
-			log.V(util.DebugLevel).Info("could not retrieve IngressClass", "ingressclass", r.IngressClassName)
+			log.V(util.DebugLevel).Info("Could not retrieve IngressClass", "ingressclass", r.IngressClassName)
 		}
 	}
 	// if the object is not configured with our ingress.class, then we need to ensure it's removed from the cache
@@ -1781,11 +1781,11 @@ func (r *KongV1Alpha1IngressClassParametersReconciler) Reconcile(ctx context.Con
 		}
 		return ctrl.Result{}, err
 	}
-	log.V(util.DebugLevel).Info("reconciling resource", "namespace", req.Namespace, "name", req.Name)
+	log.V(util.DebugLevel).Info("Reconciling resource", "namespace", req.Namespace, "name", req.Name)
 
 	// clean the object up if it's being deleted
 	if !obj.DeletionTimestamp.IsZero() && time.Now().After(obj.DeletionTimestamp.Time) {
-		log.V(util.DebugLevel).Info("resource is being deleted, its configuration will be removed", "type", "IngressClassParameters", "namespace", req.Namespace, "name", req.Name)
+		log.V(util.DebugLevel).Info("Resource is being deleted, its configuration will be removed", "type", "IngressClassParameters", "namespace", req.Namespace, "name", req.Name)
 
 		objectExistsInCache, err := r.DataplaneClient.ObjectExists(obj)
 		if err != nil {
diff --git a/internal/controllers/gateway/gateway_controller.go b/internal/controllers/gateway/gateway_controller.go
index 1a56e7cee..ea41d5531 100644
--- a/internal/controllers/gateway/gateway_controller.go
+++ b/internal/controllers/gateway/gateway_controller.go
@@ -173,14 +173,14 @@ func (r *GatewayReconciler) gatewayHasMatchingGatewayClass(obj client.Object) bo
 	if !ok {
 		r.Log.Error(
 			fmt.Errorf("unexpected object type"),
-			"gateway watch predicate received unexpected object type",
+			"Gateway watch predicate received unexpected object type",
 			"expected", "*gatewayapi.Gateway", "found", reflect.TypeOf(obj),
 		)
 		return false
 	}
 	gatewayClass := &gatewayapi.GatewayClass{}
 	if err := r.Client.Get(context.Background(), client.ObjectKey{Name: string(gateway.Spec.GatewayClassName)}, gatewayClass); err != nil {
-		r.Log.Error(err, "could not retrieve gatewayclass", "gatewayclass", gateway.Spec.GatewayClassName)
+		r.Log.Error(err, "Could not retrieve gatewayclass", "gatewayclass", gateway.Spec.GatewayClassName)
 		return false
 	}
 	return isGatewayClassControlledAndUnmanaged(gatewayClass)
@@ -193,7 +193,7 @@ func (r *GatewayReconciler) gatewayClassMatchesController(obj client.Object) boo
 	if !ok {
 		r.Log.Error(
 			fmt.Errorf("unexpected object type"),
-			"gatewayclass watch predicate received unexpected object type",
+			"Gatewayclass watch predicate received unexpected object type",
 			"expected", "*gatewayapi.GatewayClass", "found", reflect.TypeOf(obj),
 		)
 		return false
@@ -207,7 +207,7 @@ func (r *GatewayReconciler) gatewayClassMatchesController(obj client.Object) boo
 func (r *GatewayReconciler) listGatewaysForGatewayClass(ctx context.Context, gatewayClass client.Object) []reconcile.Request {
 	gateways := &gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, gateways); err != nil {
-		r.Log.Error(err, "failed to list gateways for gatewayclass in watch", "gatewayclass", gatewayClass.GetName())
+		r.Log.Error(err, "Failed to list gateways for gatewayclass in watch", "gatewayclass", gatewayClass.GetName())
 		return nil
 	}
 	return reconcileGatewaysIfClassMatches(gatewayClass, gateways.Items)
@@ -220,14 +220,14 @@ func (r *GatewayReconciler) listReferenceGrantsForGateway(ctx context.Context, o
 	if !ok {
 		r.Log.Error(
 			fmt.Errorf("unexpected object type"),
-			"referencegrant watch predicate received unexpected object type",
+			"Referencegrant watch predicate received unexpected object type",
 			"expected", "*gatewayapi.ReferenceGrant", "found", reflect.TypeOf(obj),
 		)
 		return nil
 	}
 	gateways := &gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, gateways); err != nil {
-		r.Log.Error(err, "failed to list gateways in watch", "referencegrant", grant.Name)
+		r.Log.Error(err, "Failed to list gateways in watch", "referencegrant", grant.Name)
 		return nil
 	}
 	recs := []reconcile.Request{}
@@ -255,7 +255,7 @@ func (r *GatewayReconciler) listReferenceGrantsForGateway(ctx context.Context, o
 func (r *GatewayReconciler) listGatewaysForService(ctx context.Context, svc client.Object) (recs []reconcile.Request) {
 	gateways := &gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, gateways); err != nil {
-		r.Log.Error(err, "failed to list gateways for service in watch predicates", "service", svc)
+		r.Log.Error(err, "Failed to list gateways for service in watch predicates", "service", svc)
 		return
 	}
 	for _, gateway := range gateways.Items {
@@ -282,7 +282,7 @@ func (r *GatewayReconciler) listGatewaysForHTTPRoute(_ context.Context, obj clie
 	if !ok {
 		r.Log.Error(
 			fmt.Errorf("unexpected object type"),
-			"httproute watch predicate received unexpected object type",
+			"HTTPRoute watch predicate received unexpected object type",
 			"expected", "*gatewayapi.HTTPRoute", "found", reflect.TypeOf(obj),
 		)
 		return nil
@@ -344,22 +344,22 @@ func (r *GatewayReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			if err != nil {
 				return ctrl.Result{}, err
 			}
-			debug(log, gateway, "reconciliation triggered but gateway does not exist, deleting it in dataplane")
+			debug(log, gateway, "Reconciliation triggered but gateway does not exist, deleting it in dataplane")
 			return ctrl.Result{}, r.DataplaneClient.DeleteObject(gateway)
 		}
 		return ctrl.Result{Requeue: true}, err
 	}
 
-	debug(log, gateway, "processing gateway")
+	debug(log, gateway, "Processing gateway")
 
 	// though our watch configuration eliminates reconciliation of unsupported gateways it's
 	// technically possible for the gatewayclass configuration of a gateway to change in
 	// the interim while the object has been queued for reconciliation. This double check
 	// reduces reconciliation operations that would occur on old information.
-	debug(log, gateway, "verifying gatewayclass")
+	debug(log, gateway, "Verifying gatewayclass")
 	gwc := &gatewayapi.GatewayClass{}
 	if err := r.Client.Get(ctx, client.ObjectKey{Name: string(gateway.Spec.GatewayClassName)}, gwc); err != nil {
-		debug(log, gateway, "could not retrieve gatewayclass for gateway", "gatewayclass", string(gateway.Spec.GatewayClassName))
+		debug(log, gateway, "Could not retrieve gatewayclass for gateway", "gatewayclass", string(gateway.Spec.GatewayClassName))
 		// delete reference relationships where the gateway is the referrer, as we will not process the gateway.
 		err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, gateway)
 		if err != nil {
@@ -369,11 +369,11 @@ func (r *GatewayReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			debug(log, gateway, "failed to delete object from data-plane, requeuing")
 			return ctrl.Result{}, err
 		}
-		debug(log, gateway, "ensured gateway was removed from the data-plane (if ever present)")
+		debug(log, gateway, "Ensured gateway was removed from the data-plane (if ever present)")
 		return ctrl.Result{}, nil
 	}
 	if gwc.Spec.ControllerName != GetControllerName() {
-		debug(log, gateway, "unsupported gatewayclass controllername, ignoring", "gatewayclass", gwc.Name, "controllername", gwc.Spec.ControllerName)
+		debug(log, gateway, "Unsupported gatewayclass controllername, ignoring", "gatewayclass", gwc.Name, "controllername", gwc.Spec.ControllerName)
 		// delete reference relationships where the gateway is the referrer, as we will not process the gateway.
 		err := ctrlref.DeleteReferencesByReferrer(r.ReferenceIndexers, r.DataplaneClient, gateway)
 		if err != nil {
@@ -383,14 +383,14 @@ func (r *GatewayReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 			debug(log, gateway, "failed to delete object from data-plane, requeuing")
 			return ctrl.Result{}, err
 		}
-		debug(log, gateway, "ensured gateway was removed from the data-plane (if ever present)")
+		debug(log, gateway, "Ensured gateway was removed from the data-plane (if ever present)")
 		return ctrl.Result{}, nil
 	}
 
 	// if there's any deletion timestamp on the object, we can simply ignore it. At this point
 	// with unmanaged mode being the only option supported there are no finalizers and
 	// the object should be cleaned up by GC promptly.
-	debug(log, gateway, "checking deletion timestamp")
+	debug(log, gateway, "Checking deletion timestamp")
 	if gateway.DeletionTimestamp != nil {
 		debug(log, gateway, "gateway is being deleted, ignoring")
 		return ctrl.Result{Requeue: false}, nil
@@ -436,10 +436,10 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 	// currently this controller supports only unmanaged gateway mode, we need to verify
 	// any Gateway object that comes to us is configured appropriately, and if not reject it
 	// with a clear status condition and message.
-	debug(log, gateway, "validating management mode for gateway") // this will also be done by the validating webhook, this is a fallback
+	debug(log, gateway, "Validating management mode for gateway") // this will also be done by the validating webhook, this is a fallback
 
 	// enforce the service reference as the annotation value for the key UnmanagedGateway.
-	debug(log, gateway, "initializing admin service annotation if unset")
+	debug(log, gateway, "Initializing admin service annotation if unset")
 	if len(annotations.ExtractGatewayPublishService(gateway.Annotations)) == 0 {
 		services := []string{r.PublishServiceRef.String()}
 
@@ -448,7 +448,7 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 			services = append(services, udpRef.String())
 		}
 
-		debug(log, gateway, fmt.Sprintf("no publish service annotation, setting it to proxy services %s", services))
+		debug(log, gateway, fmt.Sprintf("No publish service annotation, setting it to proxy services %s", services))
 		if gateway.Annotations == nil {
 			gateway.Annotations = map[string]string{}
 		}
@@ -459,13 +459,13 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 	serviceRefs := annotations.ExtractGatewayPublishService(gateway.Annotations)
 	// Validation check of the Gateway to ensure that the ingress service is actually available
 	// in the cluster. If it is not the object will be requeued until it exists (or is otherwise retrievable).
-	debug(log, gateway, "gathering the gateway publish service") // this will also be done by the validating webhook, this is a fallback
+	debug(log, gateway, "Gathering the gateway publish service") // this will also be done by the validating webhook, this is a fallback
 	var gatewayServices []*corev1.Service
 	for _, ref := range serviceRefs {
-		r.Log.V(util.DebugLevel).Info("determining service for ref", "ref", ref)
+		r.Log.V(util.DebugLevel).Info("Determining service for ref", "ref", ref)
 		svc, err := r.determineServiceForGateway(ctx, ref)
 		if err != nil {
-			log.Error(err, "could not determine service for gateway", "namespace", gateway.Namespace, "name", gateway.Name)
+			log.Error(err, "Could not determine service for gateway", "namespace", gateway.Namespace, "name", gateway.Name)
 			return ctrl.Result{Requeue: true}, err
 		}
 		if svc != nil {
@@ -476,7 +476,7 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 	// set the Gateway as scheduled to indicate that validation is complete and reconciliation work
 	// on the object is ready to begin.
 	if !isGatewayScheduled(gateway) {
-		info(log, gateway, "marking gateway as accepted")
+		info(log, gateway, "Marking gateway as accepted")
 		acceptedCondition := metav1.Condition{
 			Type:               string(gatewayapi.GatewayConditionAccepted),
 			Status:             metav1.ConditionTrue,
@@ -503,7 +503,7 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 	// from the Kubernetes Service which will also give us all the L4 information about the proxy. From there
 	// we can use that L4 information to derive the higher level TLS and HTTP,GRPC, e.t.c. information from
 	// the data-plane's metadata.
-	debug(log, gateway, "determining listener configurations from publish services")
+	debug(log, gateway, "Determining listener configurations from publish services")
 	var combinedAddresses []gatewayapi.GatewayAddress
 	var combinedListeners []gatewayapi.Listener
 	for _, svc := range gatewayServices {
@@ -511,7 +511,7 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 		if err != nil {
 			return ctrl.Result{}, err
 		}
-		debug(log, gateway, "determining listener configurations from Kong data-plane")
+		debug(log, gateway, "Determining listener configurations from Kong data-plane")
 		kongListeners, err = r.determineListenersFromDataPlane(ctx, svc, kongListeners)
 		if err != nil {
 			return ctrl.Result{}, err
@@ -521,7 +521,7 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 	}
 
 	if !reflect.DeepEqual(gateway.Spec.Addresses, combinedAddresses) {
-		debug(log, gateway, "updating addresses to match Kong proxy Services")
+		debug(log, gateway, "Updating addresses to match Kong proxy Services")
 		gateway.Spec.Addresses = combinedAddresses
 		if err := r.Update(ctx, gateway); err != nil {
 			if apierrors.IsConflict(err) {
@@ -550,7 +550,7 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 	// once specification matches the reference Service, all that's left to do is ensure that the
 	// Gateway status reflects the spec. As the status is simply a mirror of the Service, this is
 	// a given and we can simply update spec to status.
-	debug(log, gateway, "updating the gateway status if necessary")
+	debug(log, gateway, "Updating the gateway status if necessary")
 	isChanged, err := r.updateAddressesAndListenersStatus(ctx, gateway, listenerStatuses)
 	if err != nil {
 		if apierrors.IsConflict(err) {
@@ -560,11 +560,11 @@ func (r *GatewayReconciler) reconcileUnmanagedGateway(ctx context.Context, log l
 		return ctrl.Result{}, err
 	}
 	if isChanged {
-		debug(log, gateway, "gateways status updated")
+		debug(log, gateway, "Gateway status updated")
 		return ctrl.Result{}, nil
 	}
 
-	info(log, gateway, "gateway provisioning complete")
+	info(log, gateway, "Gateway provisioning complete")
 	return ctrl.Result{}, nil
 }
 
@@ -617,7 +617,7 @@ func (r *GatewayReconciler) determineServiceForGateway(ctx context.Context, ref
 	// retrieve the service for the kong gateway
 	svc := &corev1.Service{}
 	if name.Name == "" && name.Namespace == "" {
-		r.Log.V(util.DebugLevel).Info("service not configured, discarding it", "ref", ref)
+		r.Log.V(util.DebugLevel).Info("Service not configured, discarding it", "ref", ref)
 		return nil, nil
 	}
 	return svc, r.Client.Get(ctx, name, svc)
@@ -669,7 +669,7 @@ func (r *GatewayReconciler) determineL4ListenersFromService(
 		// if the loadbalancer IPs/Hosts haven't been provisioned yet
 		// the service is not ready and we'll need to wait.
 		if len(svc.Status.LoadBalancer.Ingress) < 1 {
-			info(log, svc, "gateway service is type LoadBalancer but has not yet been provisioned: LoadBalancer IPs can not be added to the Gateway's addresses until this is resolved")
+			info(log, svc, "Gateway service is type LoadBalancer but has not yet been provisioned: LoadBalancer IPs can not be added to the Gateway's addresses until this is resolved")
 			return addresses, listeners, nil
 		}
 
diff --git a/internal/controllers/gateway/gateway_utils.go b/internal/controllers/gateway/gateway_utils.go
index cfe16bc30..1efc761ff 100644
--- a/internal/controllers/gateway/gateway_utils.go
+++ b/internal/controllers/gateway/gateway_utils.go
@@ -584,14 +584,14 @@ func isGatewayClassEventInClass(log logr.Logger, watchEvent interface{}) bool {
 		objs = append(objs, e.ObjectOld)
 		objs = append(objs, e.ObjectNew)
 	default:
-		log.Error(fmt.Errorf("invalid type"), "received invalid event type in event handlers", "found", reflect.TypeOf(watchEvent))
+		log.Error(fmt.Errorf("invalid type"), "Received invalid event type in event handlers", "found", reflect.TypeOf(watchEvent))
 		return false
 	}
 
 	for _, obj := range objs {
 		gwc, ok := obj.(*gatewayapi.GatewayClass)
 		if !ok {
-			log.Error(fmt.Errorf("invalid type"), "received invalid object type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
+			log.Error(fmt.Errorf("invalid type"), "Received invalid object type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
 			continue
 		}
 		if gwc.Spec.ControllerName == GetControllerName() {
diff --git a/internal/controllers/gateway/gatewayclass_controller.go b/internal/controllers/gateway/gatewayclass_controller.go
index 37dbd3f91..2e63006a1 100644
--- a/internal/controllers/gateway/gatewayclass_controller.go
+++ b/internal/controllers/gateway/gatewayclass_controller.go
@@ -115,13 +115,13 @@ func (r *GatewayClassReconciler) Reconcile(ctx context.Context, req ctrl.Request
 	gwc := new(gatewayapi.GatewayClass)
 	if err := r.Client.Get(ctx, req.NamespacedName, gwc); err != nil {
 		if apierrors.IsNotFound(err) {
-			log.V(util.DebugLevel).Info("object enqueued no longer exists, skipping", "name", req.Name)
+			log.V(util.DebugLevel).Info("Object enqueued no longer exists, skipping", "name", req.Name)
 			return ctrl.Result{}, nil
 		}
 		return ctrl.Result{}, err
 	}
 
-	log.V(util.DebugLevel).Info("processing gatewayclass", "name", req.Name)
+	log.V(util.DebugLevel).Info("Processing gatewayclass", "name", req.Name)
 
 	if isGatewayClassControlledAndUnmanaged(gwc) {
 		alreadyAccepted := util.CheckCondition(
diff --git a/internal/controllers/gateway/grpcroute_controller.go b/internal/controllers/gateway/grpcroute_controller.go
index 6aedde096..f78a00d2f 100644
--- a/internal/controllers/gateway/grpcroute_controller.go
+++ b/internal/controllers/gateway/grpcroute_controller.go
@@ -128,14 +128,14 @@ func (r *GRPCRouteReconciler) listGRPCRoutesForGatewayClass(ctx context.Context,
 	// verify that the object is a GatewayClass
 	gwc, ok := obj.(*gatewayapi.GatewayClass)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all Gateway objects
 	gatewayList := gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, &gatewayList); err != nil {
-		r.Log.Error(err, "failed to list gateway objects from the cached client")
+		r.Log.Error(err, "Failed to list gateway objects from the cached client")
 		return nil
 	}
 
@@ -159,7 +159,7 @@ func (r *GRPCRouteReconciler) listGRPCRoutesForGatewayClass(ctx context.Context,
 	// map all GRPCRoute objects
 	grpcrouteList := gatewayapi.GRPCRouteList{}
 	if err := r.Client.List(ctx, &grpcrouteList); err != nil {
-		r.Log.Error(err, "failed to list grpcroute objects from the cached client")
+		r.Log.Error(err, "Failed to list grpcroute objects from the cached client")
 		return nil
 	}
 
@@ -213,14 +213,14 @@ func (r *GRPCRouteReconciler) listGRPCRoutesForGateway(ctx context.Context, obj
 	// verify that the object is a Gateway
 	gw, ok := obj.(*gatewayapi.Gateway)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all GRPCRoute objects
 	grpcrouteList := gatewayapi.GRPCRouteList{}
 	if err := r.Client.List(ctx, &grpcrouteList); err != nil {
-		r.Log.Error(err, "failed to list grpcroute objects from the cached client")
+		r.Log.Error(err, "Failed to list grpcroute objects from the cached client")
 		return nil
 	}
 
diff --git a/internal/controllers/gateway/httproute_controller.go b/internal/controllers/gateway/httproute_controller.go
index 890db3656..22c68220c 100644
--- a/internal/controllers/gateway/httproute_controller.go
+++ b/internal/controllers/gateway/httproute_controller.go
@@ -151,14 +151,14 @@ func (r *HTTPRouteReconciler) listReferenceGrantsForHTTPRoute(ctx context.Contex
 	if !ok {
 		r.Log.Error(
 			fmt.Errorf("unexpected object type"),
-			"referencegrant watch predicate received unexpected object type",
+			"Referencegrant watch predicate received unexpected object type",
 			"expected", "*gatewayapi.ReferenceGrant", "found", reflect.TypeOf(obj),
 		)
 		return nil
 	}
 	httproutes := &gatewayapi.HTTPRouteList{}
 	if err := r.Client.List(ctx, httproutes); err != nil {
-		r.Log.Error(err, "failed to list httproutes in watch", "referencegrant", grant.Name)
+		r.Log.Error(err, "Failed to list httproutes in watch", "referencegrant", grant.Name)
 		return nil
 	}
 	recs := []reconcile.Request{}
@@ -202,14 +202,14 @@ func (r *HTTPRouteReconciler) listHTTPRoutesForGatewayClass(ctx context.Context,
 	// verify that the object is a GatewayClass
 	gwc, ok := obj.(*gatewayapi.GatewayClass)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all Gateway objects
 	gatewayList := gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, &gatewayList); err != nil {
-		r.Log.Error(err, "failed to list gateway objects from the cached client")
+		r.Log.Error(err, "Failed to list gateway objects from the cached client")
 		return nil
 	}
 
@@ -233,7 +233,7 @@ func (r *HTTPRouteReconciler) listHTTPRoutesForGatewayClass(ctx context.Context,
 	// map all HTTPRoute objects
 	httprouteList := gatewayapi.HTTPRouteList{}
 	if err := r.Client.List(ctx, &httprouteList); err != nil {
-		r.Log.Error(err, "failed to list httproute objects from the cached client")
+		r.Log.Error(err, "Failed to list httproute objects from the cached client")
 		return nil
 	}
 
@@ -287,14 +287,14 @@ func (r *HTTPRouteReconciler) listHTTPRoutesForGateway(ctx context.Context, obj
 	// verify that the object is a Gateway
 	gw, ok := obj.(*gatewayapi.Gateway)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all HTTPRoute objects
 	httprouteList := gatewayapi.HTTPRouteList{}
 	if err := r.Client.List(ctx, &httprouteList); err != nil {
-		r.Log.Error(err, "failed to list httproute objects from the cached client")
+		r.Log.Error(err, "Failed to list httproute objects from the cached client")
 		return nil
 	}
 
diff --git a/internal/controllers/gateway/tcproute_controller.go b/internal/controllers/gateway/tcproute_controller.go
index c4d627941..9fcf4ba75 100644
--- a/internal/controllers/gateway/tcproute_controller.go
+++ b/internal/controllers/gateway/tcproute_controller.go
@@ -125,14 +125,14 @@ func (r *TCPRouteReconciler) listTCPRoutesForGatewayClass(ctx context.Context, o
 	// verify that the object is a GatewayClass
 	gwc, ok := obj.(*gatewayapi.GatewayClass)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all Gateway objects
 	gatewayList := gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, &gatewayList); err != nil {
-		r.Log.Error(err, "failed to list gateway objects from the cached client")
+		r.Log.Error(err, "Failed to list gateway objects from the cached client")
 		return nil
 	}
 
@@ -156,7 +156,7 @@ func (r *TCPRouteReconciler) listTCPRoutesForGatewayClass(ctx context.Context, o
 	// map all TCPRoute objects
 	tcprouteList := gatewayapi.TCPRouteList{}
 	if err := r.Client.List(ctx, &tcprouteList); err != nil {
-		r.Log.Error(err, "failed to list tcproute objects from the cached client")
+		r.Log.Error(err, "Failed to list tcproute objects from the cached client")
 		return nil
 	}
 
@@ -210,14 +210,14 @@ func (r *TCPRouteReconciler) listTCPRoutesForGateway(ctx context.Context, obj cl
 	// verify that the object is a Gateway
 	gw, ok := obj.(*gatewayapi.Gateway)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all TCPRoute objects
 	tcprouteList := gatewayapi.TCPRouteList{}
 	if err := r.Client.List(ctx, &tcprouteList); err != nil {
-		r.Log.Error(err, "failed to list tcproute objects from the cached client")
+		r.Log.Error(err, "Failed to list tcproute objects from the cached client")
 		return nil
 	}
 
diff --git a/internal/controllers/gateway/tlsroute_controller.go b/internal/controllers/gateway/tlsroute_controller.go
index bb695d0d4..88358f5a4 100644
--- a/internal/controllers/gateway/tlsroute_controller.go
+++ b/internal/controllers/gateway/tlsroute_controller.go
@@ -124,14 +124,14 @@ func (r *TLSRouteReconciler) listTLSRoutesForGatewayClass(ctx context.Context, o
 	// verify that the object is a GatewayClass
 	gwc, ok := obj.(*gatewayapi.GatewayClass)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all Gateway objects
 	gatewayList := gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, &gatewayList); err != nil {
-		r.Log.Error(err, "failed to list gateway objects from the cached client")
+		r.Log.Error(err, "Failed to list gateway objects from the cached client")
 		return nil
 	}
 
@@ -155,7 +155,7 @@ func (r *TLSRouteReconciler) listTLSRoutesForGatewayClass(ctx context.Context, o
 	// map all TLSRoute objects
 	tlsrouteList := gatewayapi.TLSRouteList{}
 	if err := r.Client.List(ctx, &tlsrouteList); err != nil {
-		r.Log.Error(err, "failed to list tlsroute objects from the cached client")
+		r.Log.Error(err, "Failed to list tlsroute objects from the cached client")
 		return nil
 	}
 
@@ -209,14 +209,14 @@ func (r *TLSRouteReconciler) listTLSRoutesForGateway(ctx context.Context, obj cl
 	// verify that the object is a Gateway
 	gw, ok := obj.(*gatewayapi.Gateway)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all TLSRoute objects
 	tlsrouteList := gatewayapi.TLSRouteList{}
 	if err := r.Client.List(ctx, &tlsrouteList); err != nil {
-		r.Log.Error(err, "failed to list tlsroute objects from the cached client")
+		r.Log.Error(err, "Failed to list tlsroute objects from the cached client")
 		return nil
 	}
 
diff --git a/internal/controllers/gateway/udproute_controller.go b/internal/controllers/gateway/udproute_controller.go
index 5af4eb145..6edc0d647 100644
--- a/internal/controllers/gateway/udproute_controller.go
+++ b/internal/controllers/gateway/udproute_controller.go
@@ -124,14 +124,14 @@ func (r *UDPRouteReconciler) listUDPRoutesForGatewayClass(ctx context.Context, o
 	// verify that the object is a GatewayClass
 	gwc, ok := obj.(*gatewayapi.GatewayClass)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "GatewayClass", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all Gateway objects
 	gatewayList := gatewayapi.GatewayList{}
 	if err := r.Client.List(ctx, &gatewayList); err != nil {
-		r.Log.Error(err, "failed to list gateway objects from the cached client")
+		r.Log.Error(err, "Failed to list gateway objects from the cached client")
 		return nil
 	}
 
@@ -155,7 +155,7 @@ func (r *UDPRouteReconciler) listUDPRoutesForGatewayClass(ctx context.Context, o
 	// map all UDPRoute objects
 	udprouteList := gatewayapi.UDPRouteList{}
 	if err := r.Client.List(ctx, &udprouteList); err != nil {
-		r.Log.Error(err, "failed to list udproute objects from the cached client")
+		r.Log.Error(err, "Failed to list udproute objects from the cached client")
 		return nil
 	}
 
@@ -209,14 +209,14 @@ func (r *UDPRouteReconciler) listUDPRoutesForGateway(ctx context.Context, obj cl
 	// verify that the object is a Gateway
 	gw, ok := obj.(*gatewayapi.Gateway)
 	if !ok {
-		r.Log.Error(fmt.Errorf("invalid type"), "found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
+		r.Log.Error(fmt.Errorf("invalid type"), "Found invalid type in event handlers", "expected", "Gateway", "found", reflect.TypeOf(obj))
 		return nil
 	}
 
 	// map all UDPRoute objects
 	udprouteList := gatewayapi.UDPRouteList{}
 	if err := r.Client.List(ctx, &udprouteList); err != nil {
-		r.Log.Error(err, "failed to list udproute objects from the cached client")
+		r.Log.Error(err, "Failed to list udproute objects from the cached client")
 		return nil
 	}
 
diff --git a/internal/controllers/reference/reference.go b/internal/controllers/reference/reference.go
index 6fe0997d7..18b8a85e9 100644
--- a/internal/controllers/reference/reference.go
+++ b/internal/controllers/reference/reference.go
@@ -121,7 +121,7 @@ func removeOutdatedReferencesToSecret(
 func DeleteReferencesByReferrer(indexers CacheIndexers, dataplaneClient controllers.DataPlaneClient, referrer client.Object) error {
 	referents, err := indexers.ListReferredObjects(referrer)
 	if err != nil {
-		indexers.logger.Error(err, "failed to list referred objects",
+		indexers.logger.Error(err, "Failed to list referred objects",
 			"referrer_kind", referrer.GetObjectKind().GroupVersionKind().String(),
 			"referrer_namespace", referrer.GetNamespace(),
 			"referrer_name", referrer.GetName(),
diff --git a/internal/dataplane/configfetcher/config_fetcher.go b/internal/dataplane/configfetcher/config_fetcher.go
index f3555cb06..a705d9638 100644
--- a/internal/dataplane/configfetcher/config_fetcher.go
+++ b/internal/dataplane/configfetcher/config_fetcher.go
@@ -59,7 +59,7 @@ func (cf *DefaultKongLastGoodConfigFetcher) TryFetchingValidConfigFromGateways(
 	logger logr.Logger,
 	gatewayClients []*adminapi.Client,
 ) error {
-	logger.V(util.DebugLevel).Info("fetching last good configuration from gateway clients", "count", len(gatewayClients))
+	logger.V(util.DebugLevel).Info("Fetching last good configuration from gateway clients", "count", len(gatewayClients))
 
 	var (
 		goodKongState *kongstate.KongState
@@ -67,7 +67,7 @@ func (cf *DefaultKongLastGoodConfigFetcher) TryFetchingValidConfigFromGateways(
 		clientUsed    *adminapi.Client
 	)
 	for _, client := range gatewayClients {
-		logger.V(util.DebugLevel).Info("fetching configuration", "url", client.BaseRootURL())
+		logger.V(util.DebugLevel).Info("Fetching configuration", "url", client.BaseRootURL())
 		rs, err := cf.getKongRawState(ctx, client.AdminAPIClient())
 		if err != nil {
 			errs = errors.Join(errs, err)
@@ -97,7 +97,7 @@ func (cf *DefaultKongLastGoodConfigFetcher) TryFetchingValidConfigFromGateways(
 			goodKongState.FillIDs(logger)
 		}
 		cf.lastValidState = goodKongState
-		logger.V(util.DebugLevel).Info("last good configuration fetched from Kong node", "url", clientUsed.BaseRootURL())
+		logger.V(util.DebugLevel).Info("Last good configuration fetched from Kong node", "url", clientUsed.BaseRootURL())
 	}
 	return errs
 }
diff --git a/internal/dataplane/deckgen/generate.go b/internal/dataplane/deckgen/generate.go
index c146338a4..2cba759cd 100644
--- a/internal/dataplane/deckgen/generate.go
+++ b/internal/dataplane/deckgen/generate.go
@@ -51,7 +51,7 @@ func ToDeckContent(
 				Plugin: *p.DeepCopy(),
 			}
 			if err := fillPlugin(ctx, &plugin, params.PluginSchemas); err != nil {
-				logger.Error(err, "failed to fill in defaults for plugin", "plugin_name", *plugin.Name)
+				logger.Error(err, "Failed to fill in defaults for plugin", "plugin_name", *plugin.Name)
 			}
 			service.Plugins = append(service.Plugins, &plugin)
 			sort.SliceStable(service.Plugins, func(i, j int) bool {
@@ -68,7 +68,7 @@ func ToDeckContent(
 					Plugin: *p.DeepCopy(),
 				}
 				if err := fillPlugin(ctx, &plugin, params.PluginSchemas); err != nil {
-					logger.Error(err, "failed to fill in defaults for plugin", "plugin_name", *plugin.Name)
+					logger.Error(err, "Failed to fill in defaults for plugin", "plugin_name", *plugin.Name)
 				}
 				route.Plugins = append(route.Plugins, &plugin)
 				sort.SliceStable(route.Plugins, func(i, j int) bool {
@@ -91,7 +91,7 @@ func ToDeckContent(
 			Plugin: plugin.Plugin,
 		}
 		if err := fillPlugin(ctx, &plugin, params.PluginSchemas); err != nil {
-			logger.Error(err, "failed to fill in defaults for plugin", "plugin_name", *plugin.Name)
+			logger.Error(err, "Failed to fill in defaults for plugin", "plugin_name", *plugin.Name)
 		}
 		content.Plugins = append(content.Plugins, plugin)
 	}
@@ -157,7 +157,7 @@ func ToDeckContent(
 		// fail the rest of the deckgen either or this will result in one bad consumer being capable of
 		// stopping all updates to the Kong Admin API.
 		if consumer.Username == nil {
-			logger.Error(nil, "invalid consumer received (username was empty)")
+			logger.Error(nil, "Invalid consumer received (username was empty)")
 			continue
 		}
 
diff --git a/internal/dataplane/failures/failures.go b/internal/dataplane/failures/failures.go
index bbcc89d0f..b628a6990 100644
--- a/internal/dataplane/failures/failures.go
+++ b/internal/dataplane/failures/failures.go
@@ -76,7 +76,7 @@ func NewResourceFailuresCollector(logger logr.Logger) *ResourceFailuresCollector
 func (c *ResourceFailuresCollector) PushResourceFailure(reason string, causingObjects ...client.Object) {
 	resourceFailure, err := NewResourceFailure(reason, causingObjects...)
 	if err != nil {
-		c.logger.Error(err, "failed to create resource failure", "resource_failure_reason", reason)
+		c.logger.Error(err, "Failed to create resource failure", "resource_failure_reason", reason)
 		return
 	}
 
diff --git a/internal/dataplane/kong_client.go b/internal/dataplane/kong_client.go
index 786b511dc..9b5cad625 100644
--- a/internal/dataplane/kong_client.go
+++ b/internal/dataplane/kong_client.go
@@ -390,7 +390,7 @@ func (c *KongClient) Update(ctx context.Context) error {
 			if err := c.kongConfigFetcher.TryFetchingValidConfigFromGateways(ctx, c.logger, c.clientsProvider.GatewayClients()); err != nil {
 				// If the client fails to fetch the last good configuration, we log it
 				// and carry on, as this is a condition that can be recovered with the following steps.
-				c.logger.Error(err, "failed to fetch last good configuration from gateways")
+				c.logger.Error(err, "Failed to fetch last good configuration from gateways")
 			}
 		}
 	}
diff --git a/internal/dataplane/kongstate/kongstate.go b/internal/dataplane/kongstate/kongstate.go
index 9482c7890..ba5e09d3e 100644
--- a/internal/dataplane/kongstate/kongstate.go
+++ b/internal/dataplane/kongstate/kongstate.go
@@ -103,7 +103,7 @@ func (ks *KongState) FillConsumersAndCredentials(
 			}
 			secret, err := s.GetSecret(consumer.Namespace, cred)
 			if err != nil {
-				pushCredentialResourceFailures(fmt.Sprintf("failed to fetch secret: %v", err))
+				pushCredentialResourceFailures(fmt.Sprintf("Failed to fetch secret: %v", err))
 				continue
 			}
 			credConfig := map[string]interface{}{}
@@ -135,7 +135,7 @@ func (ks *KongState) FillConsumersAndCredentials(
 					if err != nil {
 						// add a translation error here to tell that parsing hash_secret failed.
 						pushCredentialResourceFailures(
-							fmt.Sprintf("failed to parse hash_secret to bool: %v. defaulting to false", err),
+							fmt.Sprintf("Failed to parse hash_secret to bool: %v. defaulting to false", err),
 						)
 						credConfig[k] = false
 					} else {
@@ -150,7 +150,7 @@ func (ks *KongState) FillConsumersAndCredentials(
 					if err != nil {
 						// add a translation error here to tell that parsing TTL failed.
 						pushCredentialResourceFailures(
-							fmt.Sprintf("failed to parse ttl to int: %v, skipfilling the field", err),
+							fmt.Sprintf("Failed to parse ttl to int: %v, skipfilling the field", err),
 						)
 					} else {
 						credConfig[k] = intVal
@@ -341,7 +341,7 @@ func buildPlugins(
 		namespace, kongPluginName := identifier[0], identifier[1]
 		k8sPlugin, k8sClusterPlugin, err := getKongPluginOrKongClusterPlugin(s, namespace, kongPluginName)
 		if err != nil {
-			logger.Error(err, "failed to fetch KongPlugin resource",
+			logger.Error(err, "Failed to fetch KongPlugin resource",
 				"kongplugin_name", kongPluginName,
 				"kongplugin_namespace", namespace)
 			continue
@@ -404,7 +404,7 @@ func buildPlugins(
 
 	gKCPs, err := globalKongClusterPlugins(logger, s)
 	if err != nil {
-		logger.Error(err, "failed to fetch global plugins")
+		logger.Error(err, "Failed to fetch global plugins")
 	}
 	// global plugins have no instance_name transform as they can only be applied once
 	plugins = append(plugins, gKCPs...)
diff --git a/internal/dataplane/parser/ingressrules.go b/internal/dataplane/parser/ingressrules.go
index 95ab7e1d1..07e304b60 100644
--- a/internal/dataplane/parser/ingressrules.go
+++ b/internal/dataplane/parser/ingressrules.go
@@ -84,7 +84,7 @@ func (ir *ingressRules) populateServices(logger logr.Logger, s store.Storer, fai
 				secret, err := s.GetSecret(k8sService.Namespace, secretName)
 				if err != nil {
 					failuresCollector.PushResourceFailure(
-						fmt.Sprintf("failed to fetch secret '%s': %v", secretKey, err), k8sService,
+						fmt.Sprintf("Failed to fetch secret '%s': %v", secretKey, err), k8sService,
 					)
 					continue
 				}
@@ -260,7 +260,7 @@ func getK8sServicesForBackends(
 		}
 		k8sService, err := storer.GetService(backendNamespace, backend.Name)
 		if err != nil {
-			log.Error(err, "failed to fetch service",
+			log.Error(err, "Failed to fetch service",
 				"service_name", backend.PortDef.Name,
 				"service_namespace", backendNamespace,
 			)
diff --git a/internal/dataplane/parser/parser.go b/internal/dataplane/parser/parser.go
index 1a11bb2b9..3a592f63d 100644
--- a/internal/dataplane/parser/parser.go
+++ b/internal/dataplane/parser/parser.go
@@ -466,7 +466,7 @@ func (p *Parser) getGatewayCerts() []certWrapper {
 	certs := []certWrapper{}
 	gateways, err := s.ListGateways()
 	if err != nil {
-		logger.Error(err, "failed to list Gateways")
+		logger.Error(err, "Failed to list Gateways")
 		return certs
 	}
 	for _, gateway := range gateways {
@@ -517,7 +517,7 @@ func (p *Parser) getGatewayCerts() []certWrapper {
 					// retrieve the Secret and extract the PEM strings
 					secret, err := s.GetSecret(namespace, string(ref.Name))
 					if err != nil {
-						logger.Error(err, "failed to fetch secret",
+						logger.Error(err, "Failed to fetch secret",
 							"gateway", gateway.Name,
 							"listener", listener.Name,
 							"secret_name", string(ref.Name),
@@ -563,7 +563,7 @@ func (p *Parser) getCerts(secretsToSNIs SecretNameToSNIs) []certWrapper {
 		namespaceName := strings.Split(secretKey, "/")
 		secret, err := p.storer.GetSecret(namespaceName[0], namespaceName[1])
 		if err != nil {
-			p.registerTranslationFailure(fmt.Sprintf("failed to fetch the secret (%s)", secretKey), SNIs.Parents()...)
+			p.registerTranslationFailure(fmt.Sprintf("Failed to fetch the secret (%s)", secretKey), SNIs.Parents()...)
 			continue
 		}
 		cert, key, err := getCertFromSecret(secret)
diff --git a/internal/dataplane/parser/translate_grpcroute.go b/internal/dataplane/parser/translate_grpcroute.go
index 071441c4e..0db4acd30 100644
--- a/internal/dataplane/parser/translate_grpcroute.go
+++ b/internal/dataplane/parser/translate_grpcroute.go
@@ -19,7 +19,7 @@ func (p *Parser) ingressRulesFromGRPCRoutes() ingressRules {
 
 	grpcRouteList, err := p.storer.ListGRPCRoutes()
 	if err != nil {
-		p.logger.Error(err, "failed to list GRPCRoutes")
+		p.logger.Error(err, "Failed to list GRPCRoutes")
 		return result
 	}
 
diff --git a/internal/dataplane/parser/translate_httproute.go b/internal/dataplane/parser/translate_httproute.go
index e4eb097bf..7294722c4 100644
--- a/internal/dataplane/parser/translate_httproute.go
+++ b/internal/dataplane/parser/translate_httproute.go
@@ -26,7 +26,7 @@ func (p *Parser) ingressRulesFromHTTPRoutes() ingressRules {
 
 	httpRouteList, err := p.storer.ListHTTPRoutes()
 	if err != nil {
-		p.logger.Error(err, "failed to list HTTPRoutes")
+		p.logger.Error(err, "Failed to list HTTPRoutes")
 		return result
 	}
 
diff --git a/internal/dataplane/parser/translate_ingress.go b/internal/dataplane/parser/translate_ingress.go
index 6434daf07..ee6b808be 100644
--- a/internal/dataplane/parser/translate_ingress.go
+++ b/internal/dataplane/parser/translate_ingress.go
@@ -24,7 +24,7 @@ func (p *Parser) ingressRulesFromIngressV1() ingressRules {
 	if err != nil {
 		if !errors.As(err, &store.NotFoundError{}) {
 			// anything else is unexpected
-			p.logger.Error(err, "could not retrieve IngressClassParameters, using defaults")
+			p.logger.Error(err, "Could not retrieve IngressClassParameters, using defaults")
 		}
 	}
 
diff --git a/internal/dataplane/parser/translate_kong_l4.go b/internal/dataplane/parser/translate_kong_l4.go
index 85934eb0d..373165f92 100644
--- a/internal/dataplane/parser/translate_kong_l4.go
+++ b/internal/dataplane/parser/translate_kong_l4.go
@@ -16,7 +16,7 @@ func (p *Parser) ingressRulesFromTCPIngressV1beta1() ingressRules {
 
 	ingressList, err := p.storer.ListTCPIngresses()
 	if err != nil {
-		p.logger.Error(err, "failed to list TCPIngresses")
+		p.logger.Error(err, "Failed to list TCPIngresses")
 		return result
 	}
 
@@ -93,7 +93,7 @@ func (p *Parser) ingressRulesFromUDPIngressV1beta1() ingressRules {
 
 	ingressList, err := p.storer.ListUDPIngresses()
 	if err != nil {
-		p.logger.Error(err, "failed to list UDPIngresses")
+		p.logger.Error(err, "Failed to list UDPIngresses")
 		return result
 	}
 
diff --git a/internal/dataplane/parser/translate_secrets.go b/internal/dataplane/parser/translate_secrets.go
index baaf45b82..03c83f990 100644
--- a/internal/dataplane/parser/translate_secrets.go
+++ b/internal/dataplane/parser/translate_secrets.go
@@ -22,7 +22,7 @@ import (
 func (p *Parser) getCACerts() []kong.CACertificate {
 	caCertSecrets, err := p.storer.ListCACerts()
 	if err != nil {
-		p.logger.Error(err, "failed to list CA certs")
+		p.logger.Error(err, "Failed to list CA certs")
 		return nil
 	}
 
diff --git a/internal/dataplane/parser/translate_tcproute.go b/internal/dataplane/parser/translate_tcproute.go
index bac04a0e7..8bfb9e27a 100644
--- a/internal/dataplane/parser/translate_tcproute.go
+++ b/internal/dataplane/parser/translate_tcproute.go
@@ -18,7 +18,7 @@ func (p *Parser) ingressRulesFromTCPRoutes() ingressRules {
 
 	tcpRouteList, err := p.storer.ListTCPRoutes()
 	if err != nil {
-		p.logger.Error(err, "failed to list TCPRoutes")
+		p.logger.Error(err, "Failed to list TCPRoutes")
 		return result
 	}
 
diff --git a/internal/dataplane/parser/translate_tlsroute.go b/internal/dataplane/parser/translate_tlsroute.go
index ba3aaaaa2..b1f52b24c 100644
--- a/internal/dataplane/parser/translate_tlsroute.go
+++ b/internal/dataplane/parser/translate_tlsroute.go
@@ -23,7 +23,7 @@ func (p *Parser) ingressRulesFromTLSRoutes() ingressRules {
 
 	tlsRouteList, err := p.storer.ListTLSRoutes()
 	if err != nil {
-		p.logger.Error(err, "failed to list TLSRoutes")
+		p.logger.Error(err, "Failed to list TLSRoutes")
 		return result
 	}
 
diff --git a/internal/dataplane/parser/translate_udproute.go b/internal/dataplane/parser/translate_udproute.go
index 1b5b5aa07..756c02b54 100644
--- a/internal/dataplane/parser/translate_udproute.go
+++ b/internal/dataplane/parser/translate_udproute.go
@@ -18,7 +18,7 @@ func (p *Parser) ingressRulesFromUDPRoutes() ingressRules {
 
 	udpRouteList, err := p.storer.ListUDPRoutes()
 	if err != nil {
-		p.logger.Error(err, "failed to list UDPRoutes")
+		p.logger.Error(err, "Failed to list UDPRoutes")
 		return result
 	}
 
diff --git a/internal/dataplane/sendconfig/sendconfig.go b/internal/dataplane/sendconfig/sendconfig.go
index 01a5fcd79..81f3b285d 100644
--- a/internal/dataplane/sendconfig/sendconfig.go
+++ b/internal/dataplane/sendconfig/sendconfig.go
@@ -62,9 +62,9 @@ func PerformUpdate(
 		}
 		if !configurationChanged {
 			if client.IsKonnect() {
-				logger.V(util.DebugLevel).Info("no configuration change, skipping sync to Konnect")
+				logger.V(util.DebugLevel).Info("No configuration change, skipping sync to Konnect")
 			} else {
-				logger.V(util.DebugLevel).Info("no configuration change, skipping sync to Kong")
+				logger.V(util.DebugLevel).Info("No configuration change, skipping sync to Kong")
 			}
 			return oldSHA, []failures.ResourceFailure{}, nil
 		}
@@ -94,9 +94,9 @@ func PerformUpdate(
 	promMetrics.RecordPushSuccess(metricsProtocol, duration, client.BaseRootURL())
 
 	if client.IsKonnect() {
-		logger.V(util.InfoLevel).Info("successfully synced configuration to Konnect")
+		logger.V(util.InfoLevel).Info("Successfully synced configuration to Konnect")
 	} else {
-		logger.V(util.InfoLevel).Info("successfully synced configuration to Kong")
+		logger.V(util.InfoLevel).Info("Successfully synced configuration to Kong")
 	}
 
 	return newSHA, nil, nil
@@ -128,13 +128,13 @@ func resourceErrorsToResourceFailures(resourceErrors []ResourceError, parseErr e
 			},
 		}
 		for problemSource, problem := range ee.Problems {
-			logger.V(util.DebugLevel).Info("adding failure", "resource_name", ee.Name, "source", problemSource, "problem", problem)
+			logger.V(util.DebugLevel).Info("Adding failure", "resource_name", ee.Name, "source", problemSource, "problem", problem)
 			resourceFailure, failureCreateErr := failures.NewResourceFailure(
 				fmt.Sprintf("invalid %s: %s", problemSource, problem),
 				&obj,
 			)
 			if failureCreateErr != nil {
-				logger.Error(failureCreateErr, "could not create resource failure event")
+				logger.Error(failureCreateErr, "Could not create resource failure event")
 			} else {
 				out = append(out, resourceFailure)
 			}
diff --git a/internal/konnect/node_agent.go b/internal/konnect/node_agent.go
index f357c559c..0820e1e08 100644
--- a/internal/konnect/node_agent.go
+++ b/internal/konnect/node_agent.go
@@ -349,9 +349,9 @@ func (a *NodeAgent) updateGatewayNodes(ctx context.Context, existingNodes []*nod
 			}
 			newNode, err := a.nodeClient.CreateNode(ctx, createNodeReq)
 			if err != nil {
-				a.logger.Error(err, "failed to create kong gateway node", "hostname", gateway.Hostname)
+				a.logger.Error(err, "Failed to create kong gateway node", "hostname", gateway.Hostname)
 			} else {
-				a.logger.Info("created kong gateway node", "hostname", gateway.Hostname, "node_id", newNode.Item.ID)
+				a.logger.Info("Created kong gateway node", "hostname", gateway.Hostname, "node_id", newNode.Item.ID)
 			}
 			continue
 		}
@@ -452,7 +452,7 @@ func (p *GatewayClientGetter) GetGatewayInstances(ctx context.Context) ([]Gatewa
 	if len(gatewayClients) != 0 {
 		v, err := gatewayClients[0].GetKongVersion(ctx)
 		if err != nil {
-			p.logger.Error(err, "failed to get kong version")
+			p.logger.Error(err, "Failed to get kong version")
 		} else {
 			kongVersion = v
 		}
@@ -468,7 +468,7 @@ func (p *GatewayClientGetter) GetGatewayInstances(ctx context.Context) ([]Gatewa
 			rootURL := client.BaseRootURL()
 			u, err := url.Parse(rootURL)
 			if err != nil {
-				p.logger.Error(err, "failed to parse URL of gateway admin API from raw URL, skipping", "url", rootURL)
+				p.logger.Error(err, "Failed to parse URL of gateway admin API from raw URL, skipping", "url", rootURL)
 				continue
 			}
 			// use "gateway_address" as hostname of konnect node.
@@ -477,7 +477,7 @@ func (p *GatewayClientGetter) GetGatewayInstances(ctx context.Context) ([]Gatewa
 
 		nodeID, err := client.NodeID(ctx)
 		if err != nil {
-			p.logger.Error(err, "failed to get node ID from gateway admin API, skipping", "url", client.BaseRootURL())
+			p.logger.Error(err, "Failed to get node ID from gateway admin API, skipping", "url", client.BaseRootURL())
 			continue
 		}
 
diff --git a/internal/license/agent.go b/internal/license/agent.go
index 280bda9f1..1f89190be 100644
--- a/internal/license/agent.go
+++ b/internal/license/agent.go
@@ -118,7 +118,7 @@ func (a *Agent) Start(ctx context.Context) error {
 	err := a.reconcileLicenseWithKonnect(ctx)
 	if err != nil {
 		// If that happens, GetLicense() will return no license until we retrieve a valid one in polling.
-		a.logger.Error(err, "could not retrieve license from upstream")
+		a.logger.Error(err, "Could not retrieve license from upstream")
 	}
 
 	return a.runPollingLoop(ctx)
diff --git a/internal/manager/config.go b/internal/manager/config.go
index 7d9e1744b..44addb9a9 100644
--- a/internal/manager/config.go
+++ b/internal/manager/config.go
@@ -183,7 +183,7 @@ func (c *Config) FlagSet() *pflag.FlagSet {
 		`Kong Admin URL(s) in comma-separated format (or specify this flag multiple times) to connect to in the format "protocol://address:port".`)
 	flagSet.Var(flags.NewValidatedValue(&c.KongAdminSvc, namespacedNameFromFlagValue, nnTypeNameOverride), "kong-admin-svc",
 		`Kong Admin API Service namespaced name in "namespace/name" format, to use for Kong Gateway service discovery.`)
-	flagSet.StringSliceVar(&c.KongAdminSvcPortNames, "kong-admin-svc-port-names", []string{"admin", "admin-tls", "kong-admin", "kong-admin-tls"},
+	flagSet.StringSliceVar(&c.KongAdminSvcPortNames, "kong-admin-svc-port-names", []string{"admin-tls", "kong-admin-tls"},
 		"Name(s) of ports on Kong Admin API service in comma-separated format (or specify this flag multiple times) to take into account when doing gateway discovery.")
 	flagSet.Var(flags.NewValidatedValue(&c.GatewayDiscoveryDNSStrategy, dnsStrategyFromFlagValue, flags.WithDefault(cfgtypes.IPDNSStrategy), flags.WithTypeNameOverride[cfgtypes.DNSStrategy]("dns-strategy")),
 		"gateway-discovery-dns-strategy", "DNS strategy to use when creating Gateway's Admin API addresses. One of: ip, service, pod.")
diff --git a/internal/manager/run.go b/internal/manager/run.go
index 321c6046b..fc1c521dc 100644
--- a/internal/manager/run.go
+++ b/internal/manager/run.go
@@ -52,24 +52,24 @@ func Run(
 	logger logr.Logger,
 ) error {
 	setupLog := ctrl.LoggerFrom(ctx).WithName("setup")
-	setupLog.Info("starting controller manager", "release", metadata.Release, "repo", metadata.Repo, "commit", metadata.Commit)
-	setupLog.Info("the ingress class name has been set", "value", c.IngressClassName)
+	setupLog.Info("Starting controller manager", "release", metadata.Release, "repo", metadata.Repo, "commit", metadata.Commit)
+	setupLog.Info("The ingress class name has been set", "value", c.IngressClassName)
 
 	gateway.SetControllerName(gatewayapi.GatewayController(c.GatewayAPIControllerName))
 
-	setupLog.Info("getting enabled options and features")
+	setupLog.Info("Getting enabled options and features")
 	featureGates, err := featuregates.New(setupLog, c.FeatureGates)
 	if err != nil {
 		return fmt.Errorf("failed to configure feature gates: %w", err)
 	}
 
-	setupLog.Info("getting the kubernetes client configuration")
+	setupLog.Info("Getting the kubernetes client configuration")
 	kubeconfig, err := c.GetKubeconfig()
 	if err != nil {
 		return fmt.Errorf("get kubeconfig from file %q: %w", c.KubeconfigPath, err)
 	}
 
-	setupLog.Info("starting standalone health check server")
+	setupLog.Info("Starting standalone health check server")
 	healthServer := &healthCheckServer{}
 	healthServer.setHealthzCheck(healthz.Ping)
 	healthServer.Start(ctx, c.ProbeAddr, setupLog.WithName("health-check"))
@@ -86,7 +86,7 @@ func Run(
 
 	adminAPIClientsFactory := adminapi.NewClientFactoryForWorkspace(c.KongWorkspace, c.KongAdminAPIConfig, c.KongAdminToken)
 
-	setupLog.Info("getting the kong admin api client configuration")
+	setupLog.Info("Getting the kong admin api client configuration")
 	initialKongClients, err := c.adminAPIClients(
 		ctx,
 		setupLog.WithName("initialize-kong-clients"),
@@ -129,7 +129,7 @@ func Run(
 	}
 	kongConfig.Init(ctx, setupLog, initialKongClients)
 
-	setupLog.Info("configuring and building the controller manager")
+	setupLog.Info("Configuring and building the controller manager")
 	managerOpts, err := setupManagerOptions(ctx, setupLog, c, dbMode)
 	if err != nil {
 		return fmt.Errorf("unable to setup manager options: %w", err)
@@ -217,7 +217,7 @@ func Run(
 		kubernetesStatusQueue = status.NewQueue(status.WithBufferSize(c.UpdateStatusQueueBufferSize))
 		dataplaneClient.EnableKubernetesObjectReports(kubernetesStatusQueue)
 	} else {
-		setupLog.Info("status updates disabled, skipping status updater")
+		setupLog.Info("Status updates disabled, skipping status updater")
 	}
 
 	setupLog.Info("Initializing Dataplane address Discovery")
@@ -289,7 +289,7 @@ func Run(
 		if err != nil {
 			return fmt.Errorf("failed creating konnect client: %w", err)
 		}
-		setupLog.Info("starting license agent")
+		setupLog.Info("Starting license agent")
 		agent := license.NewAgent(
 			konnectLicenseAPIClient,
 			ctrl.LoggerFrom(ctx).WithName("license-agent"),
@@ -324,13 +324,13 @@ func Run(
 			instanceIDProvider,
 		)
 		if err != nil {
-			setupLog.Error(err, "failed setting up anonymous reports")
+			setupLog.Error(err, "Failed setting up anonymous reports")
 		} else {
 			defer stopAnonymousReports()
 		}
-		setupLog.Info("anonymous reports enabled")
+		setupLog.Info("Anonymous reports enabled")
 	} else {
-		setupLog.Info("anonymous reports disabled, skipping")
+		setupLog.Info("Anonymous reports disabled, skipping")
 	}
 
 	setupLog.Info("Starting manager")
diff --git a/internal/manager/setup.go b/internal/manager/setup.go
index e26cda36b..7cd1e6383 100644
--- a/internal/manager/setup.go
+++ b/internal/manager/setup.go
@@ -349,7 +349,7 @@ func AdminAPIClientFromServiceDiscovery(
 		retry.OnRetry(func(_ uint, err error) {
 			// log the error if the error is NOT caused by 0 available gateway endpoints.
 			if !errors.As(err, &NoAvailableEndpointsError{}) {
-				logger.Error(err, "failed to create kong client(s)")
+				logger.Error(err, "Failed to create kong client(s)")
 			}
 		}),
 	}, retryOpts...)


Test patch:
diff --git a/internal/adminapi/backoff_strategy_konnect_test.go b/internal/adminapi/backoff_strategy_konnect_test.go
index a26a72280..8232d6d37 100644
--- a/internal/adminapi/backoff_strategy_konnect_test.go
+++ b/internal/adminapi/backoff_strategy_konnect_test.go
@@ -81,7 +81,7 @@ func TestKonnectBackoffStrategy(t *testing.T) {
 
 		canUpdate, whyNot := strategy.CanUpdate(hashOne)
 		assert.False(t, canUpdate, "should not allow update for the same faulty hash")
-		assert.Equal(t, "config has to be changed: \"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b\" hash has already failed to be pushed with a client error", whyNot)
+		assert.Equal(t, "Config has to be changed: \"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b\" hash has already failed to be pushed with a client error", whyNot)
 
 		canUpdate, whyNot = strategy.CanUpdate(hashTwo)
 		assert.True(t, canUpdate, "should allow update for another hash")
@@ -95,7 +95,7 @@ func TestKonnectBackoffStrategy(t *testing.T) {
 
 		canUpdate, whyNot := strategy.CanUpdate(hashOne)
 		assert.False(t, canUpdate, "should not allow next update when last failed and backoff time wasn't satisfied")
-		assert.Equal(t, "config has to be changed: \"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b\" hash has already failed to be pushed with a client error, next attempt allowed in 3s", whyNot)
+		assert.Equal(t, "Config has to be changed: \"6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b\" hash has already failed to be pushed with a client error, next attempt allowed in 3s", whyNot)
 
 		canUpdate, whyNot = strategy.CanUpdate(hashTwo)
 		assert.False(t, canUpdate, "should not allow next update when last failed and backoff time wasn't satisfied")
diff --git a/internal/admission/server_test.go b/internal/admission/server_test.go
index 740f6f97e..03ee1d661 100644
--- a/internal/admission/server_test.go
+++ b/internal/admission/server_test.go
@@ -88,7 +88,7 @@ func TestServeHTTPBasic(t *testing.T) {
 	assert.Nil(err)
 	handler.ServeHTTP(res, req)
 	assert.Equal(400, res.Code)
-	assert.Equal("admission review object is missing\n",
+	assert.Equal("Admission review object is missing\n",
 		res.Body.String())
 }
 
diff --git a/internal/admission/validation/consumers/credentials/validation_test.go b/internal/admission/validation/consumers/credentials/validation_test.go
index e978a3da4..6a0f47c9a 100644
--- a/internal/admission/validation/consumers/credentials/validation_test.go
+++ b/internal/admission/validation/consumers/credentials/validation_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestUniqueConstraintsValidation(t *testing.T) {
-	t.Log("setting up an index of existing credentials which have unique constraints")
+	t.Log("Setting up an index of existing credentials which have unique constraints")
 	index := make(Index)
 	require.NoError(t, index.add(Credential{
 		Key:   "username",
@@ -26,7 +26,7 @@ func TestUniqueConstraintsValidation(t *testing.T) {
 		Type:  "basic-auth",
 	}))
 
-	t.Log("verifying that a new basic-auth credential with a unique username doesn't violate constraints")
+	t.Log("Verifying that a new basic-auth credential with a unique username doesn't violate constraints")
 	nonviolatingCredential := Credential{
 		Key:   "username",
 		Value: "nightwing",
@@ -34,7 +34,7 @@ func TestUniqueConstraintsValidation(t *testing.T) {
 	}
 	assert.NoError(t, index.add(nonviolatingCredential))
 
-	t.Log("verifying that a new basic-auth credential with a username that's already in use violates constraints")
+	t.Log("Verifying that a new basic-auth credential with a username that's already in use violates constraints")
 	violatingCredential := Credential{
 		Key:   "username",
 		Value: "batman",
@@ -44,7 +44,7 @@ func TestUniqueConstraintsValidation(t *testing.T) {
 	err := index.add(violatingCredential)
 	assert.Error(t, err)
 
-	t.Log("setting up a list of existing credentials which have no unique constraints")
+	t.Log("Setting up a list of existing credentials which have no unique constraints")
 	index = make(Index)
 	assert.NoError(t, index.add(Credential{
 		Key:   "key",
@@ -52,7 +52,7 @@ func TestUniqueConstraintsValidation(t *testing.T) {
 		Type:  "acl",
 	}))
 
-	t.Log("verifying that non-unique constrained credentials don't trigger a violation")
+	t.Log("Verifying that non-unique constrained credentials don't trigger a violation")
 	duplicate := Credential{
 		Key:   "key",
 		Value: "test",
@@ -61,7 +61,7 @@ func TestUniqueConstraintsValidation(t *testing.T) {
 	assert.False(t, IsKeyUniqueConstrained(duplicate.Type, duplicate.Key))
 	assert.NoError(t, index.add(duplicate))
 
-	t.Log("verifying that unconstrained keys for types with constraints don't flag as violated")
+	t.Log("Verifying that unconstrained keys for types with constraints don't flag as violated")
 	assert.False(t, IsKeyUniqueConstrained("basic-auth", "unconstrained-key"))
 }
 
diff --git a/internal/admission/validation/gateway/httproute_test.go b/internal/admission/validation/gateway/httproute_test.go
index f2b7e44ce..6d5cc12ec 100644
--- a/internal/admission/validation/gateway/httproute_test.go
+++ b/internal/admission/validation/gateway/httproute_test.go
@@ -59,7 +59,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "couldn't determine parentRefs for httproute",
+			validationMsg: "Couldn't determine parentRefs for httproute",
 			err:           fmt.Errorf("no parentRef matched gateway default/testing-gateway"),
 		},
 		{
@@ -98,7 +98,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "couldn't find gateway listeners for httproute",
+			validationMsg: "Couldn't find gateway listeners for httproute",
 			err:           fmt.Errorf("sectionname referenced listener listener-that-doesnt-exist was not found on gateway default/testing-gateway"),
 		},
 		{
@@ -126,7 +126,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "couldn't find gateway listeners for httproute",
+			validationMsg: "Couldn't find gateway listeners for httproute",
 			err:           fmt.Errorf("no listeners could be found for gateway default/testing-gateway"),
 		},
 		{
@@ -200,7 +200,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "httproute linked gateway listeners did not pass validation",
+			validationMsg: "HTTPRoute linked Gateway listeners did not pass validation",
 			err:           fmt.Errorf("HTTPRoute not supported by listener http-alternate"),
 		},
 		{
@@ -253,7 +253,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "httproute spec did not pass validation",
+			validationMsg: "HTTPRoute spec did not pass validation",
 			err:           fmt.Errorf("queryparam matching is supported with expression router only"),
 		},
 		{
@@ -311,7 +311,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "httproute spec did not pass validation",
+			validationMsg: "HTTPRoute spec did not pass validation",
 			err:           fmt.Errorf("example is not a supported group for httproute backendRefs, only core is supported"),
 		},
 		{
@@ -368,7 +368,7 @@ func TestValidateHTTPRoute(t *testing.T) {
 				},
 			}},
 			valid:         false,
-			validationMsg: "httproute spec did not pass validation",
+			validationMsg: "HTTPRoute spec did not pass validation",
 			err:           fmt.Errorf("Pod is not a supported kind for httproute backendRefs, only Service is supported"),
 		},
 	} {
diff --git a/internal/dataplane/kongstate/kongstate_test.go b/internal/dataplane/kongstate/kongstate_test.go
index 2ef2e8966..90c069e38 100644
--- a/internal/dataplane/kongstate/kongstate_test.go
+++ b/internal/dataplane/kongstate/kongstate_test.go
@@ -623,7 +623,7 @@ func TestFillConsumersAndCredentials(t *testing.T) {
 				},
 			},
 			expectedTranslationFailureMessages: map[k8stypes.NamespacedName]string{
-				{Namespace: "default", Name: "foo"}: "failed to fetch secret",
+				{Namespace: "default", Name: "foo"}: "Failed to fetch secret",
 			},
 		},
 		{
diff --git a/internal/dataplane/parser/ingressrules_test.go b/internal/dataplane/parser/ingressrules_test.go
index 3fc443054..c20585de2 100644
--- a/internal/dataplane/parser/ingressrules_test.go
+++ b/internal/dataplane/parser/ingressrules_test.go
@@ -332,7 +332,7 @@ func TestGetK8sServicesForBackends(t *testing.T) {
 			}},
 			expectedAnnotations: map[string]string{},
 			expectedLogEntries: []string{
-				"failed to fetch service",
+				"Failed to fetch service",
 			},
 		},
 	} {
diff --git a/internal/util/test/webhooks.go b/internal/util/test/webhooks.go
index bcc36aa1b..967db07d4 100644
--- a/internal/util/test/webhooks.go
+++ b/internal/util/test/webhooks.go
@@ -60,7 +60,7 @@ func getHostType() hostType {
 	out, err := cmd.CombinedOutput()
 	output := string(out)
 	if err != nil {
-		fmt.Printf("failed to run %q command %s\n%s\n", cmd.String(), err, output)
+		fmt.Printf("Failed to run %q command %s\n%s\n", cmd.String(), err, output)
 		return defaultDocker
 	}
 	switch {
diff --git a/test/e2e/features_test.go b/test/e2e/features_test.go
index da94e2c56..d326f1caf 100644
--- a/test/e2e/features_test.go
+++ b/test/e2e/features_test.go
@@ -266,7 +266,7 @@ func TestDeployAllInOneDBLESSGateway(t *testing.T) {
 		for _, pod := range pods.Items {
 			logs, err := getPodLogs(ctx, t, env, pod.Namespace, pod.Name)
 			if err != nil {
-				t.Logf("failed to get logs of pods %s/%s, error %v", pod.Namespace, pod.Name, err)
+				t.Logf("Failed to get logs of pods %s/%s, error %v", pod.Namespace, pod.Name, err)
 				return false
 			}
 			if !strings.Contains(logs, expectedMsg) {
diff --git a/test/e2e/konnect_test.go b/test/e2e/konnect_test.go
index 71ad7c4ac..0467287b0 100644
--- a/test/e2e/konnect_test.go
+++ b/test/e2e/konnect_test.go
@@ -467,7 +467,7 @@ func requireAllProxyReplicasIDsConsistentWithKonnect(
 			require.Eventually(t, func() bool {
 				_, err := nodeAPIClient.GetNode(ctx, nodeIDInAdminAPI)
 				if err != nil {
-					t.Logf("failed to get node %s from Node API: %v", nodeIDInAdminAPI, err)
+					t.Logf("Failed to get node %s from Node API: %v", nodeIDInAdminAPI, err)
 					return false
 				}
 
diff --git a/test/e2e/utils_test.go b/test/e2e/utils_test.go
index 9201e3136..0a0ced2d9 100644
--- a/test/e2e/utils_test.go
+++ b/test/e2e/utils_test.go
@@ -383,13 +383,13 @@ func startPortForwarder(ctx context.Context, t *testing.T, env environments.Envi
 func httpGetResponseContains(t *testing.T, url string, client *http.Client, substring string) bool {
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
-		t.Logf("failed to create request: %v", err)
+		t.Logf("Failed to create request: %v", err)
 		return false
 	}
 
 	resp, err := client.Do(req)
 	if err != nil {
-		t.Logf("failed to get response: %v", err)
+		t.Logf("Failed to get response: %v", err)
 		return false
 	}
 
diff --git a/test/envtest/gateway_envtest_test.go b/test/envtest/gateway_envtest_test.go
index 91542c769..1af1ec75a 100644
--- a/test/envtest/gateway_envtest_test.go
+++ b/test/envtest/gateway_envtest_test.go
@@ -52,7 +52,7 @@ func TestGatewayReconciliation_MoreThan100Routes(t *testing.T) {
 	require.Eventually(t, func() bool {
 		err := ctrlClient.Get(ctx, k8stypes.NamespacedName{Namespace: gw.Namespace, Name: gw.Name}, &gw)
 		if err != nil {
-			t.Logf("failed to get gateway %s/%s: %v", gw.Namespace, gw.Name, err)
+			t.Logf("Failed to get gateway %s/%s: %v", gw.Namespace, gw.Name, err)
 			return false
 		}
 		httpListener, ok := lo.Find(gw.Status.Listeners, func(listener gatewayapi.ListenerStatus) bool {
diff --git a/test/envtest/httproute_controller_test.go b/test/envtest/httproute_controller_test.go
index 3b0ea684c..6f4dbb11b 100644
--- a/test/envtest/httproute_controller_test.go
+++ b/test/envtest/httproute_controller_test.go
@@ -269,7 +269,7 @@ func printHTTPRoutesConditions(ctx context.Context, client ctrlclient.Client, nn
 	var route gatewayapi.HTTPRoute
 	err := client.Get(ctx, ctrlclient.ObjectKey{Namespace: nn.Namespace, Name: nn.Name}, &route)
 	if err != nil {
-		return fmt.Sprintf("failed to get HTTPRoute %s/%s when trying to print its conditions", nn.Namespace, nn.Name)
+		return fmt.Sprintf("Failed to get HTTPRoute %s/%s when trying to print its conditions", nn.Namespace, nn.Name)
 	}
 
 	if len(route.Status.Parents) == 0 {
diff --git a/test/envtest/k8s_objects_status_envtest_test.go b/test/envtest/k8s_objects_status_envtest_test.go
index eace26a34..6c36d711d 100644
--- a/test/envtest/k8s_objects_status_envtest_test.go
+++ b/test/envtest/k8s_objects_status_envtest_test.go
@@ -91,7 +91,7 @@ func TestHTTPRouteReconciliation_DoesNotBlockSyncLoopWhenStatusQueueBufferIsExce
 func httpRouteGetsProgrammed(ctx context.Context, t *testing.T, cl client.Client, httpRoute gatewayapi.HTTPRoute) func() bool {
 	return func() bool {
 		if err := cl.Get(ctx, client.ObjectKeyFromObject(&httpRoute), &httpRoute); err != nil {
-			t.Logf("failed to get httpRoute: %v", err)
+			t.Logf("Failed to get httpRoute: %v", err)
 			return false
 		}
 		if len(httpRoute.Status.Parents) == 0 {
diff --git a/test/envtest/kongstate_consumer_failures_test.go b/test/envtest/kongstate_consumer_failures_test.go
index c61148278..38608d2c7 100644
--- a/test/envtest/kongstate_consumer_failures_test.go
+++ b/test/envtest/kongstate_consumer_failures_test.go
@@ -115,7 +115,7 @@ func TestKongStateFillConsumersAndCredentialsFailure(t *testing.T) {
 			Namespace: ns.Name,
 		})
 		if err != nil {
-			t.Logf("failed to list events in namespace %s: %v", ns.Name, err)
+			t.Logf("Failed to list events in namespace %s: %v", ns.Name, err)
 			return false
 		}
 
diff --git a/test/envtest/manager_envtest_test.go b/test/envtest/manager_envtest_test.go
index 6e80c0e9b..d36c65501 100644
--- a/test/envtest/manager_envtest_test.go
+++ b/test/envtest/manager_envtest_test.go
@@ -55,7 +55,7 @@ func TestManagerDoesntStartUntilKubernetesAPIReachable(t *testing.T) {
 	require.Eventually(t, func() bool { return hasLog(expectedKubernetesAPICheckErrorLog) }, time.Minute, time.Millisecond)
 
 	t.Log("Ensure manager hasn't been started yet and no config sync has happened")
-	const configurationSyncedToKongLog = "successfully synced configuration to Kong"
+	const configurationSyncedToKongLog = "Successfully synced configuration to Kong"
 	const startingManagerLog = "Starting manager"
 	require.False(t, hasLog(configurationSyncedToKongLog))
 	require.False(t, hasLog(startingManagerLog))
diff --git a/test/envtest/telemetry_test.go b/test/envtest/telemetry_test.go
index 4ac9a67d5..c473e7560 100644
--- a/test/envtest/telemetry_test.go
+++ b/test/envtest/telemetry_test.go
@@ -326,12 +326,12 @@ func verifyTelemetryReport(t *testing.T, k8sVersion *version.Info, report string
 	t.Helper()
 	hostname, err := os.Hostname()
 	if err != nil {
-		t.Logf("failed to get hostname: %s", err)
+		t.Logf("Failed to get hostname: %s", err)
 		return false
 	}
 	semver, err := utilversion.ParseGeneric(k8sVersion.GitVersion)
 	if err != nil {
-		t.Logf("failed to parse k8s version: %s", err)
+		t.Logf("Failed to parse k8s version: %s", err)
 		return false
 	}
 
diff --git a/test/helpers/certificate/certificate.go b/test/helpers/certificate/certificate.go
index 7db3ca331..52edaf68b 100644
--- a/test/helpers/certificate/certificate.go
+++ b/test/helpers/certificate/certificate.go
@@ -58,7 +58,7 @@ func MustGenerateSelfSignedCert(decorators ...SelfSignedCertificateOptionsDecora
 	// Generate a new RSA private key.
 	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
 	if err != nil {
-		panic(fmt.Sprintf("failed to generate RSA key: %s", err))
+		panic(fmt.Sprintf("Failed to generate RSA key: %s", err))
 	}
 
 	options := SelfSignedCertificateOptions{
@@ -97,7 +97,7 @@ func MustGenerateSelfSignedCert(decorators ...SelfSignedCertificateOptionsDecora
 	}
 	derBytes, err := x509.CreateCertificate(rand.Reader, template, template, &privateKey.PublicKey, privateKey)
 	if err != nil {
-		panic(fmt.Sprintf("failed to create x509 certificate: %s", err))
+		panic(fmt.Sprintf("Failed to create x509 certificate: %s", err))
 	}
 
 	// Create a tls.Certificate from the generated private key and certificate.
diff --git a/test/helpers/conditions.go b/test/helpers/conditions.go
index 726d05dae..c6233f4b4 100644
--- a/test/helpers/conditions.go
+++ b/test/helpers/conditions.go
@@ -42,7 +42,7 @@ func HTTPRouteEventuallyContainsConditions(ctx context.Context, t *testing.T, cl
 				require.NoError(t, err)
 				return false
 			}
-			t.Logf("failed to get HTTPRoute: %v", err)
+			t.Logf("Failed to get HTTPRoute: %v", err)
 			return false
 		}
 
@@ -82,7 +82,7 @@ func HTTPRouteEventuallyNotContainsConditions(ctx context.Context, t *testing.T,
 				require.NoError(t, err)
 				return false
 			}
-			t.Logf("failed to get HTTPRoute: %v", err)
+			t.Logf("Failed to get HTTPRoute: %v", err)
 			return false
 		}
 
diff --git a/test/integration/tcpingress_test.go b/test/integration/tcpingress_test.go
index 306968a72..483efc811 100644
--- a/test/integration/tcpingress_test.go
+++ b/test/integration/tcpingress_test.go
@@ -405,7 +405,7 @@ func TestTCPIngressTLSPassthrough(t *testing.T) {
 	require.Eventually(t, func() bool {
 		deployment, err := env.Cluster().Client().AppsV1().Deployments(ns.Name).Get(ctx, deploymentName, metav1.GetOptions{})
 		if err != nil {
-			t.Logf("failed to get deployment %s/%s , error %v", ns.Name, deploymentName, err)
+			t.Logf("Failed to get deployment %s/%s , error %v", ns.Name, deploymentName, err)
 			return false
 		}
 		if deployment.Status.Replicas == deployment.Status.AvailableReplicas {
diff --git a/test/integration/translation_failures_test.go b/test/integration/translation_failures_test.go
index a2de05739..a18d89e18 100644
--- a/test/integration/translation_failures_test.go
+++ b/test/integration/translation_failures_test.go
@@ -153,7 +153,7 @@ func TestTranslationFailures(t *testing.T) {
 
 				return expectedTranslationFailure{
 					causingObjects: []client.Object{service},
-					reasonContains: "failed to fetch secret",
+					reasonContains: "Failed to fetch secret",
 				}
 			},
 		},
@@ -214,7 +214,7 @@ func TestTranslationFailures(t *testing.T) {
 
 				return expectedTranslationFailure{
 					causingObjects: []client.Object{ingress},
-					reasonContains: "failed to fetch the secret",
+					reasonContains: "Failed to fetch the secret",
 				}
 			},
 		},
@@ -302,7 +302,7 @@ func findTranslationFailureEventsForObject(
 		),
 	})
 	if err != nil {
-		t.Logf("failed to list events: %v", err)
+		t.Logf("Failed to list events: %v", err)
 		return []corev1.Event{}, false
 	}
 	if len(relatedEvents.Items) == 0 {
diff --git a/test/integration/webhook_test.go b/test/integration/webhook_test.go
index cb3be9311..7405665cb 100644
--- a/test/integration/webhook_test.go
+++ b/test/integration/webhook_test.go
@@ -141,7 +141,7 @@ func TestValidationWebhook(t *testing.T) {
 		assert.Eventually(t, func() bool {
 			_, err = kongClient.ConfigurationV1().KongConsumers(extraWebhookNamespace).Create(ctx, consumer, metav1.CreateOptions{})
 			if err != nil {
-				t.Logf("failed to create consumer, will retry: %s", err)
+				t.Logf("Failed to create consumer, will retry: %s", err)
 			}
 			return err == nil
 		}, time.Second*10, time.Second*1)
diff --git a/test/internal/helpers/http.go b/test/internal/helpers/http.go
index 357383a0d..4d739b25b 100644
--- a/test/internal/helpers/http.go
+++ b/test/internal/helpers/http.go
@@ -68,7 +68,7 @@ func MustHTTPRequest(t *testing.T, method string, host, path string, headers map
 // MustParseURL parses a string format URL to *url.URL. If error happens, fails the test.
 func MustParseURL(t *testing.T, urlStr string) *url.URL {
 	u, err := url.Parse(urlStr)
-	require.NoErrorf(t, err, "failed to parse URL %s: %v", urlStr, err)
+	require.NoErrorf(t, err, "Failed to parse URL %s: %v", urlStr, err)
 	return u
 }