feat: add copilot window for stats

observability-kit-micrometer/pom.xml

@@ -25,6 +25,16 @@
             <groupId>com.vaadin</groupId>
             <artifactId>flow-server</artifactId>
         </dependency>
+        <!--
+            Dev-only: provides the DevToolsMessageHandler SPI used by the
+            Copilot metrics panel. Optional so it is never pulled onto an
+            application's production runtime classpath.
+        -->
+        <dependency>
+            <groupId>com.vaadin</groupId>
+            <artifactId>vaadin-dev-server</artifactId>
+            <optional>true</optional>
+        </dependency>
         <dependency>
             <groupId>com.vaadin</groupId>
             <artifactId>license-checker</artifactId>

observability-kit-micrometer/src/main/java/com/vaadin/observability/micrometer/ClientResourceLoader.java

@@ -0,0 +1,70 @@
+/**
+ * Copyright (C) 2000-2026 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.observability.micrometer;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+
+import org.slf4j.LoggerFactory;
+
+import com.vaadin.flow.component.ComponentUtil;
+import com.vaadin.flow.component.UI;
+import com.vaadin.flow.internal.StringUtil;
+
+/**
+ * Loads a bundled client-side JavaScript resource into a {@link UI} exactly
+ * once. The classpath resource is read, stripped of comments and executed via
+ * {@link com.vaadin.flow.component.page.Page#executeJs}. A per-UI flag keyed by
+ * {@code initKey} guards against repeated injection.
+ */
+public final class ClientResourceLoader {
+
+    private ClientResourceLoader() {
+    }
+
+    /**
+     * Injects {@code resource} into {@code ui} once. Subsequent calls with the
+     * same {@code initKey} for the same UI are no-ops. Missing resources or
+     * read failures are logged against {@code owner} and otherwise ignored.
+     *
+     * @param ui
+     *            the target UI; {@code null} is ignored
+     * @param initKey
+     *            the per-UI data key used to ensure single injection
+     * @param resource
+     *            the classpath resource path of the JavaScript to load
+     * @param owner
+     *            the class whose class loader and logger are used
+     */
+    public static void loadOnce(UI ui, String initKey, String resource,
+            Class<?> owner) {
+        if (ui == null || ComponentUtil.getData(ui, initKey) != null) {
+            return;
+        }
+        ComponentUtil.setData(ui, initKey, Boolean.TRUE);
+        try (InputStream in = owner.getClassLoader()
+                .getResourceAsStream(resource)) {
+            if (in == null) {
+                LoggerFactory.getLogger(owner).warn(
+                        "observability-kit client resource not found: {}",
+                        resource);
+                return;
+            }
+            String js = StringUtil.removeComments(
+                    new String(in.readAllBytes(), StandardCharsets.UTF_8),
+                    true);
+            ui.getPage().executeJs(js);
+        } catch (IOException e) {
+            LoggerFactory.getLogger(owner).warn(
+                    "Could not load observability-kit client resource: {}",
+                    resource, e);
+        }
+    }
+}

observability-kit-micrometer/src/main/java/com/vaadin/observability/micrometer/MetricsServiceInitListener.java

@@ -170,7 +170,15 @@ public void serviceInit(ServiceInitEvent event) {
         ObservationRegistry or = observationRegistry != null
                 ? observationRegistry
                 : ObservabilityKit.getObservationRegistry();
+        // Record the bound registry so the dev-mode Copilot metrics panel can
+        // read the live meters regardless of deployment type.
+        ObservabilityKit.setActiveMeterRegistry(r);
         bind(event, r, or, s);
+        if (!productionMode) {
+            event.getSource()
+                    .addUIInitListener(uiEvent -> ObservabilityDevToolsClient
+                            .inject(uiEvent.getUI()));
+        }
     }
 
     void bind(ServiceInitEvent event, MeterRegistry registry,

observability-kit-micrometer/src/main/java/com/vaadin/observability/micrometer/ObservabilityDevToolsClient.java

@@ -0,0 +1,33 @@
+/**
+ * Copyright (C) 2000-2026 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.observability.micrometer;
+
+import com.vaadin.flow.component.UI;
+
+/**
+ * Loads the in-browser Vaadin Copilot metrics panel. The panel registers itself
+ * with Copilot's plugin API and pulls metric snapshots from the server over the
+ * dev-tools websocket (see {@code ObservabilityDevToolsHandler}).
+ * <p>
+ * Injected once per UI and only in development mode; in production Copilot and
+ * the dev-tools connection do not exist, so this is never called.
+ */
+final class ObservabilityDevToolsClient {
+
+    private static final String INIT_KEY = "vaadinObservabilityDevToolsInitialized";
+    private static final String CLIENT_RESOURCE = "META-INF/frontend/VaadinObservabilityDevTools.js";
+
+    private ObservabilityDevToolsClient() {
+    }
+
+    static void inject(UI ui) {
+        ClientResourceLoader.loadOnce(ui, INIT_KEY, CLIENT_RESOURCE,
+                ObservabilityDevToolsClient.class);
+    }
+}

observability-kit-micrometer/src/main/java/com/vaadin/observability/micrometer/ObservabilityKit.java

@@ -27,6 +27,15 @@ public final class ObservabilityKit {
     private static final AtomicReference<ObservationRegistry> OBSERVATION_REGISTRY = new AtomicReference<>();
     private static final AtomicReference<ObservabilitySettings> SETTINGS = new AtomicReference<>();
 
+    /**
+     * The registry instrumentation was actually bound to, recorded at
+     * {@code serviceInit} time. Unlike {@link #METER_REGISTRY} (only populated
+     * by {@link #install} in standalone deployments) this is set for every
+     * deployment type, including Spring where the registry arrives via DI. Used
+     * by the dev-mode Copilot metrics panel to read the live meters.
+     */
+    private static final AtomicReference<MeterRegistry> ACTIVE_METER_REGISTRY = new AtomicReference<>();
+
     private ObservabilityKit() {
     }
 
@@ -55,6 +64,25 @@ static MeterRegistry getMeterRegistry() {
         return METER_REGISTRY.get();
     }
 
+    /**
+     * Records the registry instrumentation was bound to. Called from
+     * {@code MetricsServiceInitListener} for all deployment types.
+     */
+    static void setActiveMeterRegistry(MeterRegistry registry) {
+        ACTIVE_METER_REGISTRY.set(registry);
+    }
+
+    /**
+     * The registry instrumentation is currently publishing to, or {@code null}
+     * if instrumentation has not been bound. Read by the dev-mode Copilot
+     * metrics panel.
+     *
+     * @return the active meter registry, or {@code null}
+     */
+    public static MeterRegistry getActiveMeterRegistry() {
+        return ACTIVE_METER_REGISTRY.get();
+    }
+
     static ObservationRegistry getObservationRegistry() {
         return OBSERVATION_REGISTRY.get();
     }
@@ -68,5 +96,6 @@ static void reset() {
         METER_REGISTRY.set(null);
         OBSERVATION_REGISTRY.set(null);
         SETTINGS.set(null);
+        ACTIVE_METER_REGISTRY.set(null);
     }
 }

observability-kit-micrometer/src/main/java/com/vaadin/observability/micrometer/client/MetricsCollectorElement.java

@@ -8,20 +8,14 @@
  */
 package com.vaadin.observability.micrometer.client;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
 import java.util.List;
 
-import org.slf4j.LoggerFactory;
-
 import com.vaadin.flow.component.AttachEvent;
 import com.vaadin.flow.component.ClientCallable;
 import com.vaadin.flow.component.Component;
-import com.vaadin.flow.component.ComponentUtil;
 import com.vaadin.flow.component.Tag;
 import com.vaadin.flow.component.UI;
-import com.vaadin.flow.internal.StringUtil;
+import com.vaadin.observability.micrometer.ClientResourceLoader;
 import com.vaadin.observability.micrometer.ObservabilitySettings;
 
 /**
@@ -55,7 +49,8 @@ public MetricsCollectorElement(ClientMetricsBinder binder,
 
     @Override
     protected void onAttach(AttachEvent event) {
-        ensureClientLoaded(event.getUI());
+        ClientResourceLoader.loadOnce(event.getUI(), CLIENT_INIT_KEY,
+                CLIENT_RESOURCE, MetricsCollectorElement.class);
     }
 
     @ClientCallable
@@ -74,27 +69,4 @@ public void recordSamples(List<ClientSample> samples) {
             binder.ingest(samples);
         }
     }
-
-    private static void ensureClientLoaded(UI ui) {
-        if (ComponentUtil.getData(ui, CLIENT_INIT_KEY) != null) {
-            return;
-        }
-        ComponentUtil.setData(ui, CLIENT_INIT_KEY, Boolean.TRUE);
-        ClassLoader loader = MetricsCollectorElement.class.getClassLoader();
-        try (InputStream in = loader.getResourceAsStream(CLIENT_RESOURCE)) {
-            if (in == null) {
-                LoggerFactory.getLogger(MetricsCollectorElement.class).warn(
-                        "observability-kit client resource not found: {}",
-                        CLIENT_RESOURCE);
-                return;
-            }
-            String js = StringUtil.removeComments(
-                    new String(in.readAllBytes(), StandardCharsets.UTF_8),
-                    true);
-            ui.getPage().executeJs(js);
-        } catch (IOException e) {
-            LoggerFactory.getLogger(MetricsCollectorElement.class)
-                    .warn("Could not load observability-kit client code", e);
-        }
-    }
 }

observability-kit-micrometer/src/main/java/com/vaadin/observability/micrometer/devtools/ObservabilityDevToolsHandler.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright (C) 2000-2026 Vaadin Ltd
+ *
+ * This program is available under Vaadin Commercial License and Service Terms.
+ *
+ * See <https://vaadin.com/commercial-license-and-service-terms> for the full
+ * license.
+ */
+package com.vaadin.observability.micrometer.devtools;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.DistributionSummary;
+import io.micrometer.core.instrument.FunctionCounter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.Measurement;
+import io.micrometer.core.instrument.Meter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.Timer;
+import tools.jackson.databind.JsonNode;
+
+import com.vaadin.base.devserver.DevToolsInterface;
+import com.vaadin.base.devserver.DevToolsMessageHandler;
+import com.vaadin.observability.micrometer.ObservabilityKit;
+
+/**
+ * Dev-mode bridge between the live Micrometer {@link MeterRegistry} and the
+ * Vaadin Copilot metrics panel.
+ * <p>
+ * Discovered via the Java {@link java.util.ServiceLoader} by Flow's dev-tools
+ * server (see {@code META-INF/services}). On request from the panel it
+ * snapshots every {@code vaadin.*} meter and sends it to the browser over the
+ * shared dev-tools websocket. This is a developer-only convenience view; it has
+ * no effect in production where the dev-tools connection does not exist.
+ */
+public class ObservabilityDevToolsHandler implements DevToolsMessageHandler {
+
+    static final String COMMAND_REFRESH = "observability-kit-refresh";
+    static final String COMMAND_METRICS = "observability-kit-metrics";
+
+    /** Only meters under this prefix are exposed to the panel. */
+    private static final String METER_PREFIX = "vaadin.";
+
+    @Override
+    public void handleConnect(DevToolsInterface devToolsInterface) {
+        // Push an initial snapshot; the panel also pulls on demand.
+        sendSnapshot(devToolsInterface);
+    }
+
+    @Override
+    public boolean handleMessage(String command, JsonNode data,
+            DevToolsInterface devToolsInterface) {
+        if (COMMAND_REFRESH.equals(command)) {
+            sendSnapshot(devToolsInterface);
+            return true;
+        }
+        return false;
+    }
+
+    private void sendSnapshot(DevToolsInterface devToolsInterface) {
+        Map<String, Object> payload = new LinkedHashMap<>();
+        payload.put("timestamp", System.currentTimeMillis());
+        payload.put("meters", snapshot());
+        devToolsInterface.send(COMMAND_METRICS, payload);
+    }
+
+    private List<Map<String, Object>> snapshot() {
+        List<Map<String, Object>> meters = new ArrayList<>();
+        MeterRegistry registry = ObservabilityKit.getActiveMeterRegistry();
+        if (registry == null) {
+            return meters;
+        }
+        for (Meter meter : registry.getMeters()) {
+            Meter.Id id = meter.getId();
+            if (!id.getName().startsWith(METER_PREFIX)) {
+                continue;
+            }
+            Map<String, Object> entry = new LinkedHashMap<>();
+            entry.put("name", id.getName());
+            entry.put("type", id.getType().name());
+
+            Map<String, String> tags = new LinkedHashMap<>();
+            for (Tag tag : id.getTags()) {
+                tags.put(tag.getKey(), tag.getValue());
+            }
+            entry.put("tags", tags);
+
+            // Emit derived, interpretable values per meter type rather than raw
+            // statistics. For timers the cumulative mean is the stable, useful
+            // figure (TOTAL_TIME is an ever-growing sum and the SimpleMeter
+            // registry's MAX decays to 0 between polls).
+            if (meter instanceof Timer timer) {
+                entry.put("count", timer.count());
+                entry.put("mean", timer.mean(TimeUnit.MILLISECONDS));
+                entry.put("max", timer.max(TimeUnit.MILLISECONDS));
+                entry.put("unit", "ms");
+            } else if (meter instanceof Counter counter) {
+                entry.put("count", (long) counter.count());
+            } else if (meter instanceof FunctionCounter counter) {
+                entry.put("count", (long) counter.count());
+            } else if (meter instanceof Gauge gauge) {
+                entry.put("value", gauge.value());
+            } else if (meter instanceof DistributionSummary summary) {
+                entry.put("count", summary.count());
+                entry.put("mean", summary.mean());
+                entry.put("max", summary.max());
+                if (id.getBaseUnit() != null) {
+                    entry.put("unit", id.getBaseUnit());
+                }
+            } else {
+                // Unknown meter type: fall back to raw measurements.
+                List<Map<String, Object>> measurements = new ArrayList<>();
+                for (Measurement measurement : meter.measure()) {
+                    Map<String, Object> m = new LinkedHashMap<>();
+                    m.put("statistic", measurement.getStatistic().name());
+                    m.put("value", measurement.getValue());
+                    measurements.add(m);
+                }
+                entry.put("measurements", measurements);
+            }
+            meters.add(entry);
+        }
+        return meters;
+    }
+}