How to efficiently stream a real-time chart from a local data file

complete noob picking up NodeJS over the last few days here, and I've gotten myself in big trouble, it looks like. I've currently got a working Node JS+Express server instance, running on a Raspberry Pi, acting as a web interface for a local data acquisition script ("the DAQ"). When executed, the script writes out data to a local file on the Pi, in .csv format, writing out in real-time every second.

My Node app is a simple web interface to start (on-click) the data acquisition script, as well as to plot previously acquired data logs, and visualize the actively being collected data in real time. Plotting of old logs was simple, and I wrote a JS function (using Plotly + d3) to read a local csv file via AJAX call, and plot it - using this script as a starting point, but using the logs served by express rather than an external file.

When I went to translate this into a real-time plot, I started out using the setInterval() method to update the graph periodically, based on other examples. After dealing with a few unwanted recursion issues, and adjusting the interval to a more reasonable setting, I eliminated the memory/traffic issues which were crashing the browser after a minute or two, and things are mostly stable.

However, I need help with one thing primarily:

1. Improving the efficiency of my first attempt approach: This acquisition script absolutely needs to be written to file every second, but considering that a typical run might last 1-2 weeks, the file size being requested on every Interval loop will quickly start to balloon. I'm completely new to Node/Express, so I'm sure there's a much better way of doing the real-time rendering aspect of this - that's the real issue here. Any pointers of a better way to go about doing this would be massively helpful!
2. Right now, the killDAQ() call issued by the "Stop" button kills the underlying python process writing out the data to disk. Is there a way to hook into using that same button click to also terminate the setInterval() loop updating the graph? There's no need for it to be updated any longer after the data acquisition has been stopped so having the single click do double duty would be ideal. I think that setting up a listener or res/req approach would be an option, but pointers in the right direction would be massively helpful.

(Edit: I solved #2, using global window. variables. It's a hack, but it seems to work:

window.refreshIntervalId = setInterval(foo);
...
clearInterval(window.refreshIntervalId);

)

Thanks for much for the help!

MWE:

html (using Pug as a template engine):

doctype html
html
    body.default
        .container-fluid
          .row
            .col-md-5
              .row.text-center
                .col-md-6
                    button#start_button(type="button", onclick="makeCallToDAQ()") Start Acquisition
                .col-md-6
                    button#stop_button(type="button", onclick="killDAQ()") Stop Acquisition
            .col-md-7
                #myDAQDiv(style='width: 980px; height: 500px;')

javascript (start/stop acquisition):

function makeCallToDAQ() {
    fetch('/start_daq', {
        // call to app to start the acquisition script
    })  
    .then(console.log(dateTime))
    .then(function(response) {
        console.log(response)
        setInterval(function(){ callPlotly(dateTime.concat('.csv')); }, 5000);
    });
}    
function killDAQ() {
    fetch('/stop_daq')
        // kills the process 
    .then(function(response) {
        // Use the response sent here
        alert('DAQ has stopped!')
    })
}

javascript (call to Plotly for plotting):

function callPlotly(filename) {
  var csv_filename = filename;
  console.log(csv_filename)

  function makeplot(csv_filename) {
    // Read data via AJAX call and grab header names
    var headerNames = [];
    d3.csv(csv_filename, function(error, data) {
      headerNames = d3.keys(data[0]);
      processData(data, headerNames)
    });
  };

  function processData(allRows, headerNames) {
    // Plot data from relevant columns
    var plotDiv = document.getElementById("plot");
    var traces = [{
      x: x,
      y: y
    }];

    Plotly.newPlot('myDAQDiv', traces, plotting_options);
  };
  makeplot(filename);  
}

node.js (the actual Node app):

// Start the DAQ
app.use(express.json());
var isDaqRunning = true;
var pythonPID = 0;
const { spawn } = require('child_process')
var process;
app.post('/start_daq', function(req, res) {
  isDaqRunning = true;

    // Call the python script here.
    const process = spawn('python', ['../private/BIC_script.py', arg1, arg2])
    pythonPID = process.pid;
    process.stdout.on('data', (myData) => {
      res.send("Done!")
    })
    process.stderr.on('data', (myErr) => {
        // If anything gets written to stderr, it'll be in the myErr variable
      })
    res.status(200).send(); //.json(result);
})

// Stop the DAQ
app.get('/stop_daq', function(req, res) {
  isDaqRunning = false;
  process.on('close', (code, signal) => {
    console.log(
      `child process terminated due to receipt of signal ${signal}`);
  });

    // Send SIGTERM to process
    process.kill('SIGTERM');

    res.status(200).send();
})