Persistance total traffic (Tx/Rx Bytes)

[AuthorShin]

Hello,
Thank you for making and maintaining this great tool.
I wan wondering if there is a way to monitor/log total traffics that being passed on each interface I mean Tx/Rx Bytes which is on Winbox is under Traffic tab for each Interface or /interface> print stats & /interface> print stats-detail via CLI and have them persistent so if device get rebooted it doesn't reset the counted traffic and reset them on the dashboard.

[M0r13n]

That is something that I am also interested in. Currently, mktxp operates in a stateless manner, relying solely on the Mikrotik router's counters as the data source. However, these counters reset after every router reboot, and since the script does not persist any state, it cannot accurately track cumulative metrics over time. Additionally, restarting the script itself results in a loss of continuity.

To address this, I propose a solution where the script writes its state (e.g., the last counter value and cumulative total) to a local file. This file-based persistence allows the script to resume tracking accurately after restarts or router reboots, without requiring external dependencies like a database. The implementation would detect counter resets and adjust the cumulative total accordingly, ensuring accurate metrics for Prometheus.

This approach keeps the script lightweight and standalone while solving the continuity issue.

I am thinking about something like this:

# Load the last known state from a file
def load_state():
    # Read from a local file (e.g., JSON or plain text)
    return {"last_value": 0, "total": 0}

# Save the current state to a file
def save_state(state):
    # Write the state (e.g., last_value, total) to a local file
    pass

# Fetch the current counter from the Mikrotik API
def fetch_counter():
    # Stub for API call to fetch the current counter value
    return current_counter

# Update the total bytes, handling counter resets
def update_total(state, current_counter):
    if current_counter < state["last_value"]: 
         # Detect reset
        state["total"] += state["last_value"]  # Add last known value to total
    state["total"] += current_counter - state["last_value"]  # Update total
    state["last_value"] = current_counter  # Update last value
    save_state()
    return state

The only real downside would be the added dependency on a local file that acts somewhat like a database, with concerns around file integrity, permissions, and portability. However, these issues seem solvable. I wonder what @akpw thinks of this. :)

[akpw]

@M0r13n thanks for the detailed analysis. As to my take, adding persistent state this way could be problematic for use cases with distributed setups, etc. Being a stateless exporter has its virtues, keeping extra complexity at bay. Might be cleaner to implement this as a separate solution, then expose a modified data source for mktxp to connect to without knowing the extra data handling aspects.