Fured fix

manage.py

@@ -4,11 +4,6 @@ from src.client import Client
 
 
 def main():
-    # define a Handler which writes INFO messages or higher to the sys.stderr
-    logging.basicConfig(
-        level=logging.INFO,
-        format='[%(asctime)s: %(levelname)s/%(name)s] %(message)s')
-
     if len(sys.argv) < 2:
         print("usage: manage.py run")
     if len(sys.argv) != 2 and sys.argv[1] != "run":

src/client.py

@@ -9,6 +9,7 @@ import pika
 import psutil
 import time
 import re
+from .memsparse import parse_memory_size
 
 logging.basicConfig()
 logger = logging.getLogger(__name__)
@@ -158,37 +159,48 @@ class Client:
         try:
             for entry in psutil.process_iter():
                 if entry.name() in ('kvm', 'qemu-system-x86_64'):
-                    parser = argparse.ArgumentParser()
+                    parser = argparse.ArgumentParser(add_help=False)
                     parser.add_argument('-name')
-                    parser.add_argument('--memory-size', '-m ', type=int)
-                    args, unknown = parser.parse_known_args(
-                        entry.cmdline()[1:])
+                    # FONTOS: nincs szóköz a '-m' végén, és saját parse függvényt használunk
+                    parser.add_argument('--memory-size', '-m ', dest='memory_size',
+                                        type=parse_memory_size)
+                    args, unknown = parser.parse_known_args(entry.cmdline()[1:])
+                
                     # for Red Hat style parametering of kvm
                     if isinstance(args.name, str):
                         args.name = re.sub(r"^guest=", "", args.name)
                         args.name = re.sub(r",debug-threads=.*$", "", args.name)
-
+                
                         process = self.processes.get(entry.pid, None)
                         if not process or process.cmdline() != entry.cmdline():
                             process = psutil.Process(entry.pid)
                             logger.info('New process: %s', process)
                             self.processes[entry.pid] = process
-
-                        mem_perc = (float(process.get_memory_info().rss)
-                                    / (args.memory_size * 1024 ** 2) * 90)
-                        metrics.append('vm.%(name)s.memory.usage %(value)f '
-                                       '%(time)d' % {'name': args.name,
-                                                     'value': mem_perc,
-                                                     'time': now})
-                        cpu_perc = process.get_cpu_percent()
-                        metrics.append('vm.%(name)s.cpu.percent %(value)f '
-                                       '%(time)d' % {'name': args.name,
-                                                     'value': cpu_perc,
-                                                     'time': now})
+                
+                        if args.memory_size:
+                            # args.memory_size MiB-ben van
+                            rss_bytes = float(process.memory_info().rss)
+                            mem_bytes_total = args.memory_size * 1024 ** 2
+                            mem_perc = (rss_bytes / mem_bytes_total) * 90.0
+                
+                            metrics.append('vm.%(name)s.memory.usage %(value)f %(time)d' % {
+                                'name': args.name,
+                                'value': mem_perc,
+                                'time': now,
+                            })
+                        else:
+                            logger.warning('Pid %d: no memory size found for VM %s', entry.pid, args.name)
+                
+                        cpu_perc = process.cpu_percent()
+                        metrics.append('vm.%(name)s.cpu.percent %(value)f %(time)d' % {
+                            'name': args.name,
+                            'value': cpu_perc,
+                            'time': now,
+                        })
                         running_vms.append(args.name)
                     else:
-                        logger.warning('Pid: %d args.name is empty?: %s %s', entry.pid, entry.name(), entry.cmdline())
-
+                        logger.warning('Pid: %d args.name is empty?: %s %s',
+                                       entry.pid, entry.name(), entry.cmdline())
         except (psutil.NoSuchProcess, TypeError):
             logger.warning('Process %d lost. Entry: %s', entry.pid, entry.cmdline()[0:])
 
@@ -239,6 +251,7 @@ class Client:
                 if metrics:
                     for chunk in self._chunker(metrics, 100):
                         self.send(chunk)
+                    logger.debug("metrics: %r", metrics)
                     logger.info("%d metrics sent", len(metrics))
                 time.sleep(10)
         except KeyboardInterrupt:

src/memsparse.py

+# memsparse.py
+import argparse
+import re
+
+def parse_memory_size(value):
+    """
+    Visszatér: memória méret MiB-ben (float).
+    Elfogadott formák:
+      - "4096"
+      - "4G", "4g"
+      - "4096M", "4096m"
+      - "size=4194304k"
+      - "4194304k"
+    """
+    # Red Hat stílus: size=4194304k
+    if value.startswith('size='):
+        value = value.split('=', 1)[1]
+
+    m = re.match(r'^(\d+)([kKmMgG]?)$', value)
+    if not m:
+        raise argparse.ArgumentTypeError(
+            "Invalid memory size format: %r" % value
+        )
+
+    num = int(m.group(1))
+    suffix = m.group(2).lower()
+
+    # QEMU unitok: k = KiB, m = MiB, g = GiB
+    if suffix == 'k':
+        mib = num / 1024.0
+    elif suffix == 'm' or suffix == '':
+        mib = float(num)
+    elif suffix == 'g':
+        mib = num * 1024.0
+    else:
+        # ide elvileg nem jutunk a regex miatt
+        raise argparse.ArgumentTypeError(
+            "Unsupported unit in memory size: %r" % suffix
+        )
+
+    return mib
+