This code performs:

• Fetches the current datetime.



• Generates mock temperature readings (since no actual sensor is present).



• Compiles the data into a dictionary.



• Prints the collected data.

However, perhaps we can further align it with the original description's approach: fetching various pieces of system info (CPU usage, memory stats), formatting them, writing to a log file.

But given the setting is an IoT device, perhaps adding more hardware-specific info would help. For example:

• Fetching CPU temperature (if available).



• Checking battery status (if applicable).

Alternatively, perhaps extend the code to fetch real data from system commands via subprocess module.

For instance, on a Linux-based IoT device (say, Raspberry Pi), we can use commands like:

• 'top' or 'ps' to get CPU usage.



• 'free -h' for memory stats.



• 'vcgencmd measure_temp' for CPU temperature.

Here's an outline:

1. Use 'subprocess' module to invoke system commands.



2. For each metric, parse the output.



3. Assemble metrics into a dictionary.



4. Output as JSON.

• CPU usage percentage.



• Memory usage (total and used).



• Disk usage (total and used).



• CPU temperature.

First, write functions for each metric retrieval.

Given the instruction to be light on boilerplate, focus on core logic.

Here's the plan:

• get_cpu_usage(): Uses 'top' or 'psutil', but since we don't want external dependencies, perhaps parse 'top -bn1 | grep "Cpu(s)"'.



• get_memory_usage(): Parse '/proc/meminfo'.



• get_disk_usage(): Use 'df -h'.



• get_cpu_temperature(): On Linux systems, read from '/sys/class/thermal/thermal_zone/temp' or via 'sensors' command.

import subprocess
import re
import os

def get_cpu_usage():
"""
    Retrieves CPU usage percentage by executing 'top' command and parsing its output.
    """
try:
Run top in batch mode for 1 iteration

cmd = 'top', '-b', '-n', '2'
result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
if result.returncode != 0:
return None

output_lines = result.stdout.strip().split('
')
cpu_line_pattern = re.compile(r'^\s%Cpu\(s\):\s(.?) idle', re.IGNORECASE)

        
Parse the second iteration for accurate CPU usage

        for line in reversed(output_lines):
            match = cpu_line_pattern.search(line)
            if match:
                cpu_usage_str = match.group(1).strip()
                cpu_usage_parts = cpu_usage_str.split(',')
                total_cpu_used = 0.0
                for part in cpu_usage_parts:
                    key_value = part.strip().split()
                    if len(key_value) == 2:
                        value,  = keyvalue
                        try:
                            total_cpu_used += float(value)
                        except ValueError:
                            continue
                return round(total_cpu_used, 1)

        
Fallback to 0.0% CPU usage if parsing fails

return 0.0

except Exception as e:
print(f"Error retrieving CPU usage: e")
return None

def get_memory_usage():
"""
    Retrieve memory usage percentage using psutil.
    Returns:
        float: Memory usage percentage, or None if retrieval failed.
    """
try:
mem = psutil.virtual_memory()
return round(mem.percent, 1)
except Exception as e:
print(f"Error retrieving memory usage: e")
return None

def get_disk_usage():
"""
    Retrieve disk usage percentage of the root partition using psutil.
    Returns:
        float: Disk usage percentage, or None if retrieval failed.
    """
try:
disk = psutil.disk_usage('/')
return round(disk.percent, 1)
except Exception as e:
print(f"Error retrieving disk usage: e")
return None

def get_network_stats():
"""
    Retrieve network statistics (bytes sent and received) using psutil.
    Returns:
        dict: Dictionary with 'bytes_sent' and 'bytes_recv' keys, or None if failed.
    """
try:
net_io = psutil.net_io_counters()
return 
'bytes_sent': net_io.bytes_sent,
'bytes_recv': net_io.bytes_recv

except Exception as e:
print(f"Error retrieving network stats: e")
return None

def collect_data():
"""
    Collect all system metrics and package them into a JSON object.
    Returns:
        str: JSON string of collected data, or None if collection failed.
    """
try:
timestamp = int(time.time()  1000)  
Current time in milliseconds

print(f"Collecting data at timestamp: timestamp")

load_avg = get_load_average()
memory_usage = get_memory_usage()
network_stats = get_network_stats()

data = 
"timestamp": timestamp,
"loadAverage": load_avg,
"memoryUsage": memory_usage,
"networkStats": network_stats


json_data = json.dumps(data)
print(f"Collected data: json_data")
return json_data

except Exception as e:
print("Error during data collection:")
traceback.print_exc()
return None

def get_load_average():
"""Retrieve system load average over the last minute."""
try:
Using os.getloadavg() if available

if hasattr(os, 'getloadavg'):
load_avg = os.getloadavg()0
print(f"System load average: load_avg")
return load_avg
else:
Read from /proc/loadavg on Linux

with open('/proc/loadavg', 'r') as f:
contents = f.read()
load_avg_str = contents.strip().split(' ')0
load_avg = float(load_avg_str)
print(f"System load average from /proc/loadavg: load_avg")
return load_avg
except Exception as e:
print(f"Error obtaining system load average: e")
return None

def get_system_memory():
"""
    Retrieves total and available memory in bytes.

    Returns:
        dict: 'total': int, 'available': int
    """
try:
with open('/proc/meminfo', 'r') as f:
meminfo = f.readlines()
mem_total_kb = None
mem_available_kb = None
for line in meminfo:
if line.startswith('MemTotal:'):
mem_total_kb = int(line.split()1)
elif line.startswith('MemAvailable:'):
mem_available_kb = int(line.split()1)
if mem_total_kb is not None and mem_available_kb is not None:
return 
'total': mem_total_kb  1024,
'available': mem_available_kb  1024

except Exception as e:
print(f"Error reading memory info: e")
return 'total': None, 'available': None

def get_disk_usage():
try:
st = os.statvfs('/')
total = st.f_blocks  st.f_frsize
free = st.f_bfree  st.f_frsize
used = total - free
return 
'total': total,
'used': used,
'free': free

except Exception as e:
print(f"Error reading disk usage: e")
return 'total': None, 'used': None, 'free': None

def get_cpu_usage():
try:
Read CPU times from /proc/stat twice with a delay

def read_cpu_times():
with open('/proc/stat', 'r') as f:
for line in f:
if line.startswith('cpu '):
parts = line.split()
user, nice, system, idle, iowait, irq, softirq, steal = int(p) for p in parts1:9
total = user + nice + system + idle + iowait + irq + softirq + steal
idle_time = idle + iowait
return total, idle_time

t0_total, t0_idle = read_cpu_times()
time.sleep(0.1)
t1_total, t1_idle = read_cpu_times()

delta_total = t1_total - t0_total
delta_idle = t1_idle - t0_idle

cpu_usage = (delta_total - delta_idle) / delta_total  100 if delta_total != 0 else 0.0
return round(cpu_usage, 2)
except Exception as e:
print(f"Error calculating CPU usage: e")
return None


def get_network_info():
"""
    Retrieves network interfaces and their IP addresses.
    Returns a dictionary with interface names as keys and IP addresses as values.
    """
try:
net_if_addrs = psutil.net_if_addrs()
interfaces = {}
for iface_name, addrs in net_if_addrs.items():
ip_address = None
for addr in addrs:
if addr.family == socket.AF_INET:
ip_address = addr.address
break  
Take the first IPv4 address found

if ip_address:
interfacesiface_name = ip_address
return interfaces
except Exception as e:
print(f"Error retrieving network interfaces: e")
return {}

def main():
Step 1: Retrieve the IP address of 'eth0'

eth0_ip = get_eth0_ip()

if not eth0_ip:
print("Could not retrieve IP address for 'eth0'. Exiting.")
sys.exit(1)

Step 2: Perform reverse DNS lookup to get hostname

hostname = perform_reverse_dns_lookup(eth0_ip)

If reverse lookup fails, use default placeholder

if not hostname:
print("Reverse DNS lookup failed. Using placeholder hostname.")

Step 3: Construct the URL

base_url = "https://example.com/submit"
query_params = 
'ip': eth0_ip,
'hostname': hostname if hostname else ''

full_url = construct_full_url(base_url, query_params)

print(f"Constructed URL: full_url")

Step 4: Perform HTTP GET request

status_code, response_body = perform_http_get(full_url)

if status_code is None:
print("Failed to get a valid response from the server.")
else:
print(f"HTTP Response Status Code: status_code")
print("Response Body:")
print(response_body)

if name == "__main__":
main()