Automatically convert JSON patch paths in MeshProxyPatches from snake_case to camelCase

[bartsmykla]

Description

Currently, Envoy's config dump presents paths in snake_case format, while JSON patches in MeshProxyPatch require camelCase format. Instead of documenting this discrepancy, we can implement logic to automatically convert paths from snake_case to camelCase when encountered. This approach would eliminate the need for users to manually convert paths, improving the overall usability of the system.

---

xref. kumahq/kuma-website#1539

[lukidzi]

I did some debugging, it is caused by not setting OrigName to true https://github.com/kumahq/kuma/blob/master/pkg/util/proto/proto.go#L44
if we change it to this we are going to have proto fields name (like in a config_dump)

MeshProxyPatch allows the creation of JSON patch and accepts JSON formatted fields camelCase; if we change the dump, a user might have to rewrite fields from the dump to match json format.

Envoy's config_dump shows only snake_case when directly requesting the envoy, but not through the Control-plane.

I think this issue might not be the case if we agree that what shows UI is a source of truth, but if we decide that we should stick to the same format as Envoy(which would be the best for cross docs reading) then we need to rewrite a lot of things and we need to keep backward compatibility for old patches in JSON format

[jakubdyszkiewicz]

Triage: let's change API so the config dump is snake_cased (just like 9901) not camelCased

[lahabana]

This because of the sanitization:

kuma/pkg/envoy/admin/client.go

Lines 145 to 161 in 6233521

	func (a *envoyAdminClient) ConfigDump(ctx context.Context, proxy core_model.ResourceWithAddress) ([]byte, error) {
	configDump, err := a.executeRequest(ctx, proxy, "config_dump")
	if err != nil {
	return nil, err
	}
	cd := &envoy_admin_v3.ConfigDump{}
	if err := util_proto.FromJSON(configDump, cd); err != nil {
	return nil, err
	}
	if err := Sanitize(cd); err != nil {
	return nil, err
	}
	return util_proto.ToJSONIndent(cd, " ")
	}

How about we retrieve the tokens that needs to be redacted in the first step and then redacted from the raw payload? This would avoid the reserialization.

[lukidzi]

We are sanitizing DataplaneToken from the output. We don't store it anywhere so we won't be able to retrieve it.

[lahabana]

What I mean is something like:

	configDump, err := a.executeRequest(ctx, proxy, "config_dump")
	if err != nil {
		return nil, err
	}

        toReplace := []string{}
	cd := &envoy_admin_v3.ConfigDump{}
	if err := util_proto.FromJSON(configDump, cd); err != nil {
		return nil, err
	}
        // Retrieve strings that need to be sanitized
	for _, config := range configDump.Configs {
		if config.MessageIs(&envoy_admin_v3.BootstrapConfigDump{}) {
			bootstrapConfigDump := &envoy_admin_v3.BootstrapConfigDump{}
			if err := config.UnmarshalTo(bootstrapConfigDump); err != nil {
				return err
			}

			for _, grpcService := range bootstrapConfigDump.GetBootstrap().GetDynamicResources().GetAdsConfig().GetGrpcServices() {
				for i, initMeta := range grpcService.InitialMetadata {
					if initMeta.Key == "authorization" {
						toReplace = append(toReplace, grpcService.InitialMetadata[i].Value, "[redacted]")
					}
				}
			}

			for _, grpcService := range bootstrapConfigDump.GetBootstrap().GetHdsConfig().GetGrpcServices() {
				for i, initMeta := range grpcService.InitialMetadata {
					if initMeta.Key == "authorization" {
						toReplace = append(toReplace, grpcService.InitialMetadata[i].Value, "[redacted]")
					}
				}
			}
		}
	}
        return strings.NewReplacer(toReplace).Replace(configDump)

It seems to also avoid multiple occurences of serialization which likely makes this quicker too :)

WDYT?