Add unit test for duplicate TYPE line fix

- Add PrometheusDuplicateTypeFix test to verify the fix
- Test creates interleaved metrics to reproduce the issue
- Verify TYPE line appears only once for each metric type

Author: Zhaowei-Zhang-27

be/src/util/metrics.cpp

@@ -325,6 +325,11 @@ std::string MetricRegistry::to_prometheus(bool with_tablet_metrics) const {
     // Reorder by MetricPrototype
     EntityMetricsByType entity_metrics_by_types;
     std::lock_guard<std::mutex> l1(_lock);
+    
+    // 关键：在这里就确保 _name 不为空
+    std::string registry_name = _name.empty() ? "unknown" : _name;
+    const char* safe_name_ptr = registry_name.c_str();
+    
     for (const auto& entity : _entities) {
         if (entity.first->_type == MetricEntityType::kTablet && !with_tablet_metrics) {
             continue;
@@ -347,16 +352,30 @@ std::string MetricRegistry::to_prometheus(bool with_tablet_metrics) const {
     // Output
     std::stringstream ss;
     std::unordered_set<std::string> exported_types;
+
     for (const auto& entity_metrics_by_type : entity_metrics_by_types) {
-        std::string metric_name = entity_metrics_by_type.first->combine_name(_name);
+        auto* proto = entity_metrics_by_type.first;
+        if (proto == nullptr) {
+            continue;
+        }
+
+        const std::string& g_str = proto->group_name;  
+        const std::string& n_str = proto->name;       
+
+        std::string metric_name = registry_name + "_" + g_str + "_" + n_str;
+
         if (exported_types.insert(metric_name).second) {
-            ss << entity_metrics_by_type.first->to_prometheus(_name); // metric TYPE line
+            ss << proto->to_prometheus(safe_name_ptr);
         }
-        std::string display_name = entity_metrics_by_type.first->combine_name(_name);
+
         for (const auto& entity_metric : entity_metrics_by_type.second) {
-            ss << entity_metric.second->to_prometheus(display_name, // metric key-value line
-                                                      entity_metric.first->_labels,
-                                                      entity_metrics_by_type.first->labels);
+            if (entity_metric.second == nullptr || entity_metric.first == nullptr) {
+                continue;
+            }
+        
+            ss << entity_metric.second->to_prometheus(metric_name, 
+                                                 entity_metric.first->_labels,
+                                                 proto->labels);
         }
     }
 

be/test/util/metrics_test.cpp

@@ -485,4 +485,52 @@ test_registry_task_duration_standard_deviation{instance="test",type="create_tabl
         registry.deregister_entity(entity);
     }
 }
+TEST_F(MetricsTest, PrometheusDuplicateTypeFix) {
+    MetricRegistry registry("test_registry");
+
+    // We use a specific scope {} to match the official coding style
+    {
+        // 1. Create the first entity and register a metric with a group name
+        auto entity1 = registry.register_entity("entity1");
+        // Using MetricPrototype is the "official way" in Doris metrics_test
+        MetricPrototype requests_type(MetricType::COUNTER, MetricUnit::OPERATIONS, "requests_total", "", "engine_requests");
+        IntCounter* m1 = (IntCounter*)entity1->register_metric<IntCounter>(&requests_type);
+        m1->increment(1);
+
+        // 2. Create the second entity and register a metric with a DIFFERENT name to break continuity
+        auto entity2 = registry.register_entity("entity2");
+        MetricPrototype other_type(MetricType::COUNTER, MetricUnit::OPERATIONS, "other_metric", "", "");
+        IntCounter* m2 = (IntCounter*)entity2->register_metric<IntCounter>(&other_type);  // 修复：使用 register_metric
+        m2->increment(5);
+
+        // 3. Create the third entity and register the SAME group name metric again
+        // In the old logic, this would trigger a duplicate # TYPE line
+        auto entity3 = registry.register_entity("entity3");
+        IntCounter* m3 = (IntCounter*)entity3->register_metric<IntCounter>(&requests_type);
+        m3->increment(10);
+
+        // Execute export
+        std::string output = registry.to_prometheus();
+
+        // Verification: Count the occurrences of "# TYPE test_registry_engine_requests counter"
+        // In your official snippet, the format is: # TYPE {registry_name}_{group_name} {type}
+        std::string target_type_line = "# TYPE test_registry_engine_requests counter";
+        
+        int occurrences = 0;
+        size_t pos = 0;  // 修复：使用 size_t 而不是 std::string::size_t
+        while ((pos = output.find(target_type_line, pos)) != std::string::npos) {
+            occurrences++;
+            pos += target_type_line.length();
+        }
+
+        // Must be exactly 1
+        EXPECT_EQ(1, occurrences) << "Duplicate TYPE line detected for interleaved metrics!";
+
+        // Cleanup: Following the official style to deregister entities
+        registry.deregister_entity(entity1);
+        registry.deregister_entity(entity2);
+        registry.deregister_entity(entity3);
+    }
+}
 } // namespace doris
+