chore: ignore internal groovy variables

ref: sourceplusplus/sourceplusplus#905

Author: BFergerson

boot/build.gradle.kts

@@ -5,6 +5,7 @@ plugins {
     id("java")
     id("org.jetbrains.kotlin.jvm")
     id("maven-publish")
+    id("groovy")
 }
 
 val probeGroup: String by project
@@ -75,6 +76,7 @@ dependencies {
     testImplementation("io.vertx:vertx-service-proxy:$vertxVersion")
     testImplementation("io.vertx:vertx-service-discovery:$vertxVersion")
     testImplementation("io.vertx:vertx-lang-kotlin-coroutines:$vertxVersion")
+    testImplementation("org.codehaus.groovy:groovy-all:3.0.13")
 }
 
 tasks.test {
@@ -206,3 +208,7 @@ fun projectDependency(name: String): ProjectDependency {
         DependencyHandlerScope.of(rootProject.dependencies).project(":probes:jvm$name")
     }
 }
+
+tasks.named<GroovyCompile>("compileTestGroovy") {
+    classpath += files(tasks.compileTestKotlin)
+}

boot/src/test/groovy/integration/breakpoint/GroovyBreakpointTest.groovy

@@ -0,0 +1,100 @@
+/*
+ * Source++, the continuous feedback platform for developers.
+ * Copyright (C) 2022-2023 CodeBrig, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package integration.breakpoint
+
+import integration.ProbeIntegrationTest
+import io.vertx.junit5.VertxTestContext
+import org.junit.jupiter.api.Test
+import spp.protocol.instrument.LiveBreakpoint
+import spp.protocol.instrument.event.LiveBreakpointHit
+import spp.protocol.instrument.event.LiveInstrumentEvent
+import spp.protocol.instrument.event.LiveInstrumentEventType
+import spp.protocol.instrument.location.LiveSourceLocation
+import spp.protocol.instrument.throttle.InstrumentThrottle
+
+import static org.junit.jupiter.api.Assertions.assertEquals
+import static org.junit.jupiter.api.Assertions.assertNotNull
+
+class GroovyBreakpointTest extends ProbeIntegrationTest {
+
+    private void doTest() {
+        def a = null
+        def b = 1
+        def c = 'a'
+        def d = "a"
+        def e = true
+        def f = 1.0
+        def g = 1.0f
+        def h = 1L
+    }
+
+    @Test
+    void testGroovy() {
+        def breakpointId = "groovy-breakpoint-test"
+        def testContext = new VertxTestContext()
+        getLiveInstrumentSubscription(breakpointId).handler {
+            def body = it.body()
+            testContext.verify {
+                def event = LiveInstrumentEvent.fromJson(body)
+                if (event.eventType == LiveInstrumentEventType.BREAKPOINT_HIT) {
+                    def item = event as LiveBreakpointHit
+                    def vars = item.stackTrace.first().variables
+                    assertEquals(8, vars.size())
+
+                    assertNotNull(vars.stream().find { it.name == "a" })
+                    assertNotNull(vars.stream().find { it.name == "b" })
+                    assertNotNull(vars.stream().find { it.name == "c" })
+                    assertNotNull(vars.stream().find { it.name == "d" })
+                    assertNotNull(vars.stream().find { it.name == "e" })
+                    assertNotNull(vars.stream().find { it.name == "f" })
+                    assertNotNull(vars.stream().find { it.name == "g" })
+
+                    testContext.completeNow()
+                }
+            }
+        }
+
+        instrumentService.addLiveInstrument(
+                new LiveBreakpoint(
+                        null,
+                        new LiveSourceLocation(
+                                GroovyBreakpointTest.class.name,
+                                42, //todo: breaks if bp on return
+                                "spp-test-probe"
+                        ),
+                        null,
+                        null,
+                        1,
+                        breakpointId,
+                        true,
+                        false,
+                        false,
+                        InstrumentThrottle.DEFAULT,
+                        new HashMap<String, Object>()
+                )
+        ).onComplete {
+            if (it.succeeded()) {
+                log.info("Triggering breakpoint")
+                doTest()
+            } else {
+                testContext.failNow(it.cause())
+            }
+        }
+
+        errorOnTimeout(testContext, 2000)
+    }
+}

boot/src/test/kotlin/integration/ProbeIntegrationTest.kt

@@ -149,6 +149,7 @@ abstract class ProbeIntegrationTest {
             return vertx.eventBus().localConsumer(listenAddress)
         }
 
+        @JvmStatic
         fun getLiveInstrumentSubscription(instrumentId: String): MessageConsumer<JsonObject> {
             val listenAddress = toLiveInstrumentSubscription(instrumentId)
 

services/src/main/kotlin/spp/probe/services/common/model/ClassMetadata.kt

@@ -27,6 +27,9 @@ class ClassMetadata(val outerClass: Boolean) : Serializable {
         private val ignoredVariables = Pattern.compile(
             "(_\\\$EnhancedClassField_ws)|((delegate|cachedValue)\\$[a-zA-Z0-9\$]+)"
         )
+        private val ignoredTypes = setOf(
+            "Lgroovy/lang/MetaClass;"
+        )
     }
 
     val innerClasses = mutableListOf<Class<*>>()
@@ -39,7 +42,11 @@ class ClassMetadata(val outerClass: Boolean) : Serializable {
     }
 
     fun addField(field: ClassField) {
-        if (ignoredVariables.matcher(field.name).matches()) {
+        if (field.name.contains("$")) {
+            return //ignore synthetic variables
+        } else if (ignoredTypes.contains(field.desc)) {
+            return
+        } else if (ignoredVariables.matcher(field.name).matches()) {
             return
         }
 
@@ -51,6 +58,12 @@ class ClassMetadata(val outerClass: Boolean) : Serializable {
     }
 
     fun addVariable(methodId: String, variable: LocalVariable) {
+        if (variable.name.contains("$")) {
+            return //ignore synthetic variables
+        } else if (ignoredTypes.contains(variable.desc)) {
+            return
+        }
+
         variables.computeIfAbsent(methodId) { ArrayList() }
         variables[methodId]!!.add(variable)
     }