function toRawOneMinChunks(newDataArray, oldRawChunk) {
                                // We take in new data and sort it according to minute chunks
                                let rawTimestamp
                                let currentTimestamp
                                let currentRawChunk = oldRawChunk
                                let chunksArray = []

                                for (let row of newDataArray) {
                                    // make sure the timestamp is formatted correctly to be accepted by the date object
                                    rawTimestamp = row[dbTimestamp]
                                    currentTimestamp = validateRawTimestamp(rawTimestamp)
                                    currentNewData = row
                                    
                                    /* Reporting we are doing well */
                                    logAndHeartBeat(currentTimestamp, ' Sorting data ', newDataArray, row)

                                    if (currentRawChunk === undefined) {
                                        // This means we have just started the sorting process so we create an new raw one minute chunk and add the incoming data row
                                        currentRawChunk = newRawMinChunk(currentTimestamp, currentNewData)
                                        continue

                                    } else {
                                        // check to see if this timestamp fits in the current raw min chunk or not
                                        let unixTimestamp = currentTimestamp.getTime()
                                        if ( unixTimestamp >= currentRawChunk[0] && unixTimestamp <= currentRawChunk[1]) {
                                            // add to the current raw min chunk
                                            currentRawChunk.push(currentNewData)
                                            continue

                                        } else if (unixTimestamp > currentRawChunk[1]) {
                                            // Add previous raw min chunk to the array before we start a new chunk
                                            chunksArray.push(currentRawChunk)
                                            currentRawChunk = newRawMinChunk(currentTimestamp, currentNewData)
                                            continue

                                        } else {
                                            SA.logger.error("Timestamp is out of order: ", currentTimestamp, " Expected to be after ", currentRawMinChunk)
                                        }
                                    }
                                }

                                chunksArray.push(currentRawChunk)
                                // After the loop has finished push the last raw min chunk to the array
                                return chunksArray
                            }
The function takes in new data and sorts it into one minute chunks based
on timestamps.
@param newDataArray - An array of new data to be sorted into minute
chunks.
@param oldRawChunk - The previous raw one minute chunk that was being
processed before the new data was added. It is undefined if this is the
first time the function is being called.
@param rawMinChunks - An array that contains the sorted data in one
minute chunks. Each element in the array represents a one minute chunk
and contains an array of data rows that fall within that minute.
@returns an array of sorted data chunks based on one minute intervals.