refactor: replace HTTP metrics with UDP, improve network architecture

- Replace HttpMetricsClient (TCP) with UdpMetricsClient (UDP) for metrics transmission
- Add HttpServerManager for /api/deviceinfo HTTP endpoint (TCP)
- Rename networkUrl to networkHost, remove http:// prefix requirement
- Update ConfigAccess with new validation and defaults
- Add network config options to PtrackerCommand
- Update ClothConfigScreen with new network settings
- Add test_udp_server.py for UDP testing
- Update localization files (en_us, zh_cn, zh_tw, lzh)
- Update README with new Network API documentation
- Remove obsolete HttpService, UrlUtils, and related tests

Author: WhatDamon

.gitignore

@@ -44,3 +44,8 @@ replay_*.log
 logs/
 *.log
 *.log.gz
+
+# Python
+
+*.pyc
+__pycache__/

README.md

@@ -9,7 +9,7 @@ A Minecraft Fabric mod for tracking game performance metrics.
 
 - **In-game Performance Display**: Shows real-time FPS, TPS, MSPT, heap memory, and CPU usage.
 - **Metrics Export**: Exports performance data to CSV, JSON, or YAML formats.
-- **HTTP API**: Exposes metrics via a local HTTP server for integration with monitoring tools.
+- **Network API**: Exposes device info via HTTP (TCP) and sends metrics via UDP for integration with monitoring tools.
 - **Configurable Collection**: Toggle which metrics to collect and export.
 
 ## Commands
@@ -37,22 +37,23 @@ Contributions are welcome. Please feel free to submit issues or pull requests on
 
 1. **Local Data Export**: When enabled, performance metrics are written to files in a configurable directory.
 
-2. **HTTP Reporting**: When the network feature is enabled, this mod sends performance metrics to a remote HTTP endpoint. The transmitted data includes:
+2. **Network Transmission**: When the network feature is enabled, this mod transmits performance metrics via UDP and exposes system information via HTTP:
    - Session identifier
    - Timestamp
    - All enabled metrics (FPS, TPS, heap, CPU, etc.)
-   - Complete system information as listed above
+   - Complete system information
 
-3. **No Authentication**: The HTTP endpoint has no built-in authentication or encryption. Any party with network access to the endpoint can receive and store your data.
+3. **No Authentication**: The HTTP endpoint and UDP receiver have no built-in authentication or encryption. Any party with network access can receive and store your data.
 
 4. **Data Retention**: Any remote server you send data to will retain that data according to their own policies. This mod has no control over how your data is stored or used by third parties.
 
 **Recommendations:**
-- Only enable the HTTP reporting feature if you trust the endpoint
-- Use localhost (`127.0.0.1`) or a trusted local server as the endpoint when testing
+- Only enable the network feature if you trust the endpoint
+- Use localhost (`127.0.0.1`) or a trusted local server when testing
 - Be aware of what data is being collected and transmitted
 - Review the data before sharing any exported files
 - Consider the implications of exposing system information to network endpoints
+- Firewall rules should be configured appropriately for your use case
 
 ## License
 

src/client/java/org/damon233/performtrackermod/config/ClothConfigScreen.java

@@ -128,34 +128,67 @@ public static Screen createConfigScreen(Screen parent) {
                 .setTooltip(Text.translatable("performtracker.config.collect_cpu.tooltip"))
                 .setSaveConsumer(ConfigAccess::setCollectCpu)
                 .build());
-        
+
         ConfigCategory network = builder.getOrCreateCategory(Text.translatable("performtracker.config.category.network"));
-        
+
+        network.addEntry(entryBuilder.startTextDescription(
+                        Text.translatable("performtracker.config.network_warning")
+                        )
+                .build());
+
         network.addEntry(entryBuilder.startBooleanToggle(
-                Text.translatable("performtracker.config.network_enabled"),
-                ConfigAccess.isNetworkEnabled())
+                        Text.translatable("performtracker.config.network_enabled"),
+                        ConfigAccess.isNetworkEnabled())
                 .setDefaultValue(false)
                 .setTooltip(Text.translatable("performtracker.config.network_enabled.tooltip"))
                 .setSaveConsumer(ConfigAccess::setNetworkEnabled)
                 .build());
-        
+
         network.addEntry(entryBuilder.startTextField(
-                Text.translatable("performtracker.config.network_endpoint"),
-                ConfigAccess.getNetworkEndpoint())
-                .setDefaultValue("http://localhost:31415")
-                .setTooltip(Text.translatable("performtracker.config.network_endpoint.tooltip"))
+                        Text.translatable("performtracker.config.network_host"),
+                        ConfigAccess.getNetworkUrl())
+                .setDefaultValue("localhost")
+                .setTooltip(Text.translatable("performtracker.config.network_host.tooltip"))
                 .setSaveConsumer(newValue -> {
-                    if (ConfigAccess.isValidNetworkEndpoint(newValue)) {
-                        ConfigAccess.setNetworkEndpoint(newValue);
+                    if (ConfigAccess.isValidNetworkUrl(newValue)) {
+                        ConfigAccess.setNetworkUrl(newValue);
                     }
                 })
                 .setErrorSupplier(newValue -> {
-                    if (!ConfigAccess.isValidNetworkEndpoint(newValue)) {
-                        return Optional.of(Text.translatable("performtracker.config.network_endpoint.error"));
+                    if (!ConfigAccess.isValidNetworkUrl(newValue)) {
+                        return Optional.of(Text.translatable("performtracker.config.network_host.error"));
                     }
                     return Optional.empty();
                 })
                 .build());
+
+        network.addEntry(entryBuilder.startIntField(
+                        Text.translatable("performtracker.config.receiver_port"),
+                        ConfigAccess.getReceiverPort())
+                .setDefaultValue(31415)
+                .setMin(1)
+                .setMax(65535)
+                .setTooltip(Text.translatable("performtracker.config.receiver_port.tooltip"))
+                .setSaveConsumer(port -> {
+                    if (port >= 1 && port <= 65535) {
+                        ConfigAccess.setReceiverPort(port);
+                    }
+                })
+                .build());
+
+        network.addEntry(entryBuilder.startIntField(
+                        Text.translatable("performtracker.config.sender_port"),
+                        ConfigAccess.getSenderPort())
+                .setDefaultValue(31416)
+                .setMin(1)
+                .setMax(65535)
+                .setTooltip(Text.translatable("performtracker.config.sender_port.tooltip"))
+                .setSaveConsumer(port -> {
+                    if (port >= 1 && port <= 65535) {
+                        ConfigAccess.setSenderPort(port);
+                    }
+                })
+                .build());
 
         return builder.build();
     }

src/main/java/org/damon233/performtrackermod/PerformTracker.java

@@ -27,78 +27,44 @@
 import org.damon233.performtrackermod.config.ConfigAccess;
 import org.damon233.performtrackermod.controller.TrackerController;
 import org.damon233.performtrackermod.command.PtrackerCommand;
-import org.damon233.performtrackermod.network.HttpService;
+import org.damon233.performtrackermod.network.HttpServerManager;
+import org.damon233.performtrackermod.network.UdpMetricsClient;
 
 public class PerformTracker implements ModInitializer {
 	public static final String MOD_ID = "performtracker";
 	public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
 
 	private static TrackerController trackerController;
-    private static HttpService httpService;
 	private static IFpsProvider fpsProvider;
 	private static IGpuProvider gpuProvider;
 
 	@Override
 	public void onInitialize() {
 		ConfigAccess.init();
-		
+
 		LOGGER.info("PerformTracker initialized.");
-        ServerMetricsCollector serverMetricsCollector = new ServerMetricsCollector();
+		ServerMetricsCollector serverMetricsCollector = new ServerMetricsCollector();
 		trackerController = new TrackerController(serverMetricsCollector, null);
 		PtrackerCommand.register();
-		
+
 		if (ConfigAccess.isNetworkEnabled()) {
-			httpService = new HttpService();
-			httpService.initialize(ConfigAccess.getNetworkUrl());
-			httpService.tryStartServer();
+			String host = ConfigAccess.getNetworkUrl();
+			int port = ConfigAccess.getReceiverPort();
+			HttpServerManager.getInstance().start(host, port);
 		}
-		
-		// Register callback for network enable/disable changes
-		ConfigAccess.setOnNetworkEnabledChanged(() -> {
-			if (ConfigAccess.isNetworkEnabled()) {
-				// Network was enabled - create and start HttpService if not exists
-				if (httpService == null) {
-					httpService = new HttpService();
-					httpService.initialize(ConfigAccess.getNetworkUrl());
-				}
-				httpService.tryStartServer();
-			} else {
-				// Network was disabled - stop server and clear HttpService
-				if (httpService != null) {
-					httpService.stop();
-					httpService.stopServer();
-					httpService = null;
-					LOGGER.info("HttpService unloaded due to network being disabled.");
-				}
-			}
-		});
-		
-		// Register callback for network endpoint changes
-		ConfigAccess.setOnNetworkEndpointChanged(() -> {
-			if (httpService != null && ConfigAccess.isNetworkEnabled()) {
-				httpService.reinitialize(ConfigAccess.getNetworkUrl());
-				LOGGER.info("HttpService reinitialized with new endpoint: {}", ConfigAccess.getNetworkUrl());
-			}
-		});
-		
+
 		ServerLifecycleEvents.SERVER_STOPPING.register(server -> {
-			if (httpService != null) {
-				httpService.stopServer();
-				LOGGER.info("HttpService server stopped.");
-			}
+			HttpServerManager.getInstance().stop();
+			UdpMetricsClient.getInstance().close();
 		});
-		
+
 		LOGGER.info("PerformTracker server components ready.");
 	}
 
 	public static TrackerController getTrackerController() {
 		return trackerController;
 	}
 
-	public static HttpService getHttpService() {
-		return httpService;
-	}
-
 	public static void setFpsProvider(Object fpsProvider) {
 		IFpsProvider provider = (IFpsProvider) fpsProvider;
 		PerformTracker.fpsProvider = provider;

src/main/java/org/damon233/performtrackermod/command/PtrackerCommand.java

@@ -57,18 +57,8 @@ private enum ConfigType {
             ConfigAccess::getExportDirectory,
             v -> ConfigAccess.setExportDirectory((String) v),
             ConfigAccess::getDefaultExportDirectory),
-        
-        BOOL3("network_enabled", "performtracker.config.network_enabled", false,
-            ConfigAccess::isNetworkEnabled,
-            v -> ConfigAccess.setNetworkEnabled((Boolean) v),
-            ConfigAccess::getDefaultNetworkEnabled),
-        
-        STRING2("network_endpoint", "performtracker.config.network_endpoint", "http://localhost:31415",
-            ConfigAccess::getNetworkEndpoint,
-            v -> ConfigAccess.setNetworkEndpoint((String) v),
-            ConfigAccess::getDefaultNetworkEndpoint),
 
-        STRING3("output_format", "performtracker.config.output_format", "csv",
+        STRING2("output_format", "performtracker.config.output_format", "csv",
             ConfigAccess::getOutputFormat,
             v -> ConfigAccess.setOutputFormat((String) v),
             ConfigAccess::getDefaultOutputFormat),
@@ -101,7 +91,27 @@ private enum ConfigType {
         BOOL10("binary_units", "performtracker.config.binary_units", true,
             ConfigAccess::isBinaryUnits,
             v -> ConfigAccess.setBinaryUnits((Boolean) v),
-            ConfigAccess::getDefaultBinaryUnits);
+            ConfigAccess::getDefaultBinaryUnits),
+        
+        BOOL11("network_enabled", "performtracker.config.network_enabled", false,
+            ConfigAccess::isNetworkEnabled,
+            v -> ConfigAccess.setNetworkEnabled((Boolean) v),
+            ConfigAccess::getDefaultNetworkEnabled),
+        
+        STRING4("network_host", "performtracker.config.network_host", "localhost",
+            ConfigAccess::getNetworkUrl,
+            v -> ConfigAccess.setNetworkUrl((String) v),
+            ConfigAccess::getDefaultNetworkUrl),
+        
+        INT2("receiver_port", "performtracker.config.receiver_port", 31415,
+            ConfigAccess::getReceiverPort,
+            v -> ConfigAccess.setReceiverPort((Integer) v),
+            ConfigAccess::getDefaultReceiverPort),
+        
+        INT3("sender_port", "performtracker.config.sender_port", 31416,
+            ConfigAccess::getSenderPort,
+            v -> ConfigAccess.setSenderPort((Integer) v),
+            ConfigAccess::getDefaultSenderPort);
 
         final String key;
         final String translationKey;
@@ -137,10 +147,8 @@ void sendInfo(ServerCommandSource source) {
         }
 
         void sendLine(ServerCommandSource source) {
-            MutableText current = FormattingService.colorValue(
-                Boolean.toString(Boolean.TRUE.equals(getter.get())));
-            MutableText def = FormattingService.colorValue(
-                Boolean.toString(Boolean.TRUE.equals(defaultGetter.get())));
+            MutableText current = FormattingService.colorValue(String.valueOf(getter.get()));
+            MutableText def = FormattingService.colorValue(String.valueOf(defaultGetter.get()));
             source.sendFeedback(() -> Text.translatable(translationKey).append(": ").append(current).append(" (default: ").append(def).append(")"), false);
         }
     }
@@ -209,11 +217,7 @@ public static void register() {
                     item.then(CommandManager.argument("value", StringArgumentType.string())
                         .executes(ctx -> {
                             String val = StringArgumentType.getString(ctx, "value");
-                            if (cfg == ConfigType.STRING2 && !ConfigAccess.isValidNetworkEndpoint(val)) {
-                                ctx.getSource().sendFeedback(() -> Text.translatable("performtracker.config.network_endpoint.error"), false);
-                                return 0;
-                            }
-                            if (cfg == ConfigType.STRING3 && !ConfigAccess.isValidOutputFormat(val)) {
+                            if (cfg == ConfigType.STRING2 && !ConfigAccess.isValidOutputFormat(val)) {
                                 ctx.getSource().sendFeedback(() -> Text.translatable("performtracker.config.output_format.error"), false);
                                 return 0;
                             }