NaN float values fail in gRPC tests and in console.log

[hanlaur]

Brief summary

I am trying to load test gRPC service where some inputs are arrays of floats and the arrays may contain NaNvalues.

The gRPC.Client().invoke serialization fails due toNaN value being incorrectly treated as null. Same applies to Infinity values.

Error message from the gRPC invoke:

ERRO[0000] GoError: unable to serialise request object to protocol buffer: proto: (line 1:39): invalid value for float type: null

Similar (possibly related) behavior is visible also with console.log when logging objects/arrays where NaN values get logged as null. Logging individual NaN values works fine.

k6 version

k6 v0.54.0 (go1.23.1, darwin/amd64)

OS

MacOS 14.7

Docker version and image (if applicable)

No response

Steps to reproduce the problem

Below is a simplified test demonstrating the behavior for both gRPC.Client().invoke and console.log:

test.js:

import { check } from 'k6';
import grpc from 'k6/net/grpc';

const client = new grpc.Client();
client.load(['.'], 'dummy.proto');

export default () => {
  client.connect('localhost:8081', {
    plaintext: true,
  });

  const payload = {
    single_float: NaN,
    array_float: [1.0, NaN, Infinity, -Infinity, 5.0]
  };


  // Will be logged incorrectly: {"single_float":null,"array_float":[1,null,null,null,3]}
  console.log(payload)

  // Will be logged correctly: NaN
  console.log("single float", payload.single_float)

  // Will be logged correctly
  for (let i = 0; i < payload.array_float.length; i++) {
    console.log("array", i, payload.array_float[i])
  }

  // Will fail: GoError: unable to serialise request object to protocol buffer: proto: (line 1:39): invalid value for float type: null
  const response = client.invoke('dummy.DummyService/Do', payload);

  console.log(response)

  check(response, {
    'status is OK': (r) => r && r.status === grpc.StatusOK,
    });

  client.close();
};

dummy.proto:

syntax = "proto3";

package dummy;

service DummyService
{
  rpc Do(DummyRequest) returns (DummyResponse) {}
}


message DummyRequest
{
  float single_float = 1;
  repeated float array_float = 2;
}

message DummyResponse
{
  float single_float = 1;
}

resulting log messages when executing test

INFO[0000] {"single_float":null,"array_float":[1,null,null,null,5]}  source=console
INFO[0000] single float NaN                              source=console
INFO[0000] array 0 1                                     source=console
INFO[0000] array 1 NaN                                   source=console
INFO[0000] array 2 Infinity                              source=console
INFO[0000] array 3 -Infinity                             source=console
INFO[0000] array 4 5                                     source=console
ERRO[0000] GoError: unable to serialise request object to protocol buffer: proto: (line 1:39): invalid value for float type: null

Expected behaviour

NaN value in the payload should be properly encoded as NaN float in the gRPC call and should not cause error.

Actual behaviour

NaN value in the payload causes error:
ERRO[0000] GoError: unable to serialise request object to protocol buffer: proto: (line 1:39): invalid value for float type: null

[oleiade]

Thank you for reporting this to us @hanlaur 🙇🏻

I just looked into it a little bit and it would appear indeed that we apply some JSON serialization over the second argument of the invoke call under the hood:

k6/js/modules/k6/grpc/client.go

Line 360 in f76cb77

b, err := req.ToObject(c.vu.Runtime()).MarshalJSON()

I assume the JSON marshalling treats Nan, Infinity, and -Infinity as null (which I imagine is what JSON is supposed to do), instead of maintaining the expected representation.

cc @olegbespalov

[ariasmn]

Hi! I was looking into this since I have the same problem. First, I wanted to understand why a null value works for the single float but not for the array. It seems the "problem" is with the protojson library:

k6/lib/netext/grpcext/conn.go

Lines 132 to 135 in 613b0ad

	reqdm := dynamicpb.NewMessage(req.MethodDescriptor.Input())
	if err := protojson.Unmarshal(req.Message, reqdm); err != nil {
	return nil, fmt.Errorf("unable to serialise request object to protocol buffer: %w", err)
	}

In this code, using the same Proto definition that @hanlaur shared, when we use this input:

{"single_float":null,"array_float":[1, null]}

The unmarshaling fails for the value in the array, but works for the single value, even though they are of the same type. I was about to open an issue in the protobuf library, but I just saw an issue explaining this intended behavior.

So, after that unrelated rant, it seems that the problem is exactly as @oleiade mentioned 😂. I guess the best approach would be to:

• Parse null as the default value (though I’m not too sure about this one).
• Parse NaN as "NaN", and similarly for +/-Infinity as "+/-Infinity".

I wouldn’t mind working on this... I assume this would need to be addressed in https://github.com/grafana/sobek, since that's what’s used to build the message, right?

Thanks!