What's a good way to ensure delivery of an entire message when using raw tcp?

Say I have an application that on the backend I want to use raw tcp so that I can have bi-directional communication between different services. In this application I want to send over a payload consisting of a json object, when the json data is sent, every few messages, it gets cut off and the remainder is then clumped to the next response. I don't want to use something like say websockets due to the time used to upgrade from http. What is a good (and hopefully best) way to ensure that that json object will go from one node and be read from another node as the whole json object?

I know sending and receiving buffers of a set size and a message for a heartbeet are the rule of thumb, but can I see an example? Preferably in Javascript (node's net stdlib) or Golang (it's net stdlib) because those are my most proficient languages, though I don't really care what language it is done in ultimately.

(I know there's a few questions out there asking similar things regarding ensuring delivery of message with tcp, but none asked for an example that I found)

I know tcp is a stream. I'm just asking of a way to ensure that when writing a specific json object to this stream, how do I ensure I get the same json object on the other end, as in "send json object X from node a, ok node b received that same object X"

You don't need a heartbeat, or fixed size messages for delivery confirmation. If you need to ensure delivery, you need an application level acknowledgement. If you need to ensure delivery of the correct message, you'll need to include a unique message ID to acknowledge. If you need to ensure that the message is unaltered, you'll need to include a checksum or MAC.

Here it sounds like you're having trouble with message framing. While there are many ways to frame your messages (simple length-prefix, type-length-value, HTTP/1.1, etc.), a simple solution is to use the built-in json.Encoder and json.Decoder.

Example client, which sends a "PING" message every second:

type Message struct {
	Payload string
}

func sendMessages(c net.Conn) {
	message := Message{}

	encoder := json.NewEncoder(c)

	for i := 0; ; i++ {
		message.Payload = fmt.Sprintf("PING %d", i)
		err := encoder.Encode(message)
		if err != nil {
			log.Fatal(err)
		}
		time.Sleep(time.Second)
	}
}

Example Server:

type Message struct {
	Payload string
}

func receiveMessages(c net.Conn) {
	m := Message{}

	decoder := json.NewDecoder(c)
	for {
		err := decoder.Decode(&m)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Received: %#v\n", m)
	}
}