BTrace TCK Report

\n\ + where arguments is comma separated name=value pairs. Argument names include:\n \ + bootClassPath boot classpath to be used\n \ + systemClassPath system classpath to be used\n \ + debug boolean flag to specify debug mode\n \ + trusted boolean flag to enable trusted mode\n \ + dumpClasses boolean flag to specify whether to dump .classes for instrumented classes\n \ + dumpDir directory where instrumented .class files are saved\n \ + help print this help message\n \ + noServer boolean flag to specify whether to start btrace server or not\n \ + port btrace agent server port\n \ + statsd statsd server, if any (format )\n \ + allowExtensions comma-separated list of extension IDs explicitly allowed to link implementations\n \ + denyExtensions comma-separated list of extension IDs explicitly denied from linking implementations\n \ + allowPrivileged allow all privileged extensions to link implementations (true/false)\n \ + probeDescPath directories where @OnProbe mapping descriptor XML files are searched\n \ + stdout redirect the btrace output to stdout instead of writing it to an arbitrary file (true/false)\n \ + scriptdir the path to a directory containing scripts to be run at the agent startup\n \ + scriptOutputFile the path to a file the btrace agent will store its output\n \ + grant comma-separated list of permissions to grant (e.g. grant=NETWORK,THREADS)\n \ + deny comma-separated list of permissions to deny (e.g. deny=EXEC,NATIVE)\n \ + grantAll grant all permissions (true/false) - use with caution\n \ + script comma separated list of compiled tracing scripts to be run at the agent startup; *MUST* be the last argument in the list\n\n \ + Permissions:\n \ + Default (always granted): MESSAGING, AGGREGATION, JFR_EVENTS, PROFILING\n \ + Standard (granted unless denied): FILE_READ, SYSTEM_PROPS, THREAD_INFO, MEMORY_INFO\n \ + Privileged (require explicit grant): FILE_WRITE, NETWORK, THREADS, NATIVE, EXEC,\n \ + REFLECTION, CLASSLOADER, UNLIMITED_MEMORY +btrace.version=BTrace v.@btrace.version@ (@hash@) diff --git a/btrace-core/src/main/resources/org/openjdk/btrace/core/messages.properties b/btrace-core/src/main/resources/org/openjdk/btrace/core/messages.properties deleted file mode 100644 index ddc547a81..000000000 --- a/btrace-core/src/main/resources/org/openjdk/btrace/core/messages.properties +++ /dev/null @@ -1,109 +0,0 @@ -# BTrace "compile time" and runtime error messages. -return.type.should.be.void=btrace probe methods must return void -btrace.program.should.be.class=btrace program must be a class (not interface or enum) -no.complex.unsafe.value=@BTrace.trusted|unsafe value should be only a plain boolean -not.a.btrace.program=@BTrace annotation is missing -no.outer.class=btrace class should not be a local class -no.asserts=asserts are not allowed -no.catch=catching exception is not allowed -no.do.while=do..while loops are not allowed -no.enhanced.for=enhanced for statements are not allowed -no.loops=loops (backward jumps) are not allowed -no.for.loop=for loops are not allowed -no.array.creation=array creation is not allowed -no.new.object=object creation is not allowed -no.synchronized.blocks=synchronized blocks are not allowed -no.synchronized.methods=probe action methods should not be synchronized -no.throw=throwing exception is not allowed -no.try=try .. catch .. finally blocks are not allowed -no.while.loop=while loops are not allowed -no.other="other" statement(s) are not allowed -execution.loop.danger=execution of btrace program may lead to endless loop which is not allowed -method.should.be.public=btrace methods should be public -class.should.be.public=btrace class should be public -no.static.method=static methods are not allowed (using BTrace short syntax) -no.instance.method=instance methods are not allowed -no.method.calls=method calls are not allowed - only calls to BTraceUtils are allowed -no.assignment=side-effects to probed program are not allowed -no.nested.class=nested and inner classes are not allowed -no.local.class=local classes are not allowed -no.static.variables=static variables are not allowed (using BTrace short syntax) -no.instance.variables=instance variables are not allowed -object.superclass.required=btrace class should extend java.lang.Object -no.interface.implementation=btrace class can not implement interfaces -no.class.literals=class literals are not allowed -self.desc.invalid=@Self annotation applicable only for Kind.ENTRY and Kind.RETURN -probemethod.desc.invalid=@ProbeMethod annotation applicable only for Kind.ENTRY, Kind.RETURN and Kind.CALL -probeclass.desc.invalid=@ProbeClassName annotation applicable only for Kind.ENTRY, Kind.RETURN and Kind.CALL -return.desc.invalid=@Return annotation applicable only for Kind.RETURN -duration.desc.invalid=@Duration annotation applicable only for Kind.RETURN and Kind.ERROR -target-method.desc.invalid=@TargetMethodOrField annotation applicable only for Kind.CALL, Kind.FIELD_GET, Kind.FIELD_SET, Kind.ARRAY_GET and Kind.ARRAY_SET -target-instance.desc.invalid=@TargetInstance annotation applicable only for Kind.CALL, Kind.FIELD_GET, Kind.FIELD_SET, Kind.ARRAY_GET, Kind.ARRAY_SET, Kind.INSTANCEOF, Kind.CHECKCAST, Kind.ERROR, Kind.THROW, Kind.CATCH, Kind.SYNC_ENTRY or Kind.SYNC_EXIT -onexit.invalid=@OnExit annotation applicable only to methods with signature (int)void -onerror.invalid=@OnError annotation applicable only to methods with signature (java.lang.Throwable)void -multiple.param.annotation=Multiple parameters annotated by the same annotation are not allowed -sampler.invalid.location=@Sampled annotation supported only for @OnMethod annotated classes with Kind of [ENTRY, RETURN, ERROR, CALL] -missing.injected=Service fields must be annotated by @Injected -injected.no.initializer=Injected fields must not use initializer -injected.no.runtime=Injection kind is RUNTIME but the service is not a subclass of org.openjdk.btrace.services.spi.RuntimeService -injected.no.simple=Injection kind is SIMPLE but the service is not a subclass of org.openjdk.btrace.services.spi.SimpleService -service.injector.literals=May only use literals as Service.* methods parameters -missing.event=Event template fields must be annotated by either @Event or @PeriodicEvent -event.nonpublic.handler=Periodic event handler must be public -event.invalid.handler=Invalid periodic event handler specified - the handler method must take exactly one parameter of JfrEvent type -agent.no.instance.variables=instance variables are not allowed -agent.unsafe.not.allowed=Trusted mode, requested by the script, not allowed -jfr.event.invalid.field=Invalid JFR event field name -# usage messages -btracec.usage=\ - Usage: btracec \n\ - where possible options include:\n \ - -classpath Specify where to find user class files and annotation processors\n \ - -cp Specify where to find user class files and annotation processors\n \ - -I Specify where to find include files\n \ - -d Specify where to place generated class files\n \ - -nopack Do not produce packed probes. Useful when targeting pre 1.3.10 versions.\n \ - -packext File extension for script packs (default '.class'). Valid only if '-nopack' is not specified.\n \ - -trusted Enable trusted script (eg. no checks) -btrace.usage=\ - Usage: btrace \n\ - where possible options include:\n \ - --version Show the version\n \ - -v Run in verbose mode\n \ - -l List all locally attachable JVMs\n \ - -lp List active probes in the given JVM\n \ - \t\t\tExpects PID or app name as the follow-up argument\n \ - \t\t\tAll other options are discarded\n \ - -r Reconnect to an active disconnected probe\n \ - \t\t\tExpects PID or app name as the follow-up argument\n \ - \t\t\tAll other options are discarded\n \ - -o The path to store the probe output (will disable showing the output in console)\n \ - -u Run in trusted mode\n \ - -d Dump the instrumented classes to the specified path\n \ - -pd The search path for the probe XML descriptors\n \ - -classpath Specify where to find user class files and annotation processors\n \ - -cp Specify where to find user class files and annotation processors\n \ - -I Specify where to find include files\n \ - -p Specify port to which the btrace agent listens for clients\n \ - -statsd Specify the statsd server, if any\n \ - -x Run unattended\n \ - \t\t\tDeploy the given probe and disconnect -btrace.agent.usage=\ - Usage: java -javaagent:java-agent.jar=

\n\ - where arguments is comma separated name=value pairs. Argument names include:\n \ - bootClassPath boot classpath to be used\n \ - systemClassPath system classpath to be used\n \ - debug boolean flag to specify debug mode\n \ - trusted boolean flag to enable trusted mode\n \ - dumpClasses boolean flag to specify whether to dump .classes for instrumented classes\n \ - dumpDir directory where instrumented .class files are saved\n \ - help print this help message\n \ - noServer boolean flag to specify whether to start btrace server or not\n \ - port btrace agent server port\n \ - statsd statsd server, if any (format )\n \ - probeDescPath directories where @OnProbe mapping descriptor XML files are searched\n \ - stdout redirect the btrace output to stdout instead of writing it to an arbitrary file (true/false)\n \ - scriptdir the path to a directory containing scripts to be run at the agent startup\n \ - scriptOutputFile the path to a file the btrace agent will store its output\n \ - script comma separated list of compiled tracing scripts to be run at the agent startup; *MUST* be the last argument in the list -btrace.version=BTrace v.@btrace.version@ (@hash@) diff --git a/btrace-core/src/test/java/io/btrace/BTraceTest.java b/btrace-core/src/test/java/io/btrace/BTraceTest.java new file mode 100644 index 000000000..846497f0d --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/BTraceTest.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +public class BTraceTest { + + @Test + void str_null_returnsNullString() { + assertEquals("null", BTrace.str((Object) null)); + } + + @Test + void str_object_usesToString() { + assertEquals("42", BTrace.str((Object) 42)); + } + + @Test + void concat_twoStrings() { + assertEquals("ab", BTrace.concat("a", "b")); + } + + @Test + void timestamp_isPositive() { + assertTrue(BTrace.timestamp() > 0); + } + + @Test + void monotonic_isPositive() { + assertTrue(BTrace.monotonic() > 0); + } + + @Test + void threadName_currentThread() { + assertEquals(Thread.currentThread().getName(), BTrace.threadName(Thread.currentThread())); + } + + @Test + void threadId_currentThread() { + assertEquals(Thread.currentThread().getId(), BTrace.threadId(Thread.currentThread())); + } + + @Test + void className_object() { + assertEquals("java.lang.String", BTrace.className("hello")); + } + + @Test + void identity_returnsSystemIdentityHashCode() { + Object o = new Object(); + assertEquals(System.identityHashCode(o), BTrace.identity(o)); + } + + @Test + void substr_basic() { + assertEquals("bc", BTrace.substr("abcd", 1, 3)); + } + + @Test + void matches_basicRegex() { + assertTrue(BTrace.matches("abcd", ".*bc.*")); + assertFalse(BTrace.matches("abcd", "^bc")); + } + + @Test + void str_boolean_true() { + assertEquals("true", BTrace.str(true)); + } + + @Test + void str_boolean_false() { + assertEquals("false", BTrace.str(false)); + } + + @Test + void str_int() { + assertEquals("7", BTrace.str(7)); + } + + @Test + void str_long() { + assertEquals("7", BTrace.str(7L)); + } + + @Test + void str_float() { + assertEquals("1.5", BTrace.str(1.5f)); + } + + @Test + void str_double() { + assertEquals("2.5", BTrace.str(2.5)); + } + + @Test + void startsWith_true() { + assertTrue(BTrace.startsWith("hello", "hel")); + } + + @Test + void startsWith_false() { + assertFalse(BTrace.startsWith("hello", "ell")); + } + + @Test + void endsWith_true() { + assertTrue(BTrace.endsWith("hello", "llo")); + } + + @Test + void endsWith_false() { + assertFalse(BTrace.endsWith("hello", "hel")); + } + + @Test + void length_string() { + assertEquals(5, BTrace.length("hello")); + } + + @Test + void length_null() { + assertEquals(0, BTrace.length(null)); + } + + @Test + void abs_long() { + assertEquals(5L, BTrace.abs(-5L)); + } + + @Test + void abs_double() { + assertEquals(3.0, BTrace.abs(-3.0)); + } + + @Test + void min_long() { + assertEquals(2L, BTrace.min(2L, 5L)); + } + + @Test + void max_long() { + assertEquals(5L, BTrace.max(2L, 5L)); + } + + @Test + void min_double() { + assertEquals(1.0, BTrace.min(1.0, 2.0)); + } + + @Test + void max_double() { + assertEquals(2.0, BTrace.max(1.0, 2.0)); + } + + @Test + void concat_null_null_returnsEmpty() { + assertEquals("", BTrace.concat(null, null)); + } + + @Test + void concat_null_b_returnsB() { + assertEquals("b", BTrace.concat(null, "b")); + } + + @Test + void substr_null_returnsEmpty() { + assertEquals("", BTrace.substr(null, 0, 0)); + } + + @Test + void matches_null_subject_returnsFalse() { + assertFalse(BTrace.matches(null, ".*")); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/BTraceUtilsShimTest.java b/btrace-core/src/test/java/io/btrace/core/BTraceUtilsShimTest.java new file mode 100644 index 000000000..c420c1808 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/BTraceUtilsShimTest.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import io.btrace.BTrace; +import org.junit.jupiter.api.Test; + +public class BTraceUtilsShimTest { + + @Test + void stringsStrcat_delegatesToBTrace() { + assertEquals(BTrace.concat("hello", " world"), BTraceUtils.Strings.strcat("hello", " world")); + } + + @Test + void stringsStr_objectProducesSameResult() { + Object obj = 42; + assertEquals(BTrace.str(obj), BTraceUtils.Strings.str(obj)); + } + + @Test + void stringsStr_nullProducesSameResult() { + assertEquals(BTrace.str((Object) null), BTraceUtils.Strings.str((Object) null)); + } +} diff --git a/btrace-core/src/test/java/org/openjdk/btrace/core/CircularBufferTest.java b/btrace-core/src/test/java/io/btrace/core/CircularBufferTest.java similarity index 80% rename from btrace-core/src/test/java/org/openjdk/btrace/core/CircularBufferTest.java rename to btrace-core/src/test/java/io/btrace/core/CircularBufferTest.java index 71b07139f..ca22f602f 100644 --- a/btrace-core/src/test/java/org/openjdk/btrace/core/CircularBufferTest.java +++ b/btrace-core/src/test/java/io/btrace/core/CircularBufferTest.java @@ -1,4 +1,20 @@ -package org.openjdk.btrace.core; +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core; import static org.junit.jupiter.api.Assertions.*; diff --git a/btrace-core/src/test/java/io/btrace/core/MethodIDTest.java b/btrace-core/src/test/java/io/btrace/core/MethodIDTest.java new file mode 100644 index 000000000..c3b7e52d1 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/MethodIDTest.java @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core; + +import static org.junit.jupiter.api.Assertions.*; + +import java.lang.reflect.Field; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class MethodIDTest { + + @BeforeEach + void resetState() throws Exception { + // Reset the static fields for isolation between tests + Field lastFld = MethodID.class.getDeclaredField("lastMethodId"); + Field mapFld = MethodID.class.getDeclaredField("methodIds"); + + lastFld.setAccessible(true); + mapFld.setAccessible(true); + + AtomicInteger last = (AtomicInteger) lastFld.get(null); + @SuppressWarnings("unchecked") + Map map = (Map) mapFld.get(null); + + last.set(1); + map.clear(); + } + + @Test + void singleThreadedConsistency() { + int id1 = MethodID.getMethodId("A#foo#()V"); + int id2 = MethodID.getMethodId("A#foo#()V"); + int id3 = MethodID.getMethodId("A#bar#()V"); + + assertEquals(id1, id2, "Same tag should return same ID"); + assertNotEquals(id1, id3, "Different tags should return different IDs"); + } + + @Test + void concurrentGenerationHasNoDuplicates() throws Exception { + int threads = 10; + int idsPerThread = 1000; + ExecutorService pool = Executors.newFixedThreadPool(threads); + ConcurrentMap reverse = new ConcurrentHashMap<>(); + CountDownLatch start = new CountDownLatch(1); + CountDownLatch done = new CountDownLatch(threads); + + for (int t = 0; t < threads; t++) { + final int idx = t; + pool.submit( + () -> { + try { + start.await(); + for (int i = 0; i < idsPerThread; i++) { + String tag = "C" + idx + "#m" + i + "#()V"; + int id = MethodID.getMethodId(tag); + String prev = reverse.putIfAbsent(id, tag); + if (prev != null && !prev.equals(tag)) { + fail( + "Duplicate ID assigned to different tags: " + + id + + " => " + + prev + + " vs " + + tag); + } + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + fail(e); + } finally { + done.countDown(); + } + }); + } + + start.countDown(); + assertTrue(done.await(30, TimeUnit.SECONDS), "Tasks should complete timely"); + pool.shutdownNow(); + + // Ensure expected cardinality + assertEquals(threads * idsPerThread, reverse.size(), "Every tag should map to a unique ID"); + + // Re-check stability: calling again returns same id + Set secondPass = new HashSet<>(); + for (Map.Entry e : reverse.entrySet()) { + int id = MethodID.getMethodId(e.getValue()); + assertTrue(secondPass.add(id), "IDs should still be unique on second pass"); + } + assertEquals(reverse.size(), secondPass.size()); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/PrefixMapTest.java b/btrace-core/src/test/java/io/btrace/core/PrefixMapTest.java new file mode 100644 index 000000000..bc7eb3c5e --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/PrefixMapTest.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.Test; + +class PrefixMapTest { + @Test + void addAndContainsWorkWithDuplicates() { + PrefixMap pm = new PrefixMap(); + pm.add("abc"); + pm.add("abc"); // duplicate + pm.add("abcd"); + + assertTrue(pm.contains("abc")); + assertTrue(pm.contains("abcdef")); + assertTrue(pm.contains("abcd")); + assertFalse(pm.contains("ab")); + assertFalse(pm.contains("abX")); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/ReflectiveFieldAccessTest.java b/btrace-core/src/test/java/io/btrace/core/ReflectiveFieldAccessTest.java new file mode 100644 index 000000000..a8efd9183 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/ReflectiveFieldAccessTest.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class ReflectiveFieldAccessTest { + + @Test + public void getIntTest() { + D a = new D(); + RuntimeException exception = + assertThrows(RuntimeException.class, () -> BTraceUtils.Reflective.getInt("notExist", a)); + assertTrue(exception.getMessage().contains("notExist")); + } + + static class A { + int a; + } + + static class B extends A {} + + static class C extends A {} + + static class D extends C {} +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/InstrumentCommandTest.java b/btrace-core/src/test/java/io/btrace/core/comm/InstrumentCommandTest.java new file mode 100644 index 000000000..39e97b507 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/InstrumentCommandTest.java @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import io.btrace.core.ArgsMap; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.Test; + +/** + * Tests for InstrumentCommand defensive copying to prevent external modification of bytecode and + * arguments. + */ +class InstrumentCommandTest { + + @Test + void testConstructorWithArgsMapMakesDefensiveCopy() { + byte[] bytecode = {0x01, 0x02, 0x03}; + ArgsMap args = new ArgsMap(); + args.put("key1", "value1"); + + InstrumentCommand cmd = new InstrumentCommand(bytecode, args); + + // Modify the original bytecode array + bytecode[0] = (byte) 0xFF; + + // Modify the original ArgsMap + args.put("key2", "value2"); + + // Verify command's internal state was not affected + byte[] retrievedCode = cmd.getCode(); + assertEquals( + 0x01, retrievedCode[0], "Bytecode should not be affected by external modification"); + + ArgsMap retrievedArgs = cmd.getArguments(); + assertNull(retrievedArgs.get("key2"), "Args should not be affected by external modification"); + assertEquals("value1", retrievedArgs.get("key1")); + } + + @Test + void testConstructorWithStringArrayArgs() { + byte[] bytecode = {0x01, 0x02, 0x03}; + String[] args = {"key1=value1", "key2=value2"}; + + InstrumentCommand cmd = new InstrumentCommand(bytecode, args); + + // Modify original bytecode + bytecode[0] = (byte) 0xFF; + + // Verify bytecode is protected + assertEquals(0x01, cmd.getCode()[0]); + + // Verify args were parsed correctly + assertEquals("value1", cmd.getArguments().get("key1")); + assertEquals("value2", cmd.getArguments().get("key2")); + } + + @Test + void testConstructorWithMapArgs() { + byte[] bytecode = {0x01, 0x02, 0x03}; + Map argsMap = new HashMap<>(); + argsMap.put("key1", "value1"); + + InstrumentCommand cmd = new InstrumentCommand(bytecode, argsMap); + + // Modify original bytecode and map + bytecode[0] = (byte) 0xFF; + argsMap.put("key2", "value2"); + + // Verify command is protected + assertEquals(0x01, cmd.getCode()[0]); + assertNull(cmd.getArguments().get("key2")); + } + + @Test + void testGetCodeReturnsDefensiveCopy() { + byte[] bytecode = {0x01, 0x02, 0x03}; + InstrumentCommand cmd = new InstrumentCommand(bytecode, new ArgsMap()); + + byte[] retrieved1 = cmd.getCode(); + byte[] retrieved2 = cmd.getCode(); + + // Modify the returned array + retrieved1[0] = (byte) 0xFF; + + // Verify original is unchanged + assertEquals(0x01, cmd.getCode()[0], "getCode() should return a defensive copy"); + + // Verify each call returns a new copy + assertNotSame(retrieved1, retrieved2, "getCode() should return new copy each time"); + assertEquals(0x01, retrieved2[0], "Second call should return unmodified bytecode"); + } + + @Test + void testNullBytecode() { + InstrumentCommand cmd = new InstrumentCommand(null, new ArgsMap()); + + assertNull(cmd.getCode(), "Null bytecode should remain null"); + } + + @Test + void testNullArgs() { + byte[] bytecode = {0x01, 0x02, 0x03}; + InstrumentCommand cmd = new InstrumentCommand(bytecode, (ArgsMap) null); + + assertNull(cmd.getArguments(), "Null args should remain null"); + } + + @Test + void testEmptyBytecode() { + byte[] bytecode = {}; + InstrumentCommand cmd = new InstrumentCommand(bytecode, new ArgsMap()); + + assertNotNull(cmd.getCode()); + assertEquals(0, cmd.getCode().length); + } + + @Test + void testEmptyArgs() { + byte[] bytecode = {0x01, 0x02, 0x03}; + ArgsMap args = new ArgsMap(); + InstrumentCommand cmd = new InstrumentCommand(bytecode, args); + + assertNotNull(cmd.getArguments()); + assertEquals(0, cmd.getArguments().size()); + } + + @Test + void testLargeBytecodeArray() { + byte[] bytecode = new byte[1024 * 1024]; // 1MB + for (int i = 0; i < bytecode.length; i++) { + bytecode[i] = (byte) (i % 256); + } + + InstrumentCommand cmd = new InstrumentCommand(bytecode, new ArgsMap()); + + // Modify original + bytecode[1000] = (byte) 0xFF; + + // Verify copy is independent + assertNotEquals((byte) 0xFF, cmd.getCode()[1000]); + } + + @Test + void testMultipleArguments() { + byte[] bytecode = {0x01, 0x02, 0x03}; + ArgsMap args = new ArgsMap(); + args.put("arg1", "value1"); + args.put("arg2", "value2"); + args.put("arg3", "value3"); + + InstrumentCommand cmd = new InstrumentCommand(bytecode, args); + + // Modify original + args.put("arg4", "value4"); + args.put("arg1", "modified"); + + // Verify command's args are unchanged + ArgsMap cmdArgs = cmd.getArguments(); + assertEquals(3, cmdArgs.size()); + assertEquals("value1", cmdArgs.get("arg1")); + assertEquals("value2", cmdArgs.get("arg2")); + assertEquals("value3", cmdArgs.get("arg3")); + assertNull(cmdArgs.get("arg4")); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/JavaSerializationProtocolLeakTest.java b/btrace-core/src/test/java/io/btrace/core/comm/JavaSerializationProtocolLeakTest.java new file mode 100644 index 000000000..870ad0aa0 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/JavaSerializationProtocolLeakTest.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.concurrent.atomic.AtomicBoolean; +import org.junit.jupiter.api.Test; + +class JavaSerializationProtocolLeakTest { + + static class FailingInputStream extends InputStream { + @Override + public int read() throws IOException { + throw new IOException("boom"); + } + } + + static class CloseTrackingOutputStream extends OutputStream { + final AtomicBoolean closed = new AtomicBoolean(false); + + @Override + public void write(int b) throws IOException { + // accept anything + } + + @Override + public void close() throws IOException { + closed.set(true); + super.close(); + } + } + + @Test + void constructorClosesOutputStreamOnInputInitFailure() { + InputStream failingIn = new FailingInputStream(); + CloseTrackingOutputStream trackingOut = new CloseTrackingOutputStream(); + + IOException ex = + assertThrows( + IOException.class, () -> new JavaSerializationProtocol(failingIn, trackingOut)); + assertTrue(trackingOut.closed.get(), "Output stream should be closed when input init fails"); + assertEquals("boom", ex.getMessage()); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/ListProbesCommandConcurrencyTest.java b/btrace-core/src/test/java/io/btrace/core/comm/ListProbesCommandConcurrencyTest.java new file mode 100644 index 000000000..c33a050fd --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/ListProbesCommandConcurrencyTest.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; + +import java.io.ByteArrayOutputStream; +import java.io.ObjectOutputStream; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.Test; + +class ListProbesCommandConcurrencyTest { + + @Test + void concurrentSetAndIterateDoesNotThrow() throws Exception { + ListProbesCommand cmd = new ListProbesCommand(); + + CountDownLatch start = new CountDownLatch(1); + CountDownLatch done = new CountDownLatch(2); + + Runnable writer = + () -> { + try { + start.await(); + for (int r = 0; r < 500; r++) { + int size = (r % 10) + 1; + List list = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + list.add("probe-" + r + '-' + i); + } + cmd.setProbes(list); + } + } catch (InterruptedException ignored) { + Thread.currentThread().interrupt(); + } finally { + done.countDown(); + } + }; + + Runnable reader = + () -> { + try { + start.await(); + for (int r = 0; r < 500; r++) { + // print() + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + assertDoesNotThrow(() -> cmd.print(pw)); + + // write() + assertDoesNotThrow( + () -> { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { + cmd.write(oos); + } + }); + } + } catch (InterruptedException ignored) { + Thread.currentThread().interrupt(); + } finally { + done.countDown(); + } + }; + + new Thread(writer).start(); + new Thread(reader).start(); + start.countDown(); + + // Ensure both loops finished + done.await(10, TimeUnit.SECONDS); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/NullSafetyTest.java b/btrace-core/src/test/java/io/btrace/core/comm/NullSafetyTest.java new file mode 100644 index 000000000..81b300bb5 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/NullSafetyTest.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.Test; + +class NullSafetyTest { + + @Test + void testErrorCommandPrintWithNullCause() { + ErrorCommand cmd = new ErrorCommand(null); + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + + assertDoesNotThrow(() -> cmd.print(pw)); + + String output = sw.toString(); + assertTrue(output.contains("! ERROR")); + assertTrue(output.contains("No exception information available")); + } + + @Test + void testGridDataCommandWithNullRow() { + List data = new ArrayList<>(); + data.add(new Object[] {"Row1", 100}); + data.add(null); + data.add(new Object[] {"Row3", 300}); + + GridDataCommand cmd = new GridDataCommand("TestGrid", data); + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + + assertDoesNotThrow(() -> cmd.print(pw)); + String output = sw.toString(); + assertTrue(output.contains("Row1")); + assertTrue(output.contains("Row3")); + } + + @Test + void testMessageCommandWithNullMessage() { + MessageCommand cmd = new MessageCommand((String) null); + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + + assertDoesNotThrow(() -> cmd.print(pw)); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/ProtocolConfigTest.java b/btrace-core/src/test/java/io/btrace/core/comm/ProtocolConfigTest.java new file mode 100644 index 000000000..56792b9bc --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/ProtocolConfigTest.java @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; + +/** Tests for ProtocolConfig. */ +public class ProtocolConfigTest { + + @AfterEach + public void clearSystemProperties() { + System.clearProperty("btrace.comm.protocol"); + System.clearProperty("btrace.comm.autoNegotiate"); + System.clearProperty("btrace.comm.forceVersion"); + } + + @Test + public void testDefaultConfig() { + ProtocolConfig config = ProtocolConfig.getDefault(); + + assertEquals(ProtocolVersion.V2, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testBuilderDefaultValues() { + ProtocolConfig config = ProtocolConfig.builder().build(); + + assertEquals(ProtocolVersion.V2, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testBuilderCustomVersion() { + ProtocolConfig config = ProtocolConfig.builder().version(ProtocolVersion.V1).build(); + + assertEquals(ProtocolVersion.V1, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testBuilderDisableAutoNegotiate() { + ProtocolConfig config = ProtocolConfig.builder().autoNegotiate(false).build(); + + assertEquals(ProtocolVersion.V2, config.getVersion()); + assertFalse(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testBuilderForceVersion() { + ProtocolConfig config = + ProtocolConfig.builder() + .version(ProtocolVersion.V1) + .autoNegotiate(false) + .forceVersion(true) + .build(); + + assertEquals(ProtocolVersion.V1, config.getVersion()); + assertFalse(config.isAutoNegotiate()); + assertTrue(config.isForceVersion()); + } + + @Test + public void testBuilderInvalidConfiguration() { + // Cannot have both forceVersion and autoNegotiate enabled + assertThrows( + IllegalArgumentException.class, + () -> ProtocolConfig.builder().autoNegotiate(true).forceVersion(true).build()); + } + + @Test + public void testFromSystemPropertiesNoProperties() { + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + + // Should return default config when no properties are set + assertEquals(ProtocolVersion.V2, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testFromSystemPropertiesProtocolV1() { + System.setProperty("btrace.comm.protocol", "v1"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + + assertEquals(ProtocolVersion.V1, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testFromSystemPropertiesProtocolV2() { + System.setProperty("btrace.comm.protocol", "v2"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + + assertEquals(ProtocolVersion.V2, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + } + + @Test + public void testFromSystemPropertiesProtocolNumeric() { + System.setProperty("btrace.comm.protocol", "1"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + assertEquals(ProtocolVersion.V1, config.getVersion()); + + System.setProperty("btrace.comm.protocol", "2"); + config = ProtocolConfig.fromSystemProperties(); + assertEquals(ProtocolVersion.V2, config.getVersion()); + } + + @Test + public void testFromSystemPropertiesProtocolUppercase() { + System.setProperty("btrace.comm.protocol", "V1"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + assertEquals(ProtocolVersion.V1, config.getVersion()); + + System.setProperty("btrace.comm.protocol", "V2"); + config = ProtocolConfig.fromSystemProperties(); + assertEquals(ProtocolVersion.V2, config.getVersion()); + } + + @Test + public void testFromSystemPropertiesInvalidProtocol() { + System.setProperty("btrace.comm.protocol", "invalid"); + assertThrows(IllegalArgumentException.class, () -> ProtocolConfig.fromSystemProperties()); + } + + @Test + public void testFromSystemPropertiesAutoNegotiate() { + System.setProperty("btrace.comm.autoNegotiate", "false"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + + assertFalse(config.isAutoNegotiate()); + } + + @Test + public void testFromSystemPropertiesForceVersion() { + System.setProperty("btrace.comm.protocol", "v1"); + System.setProperty("btrace.comm.autoNegotiate", "false"); + System.setProperty("btrace.comm.forceVersion", "true"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + + assertEquals(ProtocolVersion.V1, config.getVersion()); + assertFalse(config.isAutoNegotiate()); + assertTrue(config.isForceVersion()); + } + + @Test + public void testFromSystemPropertiesAllProperties() { + System.setProperty("btrace.comm.protocol", "v2"); + System.setProperty("btrace.comm.autoNegotiate", "true"); + System.setProperty("btrace.comm.forceVersion", "false"); + ProtocolConfig config = ProtocolConfig.fromSystemProperties(); + + assertEquals(ProtocolVersion.V2, config.getVersion()); + assertTrue(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testToString() { + ProtocolConfig config = ProtocolConfig.getDefault(); + String str = config.toString(); + + assertTrue(str.contains("version=")); + assertTrue(str.contains("autoNegotiate=")); + assertTrue(str.contains("forceVersion=")); + } + + @Test + public void testBuilderChaining() { + ProtocolConfig config = + ProtocolConfig.builder() + .version(ProtocolVersion.V1) + .autoNegotiate(false) + .forceVersion(false) + .build(); + + assertEquals(ProtocolVersion.V1, config.getVersion()); + assertFalse(config.isAutoNegotiate()); + assertFalse(config.isForceVersion()); + } + + @Test + public void testMultipleBuilds() { + ProtocolConfig.Builder builder = ProtocolConfig.builder(); + + ProtocolConfig config1 = builder.version(ProtocolVersion.V1).build(); + ProtocolConfig config2 = builder.version(ProtocolVersion.V2).build(); + + // Each build should create independent instances + assertNotSame(config1, config2); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/ProtocolNegotiatorTest.java b/btrace-core/src/test/java/io/btrace/core/comm/ProtocolNegotiatorTest.java new file mode 100644 index 000000000..1a92fe22b --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/ProtocolNegotiatorTest.java @@ -0,0 +1,264 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.PushbackInputStream; +import org.junit.jupiter.api.Test; + +/** Tests for ProtocolNegotiator and ProtocolVersion. */ +public class ProtocolNegotiatorTest { + + @Test + public void testProtocolVersionV1() { + assertEquals(1, ProtocolVersion.V1.getVersion()); + assertFalse(ProtocolVersion.V1.hasMagicBytes()); + assertEquals(0, ProtocolVersion.V1.getMagicBytes().length); + } + + @Test + public void testProtocolVersionV2() { + assertEquals(2, ProtocolVersion.V2.getVersion()); + assertTrue(ProtocolVersion.V2.hasMagicBytes()); + byte[] magicBytes = ProtocolVersion.V2.getMagicBytes(); + assertEquals(4, magicBytes.length); + assertEquals(0x42, magicBytes[0]); // 'B' + assertEquals(0x54, magicBytes[1]); // 'T' + assertEquals(0x52, magicBytes[2]); // 'R' + assertEquals(0x32, magicBytes[3]); // '2' + } + + @Test + public void testProtocolVersionFromVersion() { + assertEquals(ProtocolVersion.V1, ProtocolVersion.fromVersion(1)); + assertEquals(ProtocolVersion.V2, ProtocolVersion.fromVersion(2)); + + assertThrows(IllegalArgumentException.class, () -> ProtocolVersion.fromVersion(0)); + assertThrows(IllegalArgumentException.class, () -> ProtocolVersion.fromVersion(3)); + assertThrows(IllegalArgumentException.class, () -> ProtocolVersion.fromVersion(-1)); + } + + @Test + public void testProtocolVersionDetectFromPrefix() { + // V2 magic bytes + byte[] v2Prefix = {0x42, 0x54, 0x52, 0x32}; // "BTR2" + assertEquals(ProtocolVersion.V2, ProtocolVersion.detectFromPrefix(v2Prefix)); + + // V2 with extra bytes + byte[] v2PrefixExtra = {0x42, 0x54, 0x52, 0x32, 0x01, 0x02}; + assertEquals(ProtocolVersion.V2, ProtocolVersion.detectFromPrefix(v2PrefixExtra)); + + // V1 (no magic bytes) + byte[] v1Prefix = {(byte) 0xAC, (byte) 0xED, 0x00, 0x05}; // Java serialization header + assertEquals(ProtocolVersion.V1, ProtocolVersion.detectFromPrefix(v1Prefix)); + + // Empty + assertEquals(ProtocolVersion.V1, ProtocolVersion.detectFromPrefix(new byte[0])); + assertEquals(ProtocolVersion.V1, ProtocolVersion.detectFromPrefix(null)); + + // Incomplete V2 magic + byte[] incomplete = {0x42, 0x54, 0x52}; // Only "BTR" + assertEquals(ProtocolVersion.V1, ProtocolVersion.detectFromPrefix(incomplete)); + + // Wrong magic bytes + byte[] wrong = {0x42, 0x54, 0x52, 0x31}; // "BTR1" + assertEquals(ProtocolVersion.V1, ProtocolVersion.detectFromPrefix(wrong)); + } + + @Test + public void testProtocolVersionGetDefault() { + assertEquals(ProtocolVersion.V2, ProtocolVersion.getDefault()); + } + + @Test + public void testNegotiatorDefaultConstructor() { + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + assertEquals(ProtocolVersion.V2, negotiator.getPreferredVersion()); + } + + @Test + public void testNegotiatorCustomVersion() { + ProtocolNegotiator negotiator = new ProtocolNegotiator(ProtocolVersion.V1); + assertEquals(ProtocolVersion.V1, negotiator.getPreferredVersion()); + } + + @Test + public void testNegotiateV2WithPushback() throws IOException { + byte[] v2Data = {0x42, 0x54, 0x52, 0x32, 0x01, 0x02, 0x03}; // "BTR2" + data + PushbackInputStream pis = new PushbackInputStream(new ByteArrayInputStream(v2Data), 4); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + ProtocolVersion detected = negotiator.negotiate(pis); + + assertEquals(ProtocolVersion.V2, detected); + + // After negotiation, stream should be positioned after magic bytes + assertEquals(0x01, pis.read()); + assertEquals(0x02, pis.read()); + assertEquals(0x03, pis.read()); + } + + @Test + public void testNegotiateV1WithPushback() throws IOException { + byte[] v1Data = {(byte) 0xAC, (byte) 0xED, 0x00, 0x05}; // Java serialization header + PushbackInputStream pis = new PushbackInputStream(new ByteArrayInputStream(v1Data), 4); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + ProtocolVersion detected = negotiator.negotiate(pis); + + assertEquals(ProtocolVersion.V1, detected); + + // After negotiation, stream should be reset to beginning (bytes pushed back) + assertEquals(0xAC, pis.read() & 0xFF); + assertEquals(0xED, pis.read() & 0xFF); + assertEquals(0x00, pis.read()); + assertEquals(0x05, pis.read()); + } + + @Test + public void testNegotiateV2WithMark() throws IOException { + byte[] v2Data = {0x42, 0x54, 0x52, 0x32, 0x01, 0x02, 0x03}; // "BTR2" + data + ByteArrayInputStream bis = new ByteArrayInputStream(v2Data); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + ProtocolVersion detected = negotiator.negotiate(bis); + + assertEquals(ProtocolVersion.V2, detected); + + // After negotiation, stream should be positioned after magic bytes + assertEquals(0x01, bis.read()); + assertEquals(0x02, bis.read()); + assertEquals(0x03, bis.read()); + } + + @Test + public void testNegotiateV1WithMark() throws IOException { + byte[] v1Data = {(byte) 0xAC, (byte) 0xED, 0x00, 0x05}; // Java serialization header + ByteArrayInputStream bis = new ByteArrayInputStream(v1Data); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + ProtocolVersion detected = negotiator.negotiate(bis); + + assertEquals(ProtocolVersion.V1, detected); + + // After negotiation, stream should be reset to beginning + assertEquals(0xAC, bis.read() & 0xFF); + assertEquals(0xED, bis.read() & 0xFF); + assertEquals(0x00, bis.read()); + assertEquals(0x05, bis.read()); + } + + @Test + public void testNegotiateEmptyStream() { + byte[] emptyData = {}; + PushbackInputStream pis = new PushbackInputStream(new ByteArrayInputStream(emptyData), 4); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + assertThrows(IOException.class, () -> negotiator.negotiate(pis)); + } + + @Test + public void testNegotiateUnsupportedStream() { + // Create a stream that doesn't support mark/reset or pushback + InputStream unsupported = + new InputStream() { + @Override + public int read() throws IOException { + return 0; + } + + @Override + public boolean markSupported() { + return false; + } + }; + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + assertThrows(IllegalArgumentException.class, () -> negotiator.negotiate(unsupported)); + } + + @Test + public void testCreateNegotiationStream() { + ByteArrayInputStream bis = new ByteArrayInputStream(new byte[10]); + PushbackInputStream pis = ProtocolNegotiator.createNegotiationStream(bis); + + assertNotNull(pis); + assertTrue(pis instanceof PushbackInputStream); + } + + @Test + public void testCreateNegotiationStreamAlreadyPushback() { + PushbackInputStream original = new PushbackInputStream(new ByteArrayInputStream(new byte[10])); + PushbackInputStream result = ProtocolNegotiator.createNegotiationStream(original); + + assertSame(original, result); + } + + @Test + public void testNegotiateMultipleV2Connections() throws IOException { + // Simulate multiple connections to ensure negotiation works repeatedly + for (int i = 0; i < 5; i++) { + byte[] v2Data = {0x42, 0x54, 0x52, 0x32, (byte) i}; + PushbackInputStream pis = new PushbackInputStream(new ByteArrayInputStream(v2Data), 4); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + ProtocolVersion detected = negotiator.negotiate(pis); + + assertEquals(ProtocolVersion.V2, detected); + assertEquals(i, pis.read()); // Verify data after magic bytes + } + } + + @Test + public void testNegotiateMultipleV1Connections() throws IOException { + // Simulate multiple connections to ensure negotiation works repeatedly + for (int i = 0; i < 5; i++) { + byte[] v1Data = {(byte) 0xAC, (byte) 0xED, 0x00, (byte) i}; + PushbackInputStream pis = new PushbackInputStream(new ByteArrayInputStream(v1Data), 4); + + ProtocolNegotiator negotiator = new ProtocolNegotiator(); + ProtocolVersion detected = negotiator.negotiate(pis); + + assertEquals(ProtocolVersion.V1, detected); + assertEquals(0xAC, pis.read() & 0xFF); // Verify pushed back + } + } + + @Test + public void testProtocolVersionToString() { + assertTrue(ProtocolVersion.V1.toString().contains("version=1")); + assertTrue(ProtocolVersion.V1.toString().contains("hasMagicBytes=false")); + + assertTrue(ProtocolVersion.V2.toString().contains("version=2")); + assertTrue(ProtocolVersion.V2.toString().contains("hasMagicBytes=true")); + } + + @Test + public void testMagicBytesImmutable() { + // Ensure that modifying returned magic bytes doesn't affect the enum + byte[] magicBytes = ProtocolVersion.V2.getMagicBytes(); + byte original = magicBytes[0]; + magicBytes[0] = 0x00; // Try to modify + + byte[] magicBytes2 = ProtocolVersion.V2.getMagicBytes(); + assertEquals(original, magicBytes2[0]); // Should still be original value + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/TypeSafetyTest.java b/btrace-core/src/test/java/io/btrace/core/comm/TypeSafetyTest.java new file mode 100644 index 000000000..2a9eac36e --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/TypeSafetyTest.java @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.Test; + +/** + * Tests for type safety validation in Command deserialization. These tests ensure that malformed or + * malicious data cannot cause ClassCastException at runtime. + */ +class TypeSafetyTest { + + @Test + void testNumberDataCommandValidNumber() throws Exception { + NumberDataCommand cmd = new NumberDataCommand("test", 42); + + // Serialize and deserialize + NumberDataCommand deserialized = roundTrip(cmd, NumberDataCommand.class); + + assertEquals("test", deserialized.name); + assertEquals(42, deserialized.getValue()); + } + + @Test + void testNumberDataCommandNullValue() throws Exception { + NumberDataCommand cmd = new NumberDataCommand("test", null); + + NumberDataCommand deserialized = roundTrip(cmd, NumberDataCommand.class); + + assertEquals("test", deserialized.name); + assertNull(deserialized.getValue()); + } + + @Test + void testNumberDataCommandRejectsInvalidType() throws Exception { + // Create a command and manually serialize with wrong type + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + + // Write command header + oos.writeByte(Command.NUMBER); + + // Write name + oos.writeUTF("test"); + + // Write WRONG type (String instead of Number) + oos.writeObject("not a number"); + oos.flush(); + + // Try to deserialize - should fail during WireIO.read() + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bais); + + IOException thrown = + assertThrows( + IOException.class, + () -> { + WireIO.read(ois); + }); + assertTrue(thrown.getMessage().contains("Invalid data type")); + } + + @Test + void testErrorCommandValidThrowable() throws Exception { + Throwable cause = new RuntimeException("test error"); + ErrorCommand cmd = new ErrorCommand(cause); + + ErrorCommand deserialized = roundTrip(cmd, ErrorCommand.class); + + assertNotNull(deserialized.getCause()); + assertEquals("test error", deserialized.getCause().getMessage()); + } + + @Test + void testErrorCommandNullCause() throws Exception { + ErrorCommand cmd = new ErrorCommand(null); + + ErrorCommand deserialized = roundTrip(cmd, ErrorCommand.class); + + assertNull(deserialized.getCause()); + } + + @Test + void testErrorCommandRejectsInvalidType() throws Exception { + // Create a command and manually serialize with wrong type + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + + // Write command header + oos.writeByte(Command.ERROR); + + // Write WRONG type (String instead of Throwable) + oos.writeObject("not a throwable"); + oos.flush(); + + // Try to deserialize + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bais); + + IOException thrown = + assertThrows( + IOException.class, + () -> { + WireIO.read(ois); + }); + assertTrue(thrown.getMessage().contains("Invalid data type")); + } + + @Test + void testSetSettingsCommandValidTypes() throws Exception { + Map params = new HashMap<>(); + params.put("string_param", "value"); + params.put("int_param", 42); + params.put("bool_param", true); + params.put("long_param", 123L); + params.put("double_param", 3.14); + + SetSettingsCommand cmd = new SetSettingsCommand(params); + SetSettingsCommand deserialized = roundTrip(cmd, SetSettingsCommand.class); + + assertEquals(5, deserialized.getParams().size()); + assertEquals("value", deserialized.getParams().get("string_param")); + assertEquals(42, deserialized.getParams().get("int_param")); + assertEquals(true, deserialized.getParams().get("bool_param")); + assertEquals(123L, deserialized.getParams().get("long_param")); + assertEquals(3.14, deserialized.getParams().get("double_param")); + } + + @Test + void testSetSettingsCommandRejectsInvalidType() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + + // Write command header + oos.writeByte(Command.SET_PARAMS); + + // Write params with invalid type (use a serializable but invalid type) + oos.writeInt(1); // size + oos.writeUTF("bad_param"); + oos.writeObject( + new java.util + .ArrayList<>()); // Invalid type - ArrayList is serializable but not a valid settings + // type + oos.flush(); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bais); + + IOException thrown = + assertThrows( + IOException.class, + () -> { + WireIO.read(ois); + }); + assertTrue(thrown.getMessage().contains("Invalid settings value type")); + } + + @Test + void testSetSettingsCommandRejectsNegativeSize() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + + oos.writeByte(Command.SET_PARAMS); + oos.writeInt(-1); // Negative size! + oos.flush(); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bais); + + IOException thrown = + assertThrows( + IOException.class, + () -> { + WireIO.read(ois); + }); + assertTrue(thrown.getMessage().contains("Invalid params size")); + } + + @Test + void testSetSettingsCommandRejectsExcessiveSize() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + + oos.writeByte(Command.SET_PARAMS); + oos.writeInt(100000); // Excessive size! + oos.flush(); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bais); + + IOException thrown = + assertThrows( + IOException.class, + () -> { + WireIO.read(ois); + }); + assertTrue(thrown.getMessage().contains("Invalid params size")); + } + + // Helper method to serialize and deserialize a command + private T roundTrip(T cmd, Class clazz) throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + WireIO.write(oos, cmd); + oos.flush(); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bais); + Command result = WireIO.read(ois); + + assertInstanceOf(clazz, result); + return clazz.cast(result); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/WireProtocolSessionTest.java b/btrace-core/src/test/java/io/btrace/core/comm/WireProtocolSessionTest.java new file mode 100644 index 000000000..7f889c2c1 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/WireProtocolSessionTest.java @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.InputStream; +import java.io.OutputStream; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import java.io.PushbackInputStream; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.junit.jupiter.api.Test; + +class WireProtocolSessionTest { + private interface SessionHandler { + void handle(WireProtocol protocol) throws Exception; + } + + @Test + void testDisconnectThenListProbesAcrossConnections() throws Exception { + String probeId = "probe-12345"; + String probeEntry = probeId + " [OnMethodTest]"; + + runV2Session( + protocol -> { + Command cmd = protocol.read(); + assertTrue(cmd instanceof DisconnectCommand); + protocol.write(new DisconnectCommand(probeId)); + protocol.flush(); + }, + protocol -> { + protocol.write(new DisconnectCommand()); + protocol.flush(); + Command cmd = protocol.read(); + assertTrue(cmd instanceof DisconnectCommand); + assertEquals(probeId, ((DisconnectCommand) cmd).getProbeId()); + }); + + runV2Session( + protocol -> { + Command cmd = protocol.read(); + assertTrue(cmd instanceof ListProbesCommand); + ListProbesCommand response = (ListProbesCommand) cmd; + response.setProbes(Collections.singletonList(probeEntry)); + protocol.write(response); + protocol.flush(); + }, + protocol -> { + protocol.write(new ListProbesCommand()); + protocol.flush(); + Command cmd = protocol.read(); + assertTrue(cmd instanceof ListProbesCommand); + List probes = ((ListProbesCommand) cmd).getProbes(); + assertEquals(1, probes.size()); + assertEquals(probeEntry, probes.get(0)); + }); + } + + private static void runV2Session(SessionHandler serverHandler, SessionHandler clientHandler) + throws Exception { + Duplex duplex = new Duplex(); + ExecutorService executor = Executors.newSingleThreadExecutor(); + Future serverFuture = + executor.submit( + () -> { + try (WireProtocol protocol = + createServerProtocol(duplex.serverIn, duplex.serverOut)) { + serverHandler.handle(protocol); + } catch (Exception e) { + throw new RuntimeException(e); + } + }); + + try (WireProtocol protocol = createClientProtocol(duplex.clientIn, duplex.clientOut)) { + clientHandler.handle(protocol); + } + + try { + serverFuture.get(5, TimeUnit.SECONDS); + } catch (ExecutionException e) { + throw unwrap(e); + } catch (TimeoutException e) { + throw new AssertionError("Server session did not complete in time", e); + } finally { + executor.shutdownNow(); + } + } + + private static WireProtocol createServerProtocol(InputStream in, OutputStream out) + throws Exception { + ProtocolNegotiator negotiator = new ProtocolNegotiator(ProtocolVersion.V2); + PushbackInputStream input = ProtocolNegotiator.createNegotiationStream(in); + ProtocolVersion negotiated = negotiator.negotiateAgent(input, out); + assertEquals(ProtocolVersion.V2, negotiated); + WireProtocol protocol = new BinaryWireProtocol(input, out); + assertEquals(ProtocolVersion.V2, protocol.getVersion()); + return protocol; + } + + private static WireProtocol createClientProtocol(InputStream in, OutputStream out) + throws Exception { + ProtocolNegotiator negotiator = new ProtocolNegotiator(ProtocolVersion.V2); + ProtocolVersion negotiated = negotiator.negotiateClient(in, out, ProtocolVersion.V2); + assertEquals(ProtocolVersion.V2, negotiated); + WireProtocol protocol = new BinaryWireProtocol(in, out); + assertEquals(ProtocolVersion.V2, protocol.getVersion()); + return protocol; + } + + private static Exception unwrap(ExecutionException e) { + Throwable cause = e.getCause(); + if (cause instanceof Exception) { + return (Exception) cause; + } + return new RuntimeException(cause); + } + + private static final class Duplex { + final InputStream clientIn; + final OutputStream clientOut; + final InputStream serverIn; + final OutputStream serverOut; + + Duplex() throws Exception { + PipedInputStream clientInput = new PipedInputStream(32 * 1024); + PipedInputStream serverInput = new PipedInputStream(32 * 1024); + this.clientOut = new PipedOutputStream(serverInput); + this.serverOut = new PipedOutputStream(clientInput); + this.clientIn = clientInput; + this.serverIn = serverInput; + } + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/WireProtocolTest.java b/btrace-core/src/test/java/io/btrace/core/comm/WireProtocolTest.java new file mode 100644 index 000000000..cebeb7a0f --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/WireProtocolTest.java @@ -0,0 +1,352 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm; + +import static org.junit.jupiter.api.Assertions.*; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import org.junit.jupiter.api.Test; + +/** Tests for WireProtocol interface and implementations. */ +public class WireProtocolTest { + + @Test + public void testJavaSerializationProtocolBasic() throws Exception { + // Use piped streams for proper ObjectStream initialization + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + + // Create protocols + WireProtocol writer = WireProtocol.create(ProtocolVersion.V1, pis, pos); + + // Write command in separate thread to avoid deadlock + Thread writerThread = + new Thread( + () -> { + try { + Command cmd = new MessageCommand("test message"); + writer.write(cmd); + writer.flush(); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); + writerThread.start(); + + // Read command + Command readCmd = writer.read(); + + assertEquals(Command.MESSAGE, readCmd.getType()); + assertTrue(readCmd instanceof MessageCommand); + assertEquals("test message", ((MessageCommand) readCmd).getMessage()); + assertEquals(ProtocolVersion.V1, writer.getVersion()); + + writerThread.join(); + } + + @Test + public void testBinaryWireProtocolBasic() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Write with binary protocol + WireProtocol writer = new BinaryWireProtocol(new ByteArrayInputStream(new byte[0]), baos); + Command cmd = new MessageCommand("test message"); + writer.write(cmd); + writer.flush(); + + // Read with binary protocol + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + WireProtocol reader = new BinaryWireProtocol(bais, new ByteArrayOutputStream()); + Command readCmd = reader.read(); + + assertEquals(Command.MESSAGE, readCmd.getType()); + assertTrue(readCmd instanceof MessageCommand); + assertEquals("test message", ((MessageCommand) readCmd).getMessage()); + assertEquals(ProtocolVersion.V2, reader.getVersion()); + } + + @Test + public void testWireProtocolCreateV1() throws Exception { + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + + WireProtocol protocol = WireProtocol.create(ProtocolVersion.V1, pis, pos); + + assertTrue(protocol instanceof JavaSerializationProtocol); + assertEquals(ProtocolVersion.V1, protocol.getVersion()); + protocol.close(); + } + + @Test + public void testWireProtocolCreateV2() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + WireProtocol protocol = + WireProtocol.create(ProtocolVersion.V2, new ByteArrayInputStream(new byte[0]), baos); + + assertTrue(protocol instanceof BinaryWireProtocol); + assertEquals(ProtocolVersion.V2, protocol.getVersion()); + } + + @Test + public void testWireProtocolWithNegotiationV2() throws Exception { + // Create stream with V2 magic bytes + ByteArrayOutputStream setupStream = new ByteArrayOutputStream(); + setupStream.write(new byte[] {0x42, 0x54, 0x52, 0x32}); // "BTR2" + + // Add some dummy data for the protocol to work with + ByteArrayInputStream inputStream = new ByteArrayInputStream(setupStream.toByteArray()); + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + WireProtocol protocol = WireProtocol.createWithNegotiation(inputStream, outputStream); + + assertEquals(ProtocolVersion.V2, protocol.getVersion()); + assertTrue(protocol instanceof BinaryWireProtocol); + } + + @Test + public void testWireProtocolWithNegotiationV1() throws Exception { + // Create stream with Java serialization header + ByteArrayOutputStream setupStream = new ByteArrayOutputStream(); + setupStream.write(new byte[] {(byte) 0xAC, (byte) 0xED, 0x00, 0x05}); + + ByteArrayInputStream inputStream = new ByteArrayInputStream(setupStream.toByteArray()); + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + WireProtocol protocol = WireProtocol.createWithNegotiation(inputStream, outputStream); + + assertEquals(ProtocolVersion.V1, protocol.getVersion()); + assertTrue(protocol instanceof JavaSerializationProtocol); + } + + @Test + public void testWireProtocolWithConfigForceV1() throws Exception { + ProtocolConfig config = + ProtocolConfig.builder() + .version(ProtocolVersion.V1) + .autoNegotiate(false) + .forceVersion(true) + .build(); + + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + + WireProtocol protocol = WireProtocol.createWithConfig(config, pis, pos); + + assertEquals(ProtocolVersion.V1, protocol.getVersion()); + assertTrue(protocol instanceof JavaSerializationProtocol); + protocol.close(); + } + + @Test + public void testWireProtocolWithConfigAutoNegotiate() throws Exception { + ProtocolConfig config = + ProtocolConfig.builder() + .version(ProtocolVersion.V2) // Preferred version + .autoNegotiate(true) + .build(); + + // Stream with V2 magic bytes + ByteArrayOutputStream setupStream = new ByteArrayOutputStream(); + setupStream.write(new byte[] {0x42, 0x54, 0x52, 0x32}); + + ByteArrayInputStream inputStream = new ByteArrayInputStream(setupStream.toByteArray()); + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + WireProtocol protocol = WireProtocol.createWithConfig(config, inputStream, outputStream); + + assertEquals(ProtocolVersion.V2, protocol.getVersion()); + } + + @Test + public void testMultipleCommandsV1() throws Exception { + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + + // Single protocol for both read and write + WireProtocol protocol = new JavaSerializationProtocol(pis, pos); + + // Write multiple commands in separate thread + Thread writerThread = + new Thread( + () -> { + try { + protocol.write(new MessageCommand("msg1")); + protocol.write(new MessageCommand("msg2")); + protocol.write(new ExitCommand(0)); + protocol.flush(); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); + writerThread.start(); + + // Read multiple commands + Command cmd1 = protocol.read(); + assertEquals("msg1", ((MessageCommand) cmd1).getMessage()); + + Command cmd2 = protocol.read(); + assertEquals("msg2", ((MessageCommand) cmd2).getMessage()); + + Command cmd3 = protocol.read(); + assertEquals(Command.EXIT, cmd3.getType()); + + writerThread.join(); + protocol.close(); + } + + @Test + public void testMultipleCommandsV2() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + WireProtocol writer = new BinaryWireProtocol(new ByteArrayInputStream(new byte[0]), baos); + + // Write multiple commands + writer.write(new MessageCommand("msg1")); + writer.write(new MessageCommand("msg2")); + writer.write(new ExitCommand(0)); + writer.flush(); + + // Read multiple commands + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + WireProtocol reader = new BinaryWireProtocol(bais, new ByteArrayOutputStream()); + + Command cmd1 = reader.read(); + assertEquals("msg1", ((MessageCommand) cmd1).getMessage()); + + Command cmd2 = reader.read(); + assertEquals("msg2", ((MessageCommand) cmd2).getMessage()); + + Command cmd3 = reader.read(); + assertEquals(Command.EXIT, cmd3.getType()); + } + + @Test + public void testCloseV1() throws Exception { + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + WireProtocol protocol = new JavaSerializationProtocol(pis, pos); + + protocol.close(); + + assertThrows(IOException.class, () -> protocol.write(new MessageCommand("test"))); + assertThrows(IOException.class, () -> protocol.read()); + } + + @Test + public void testCloseV2() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + WireProtocol protocol = new BinaryWireProtocol(new ByteArrayInputStream(new byte[0]), baos); + + protocol.close(); + + assertThrows(IOException.class, () -> protocol.write(new MessageCommand("test"))); + assertThrows(IOException.class, () -> protocol.read()); + } + + @Test + public void testJavaSerializationProtocolReset() throws Exception { + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + JavaSerializationProtocol protocol = new JavaSerializationProtocol(pis, pos); + + // Reset should not throw + protocol.reset(); + + // Should still be able to write after reset (in separate thread to avoid deadlock) + Thread writerThread = + new Thread( + () -> { + try { + protocol.write(new MessageCommand("test")); + protocol.flush(); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); + writerThread.start(); + writerThread.join(); + + protocol.close(); + } + + @Test + public void testJavaSerializationProtocolAccessors() throws Exception { + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + JavaSerializationProtocol protocol = new JavaSerializationProtocol(pis, pos); + + assertNotNull(protocol.getObjectInputStream()); + assertNotNull(protocol.getObjectOutputStream()); + protocol.close(); + } + + @Test + public void testBinaryWireProtocolAccessors() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ByteArrayInputStream bais = new ByteArrayInputStream(new byte[0]); + BinaryWireProtocol protocol = new BinaryWireProtocol(bais, baos); + + assertSame(bais, protocol.getInputStream()); + assertSame(baos, protocol.getOutputStream()); + } + + @Test + public void testV1V2Interoperability() throws Exception { + // Test V2 - simpler with byte arrays + ByteArrayOutputStream v2Stream = new ByteArrayOutputStream(); + WireProtocol v2Writer = new BinaryWireProtocol(new ByteArrayInputStream(new byte[0]), v2Stream); + v2Writer.write(new MessageCommand("v2 message")); + v2Writer.flush(); + + // Read with V2 + WireProtocol v2Reader = + new BinaryWireProtocol( + new ByteArrayInputStream(v2Stream.toByteArray()), new ByteArrayOutputStream()); + Command v2Cmd = v2Reader.read(); + assertEquals("v2 message", ((MessageCommand) v2Cmd).getMessage()); + v2Reader.close(); + + // Test V1 with piped streams + PipedOutputStream pos = new PipedOutputStream(); + PipedInputStream pis = new PipedInputStream(pos); + WireProtocol v1Protocol = new JavaSerializationProtocol(pis, pos); + + // Write in separate thread + Thread writerThread = + new Thread( + () -> { + try { + v1Protocol.write(new MessageCommand("v1 message")); + v1Protocol.flush(); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); + writerThread.start(); + + // Read + Command v1Cmd = v1Protocol.read(); + assertEquals("v1 message", ((MessageCommand) v1Cmd).getMessage()); + + writerThread.join(); + v1Protocol.close(); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolEdgeCasesTest.java b/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolEdgeCasesTest.java new file mode 100644 index 000000000..3a7f17e1f --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolEdgeCasesTest.java @@ -0,0 +1,547 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm.v2; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +/** + * Edge case tests for the binary protocol. Tests null values, empty collections, large payloads, + * boundary conditions, and malformed data. + */ +public class BinaryProtocolEdgeCasesTest { + + // ===== NULL AND EMPTY VALUE TESTS ===== + + @Test + public void testNullString() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryProtocol.writeString(baos, null); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + String result = BinaryProtocol.readString(bais); + assertNull(result); + } + + @Test + public void testEmptyString() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryProtocol.writeString(baos, ""); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + String result = BinaryProtocol.readString(bais); + assertNotNull(result); + assertEquals("", result); + } + + @Test + public void testNullByteArray() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryProtocol.writeByteArray(baos, null); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + byte[] result = BinaryProtocol.readByteArray(bais); + assertNull(result); + } + + @Test + public void testEmptyByteArray() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryProtocol.writeByteArray(baos, new byte[0]); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + byte[] result = BinaryProtocol.readByteArray(bais); + assertNotNull(result); + assertEquals(0, result.length); + } + + @Test + public void testMessageCommandNullMessage() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + BinaryMessageCommand original = new BinaryMessageCommand(null, false); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + // Empty message should be preserved as empty string (not null) + assertEquals("", msgCommand.getMessage()); + } + + @Test + public void testErrorCommandNullMessage() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + BinaryErrorCommand original = new BinaryErrorCommand("java.lang.RuntimeException", null, null); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryErrorCommand); + BinaryErrorCommand errorCommand = (BinaryErrorCommand) readCommand; + assertEquals("java.lang.RuntimeException", errorCommand.getExceptionClass()); + assertNull(errorCommand.getMessage()); + assertNull(errorCommand.getStackTrace()); + } + + @Test + public void testEventCommandNullEvent() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + BinaryEventCommand original = new BinaryEventCommand(null); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryEventCommand); + BinaryEventCommand eventCommand = (BinaryEventCommand) readCommand; + assertNull(eventCommand.getEvent()); + } + + @Test + public void testStringMapWithNullValues() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + Map data = new HashMap<>(); + data.put("key1", "value1"); + data.put("key2", null); + data.put("key3", ""); + + BinaryStringMapDataCommand original = new BinaryStringMapDataCommand("TestMap", data); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryStringMapDataCommand); + BinaryStringMapDataCommand mapCommand = (BinaryStringMapDataCommand) readCommand; + Map readData = mapCommand.getData(); + assertEquals("value1", readData.get("key1")); + assertNull(readData.get("key2")); + assertEquals("", readData.get("key3")); + } + + @Test + public void testEmptyNumberMap() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + Map data = new HashMap<>(); + BinaryNumberMapDataCommand original = new BinaryNumberMapDataCommand("EmptyMap", data); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryNumberMapDataCommand); + BinaryNumberMapDataCommand mapCommand = (BinaryNumberMapDataCommand) readCommand; + assertTrue(mapCommand.getData().isEmpty()); + } + + // ===== BOUNDARY CONDITION TESTS ===== + + @Test + public void testVeryLargeMessage() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create a 10MB message + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 10 * 1024 * 1024; i++) { + sb.append('A'); + } + String largeMessage = sb.toString(); + + BinaryMessageCommand original = new BinaryMessageCommand(largeMessage, false); + BinaryWireIO.write(baos, original); + + // Verify it was written + assertTrue(baos.size() > 0); + + // Verify it can be read back + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(largeMessage.length(), msgCommand.getMessage().length()); + assertEquals(largeMessage, msgCommand.getMessage()); + } + + @Test + public void testLargeBytecodeArray() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create a 1MB bytecode array + byte[] largeCode = new byte[1024 * 1024]; + for (int i = 0; i < largeCode.length; i++) { + largeCode[i] = (byte) (i % 256); + } + + Map args = new HashMap<>(); + args.put("test", "value"); + + BinaryInstrumentCommand original = new BinaryInstrumentCommand(largeCode, args); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryInstrumentCommand); + BinaryInstrumentCommand instrCommand = (BinaryInstrumentCommand) readCommand; + assertArrayEquals(largeCode, instrCommand.getCode()); + } + + @Test + public void testMapWith1000Entries() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + Map data = new HashMap<>(); + for (int i = 0; i < 1000; i++) { + data.put("key" + i, i); + } + + BinaryNumberMapDataCommand original = new BinaryNumberMapDataCommand("LargeMap", data); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryNumberMapDataCommand); + BinaryNumberMapDataCommand mapCommand = (BinaryNumberMapDataCommand) readCommand; + assertEquals(1000, mapCommand.getData().size()); + for (int i = 0; i < 1000; i++) { + assertEquals(i, mapCommand.getData().get("key" + i).intValue()); + } + } + + @Test + public void testGridDataWithManyRows() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + List columnNames = new ArrayList<>(); + columnNames.add("Col1"); + columnNames.add("Col2"); + + List data = new ArrayList<>(); + for (int i = 0; i < 500; i++) { + data.add(new Object[] {"Row" + i, i}); + } + + BinaryGridDataCommand original = new BinaryGridDataCommand("LargeGrid", columnNames, data); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryGridDataCommand); + BinaryGridDataCommand gridCommand = (BinaryGridDataCommand) readCommand; + assertEquals(500, gridCommand.getData().size()); + } + + // ===== UNICODE AND SPECIAL CHARACTER TESTS ===== + + @Test + public void testUnicodeStrings() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test various Unicode characters + String unicode = "Hello 世界 🌍 مرحبا Привет"; + BinaryMessageCommand original = new BinaryMessageCommand(unicode, false); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(unicode, msgCommand.getMessage()); + } + + @Test + public void testEmojiInMessage() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + String emoji = "🚀 BTrace launched! 🎉🎊🎈"; + BinaryMessageCommand original = new BinaryMessageCommand(emoji, false); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(emoji, msgCommand.getMessage()); + } + + @Test + public void testControlCharactersInString() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + String controlChars = "Line1\nLine2\tTabbed\rCarriageReturn\0Null"; + BinaryProtocol.writeString(baos, controlChars); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + String result = BinaryProtocol.readString(bais); + assertEquals(controlChars, result); + } + + // ===== MALFORMED DATA TESTS ===== + + @Test + public void testInvalidProtocolVersion() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Write invalid protocol version + BinaryProtocol.writeByte(baos, (byte) 99); // Invalid version + BinaryProtocol.writeByte(baos, BinaryCommand.MESSAGE); // Valid command type + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + + // Should throw IOException due to version mismatch + assertThrows( + IOException.class, + () -> { + BinaryWireIO.read(bais); + }); + } + + @Test + public void testInvalidCommandType() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Write valid protocol version but invalid command type + BinaryProtocol.writeByte(baos, BinaryProtocol.VERSION); + BinaryProtocol.writeByte(baos, (byte) 99); // Invalid command type + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + + // Should throw MalformedCommandException due to unknown command type + assertThrows( + MalformedCommandException.class, + () -> { + BinaryWireIO.read(bais); + }); + } + + @Test + public void testTruncatedStream() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Write only protocol version and command type, but not the data + BinaryProtocol.writeByte(baos, BinaryProtocol.VERSION); + BinaryProtocol.writeByte(baos, BinaryCommand.MESSAGE); + // Missing message data... + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + + // Should throw IOException due to unexpected end of stream + assertThrows( + IOException.class, + () -> { + BinaryWireIO.read(bais); + }); + } + + // ===== COMPRESSION EDGE CASES ===== + + @Test + public void testCompressionThreshold() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create message exactly at threshold (1024 bytes) + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 1024; i++) { + sb.append('X'); + } + String thresholdMessage = sb.toString(); + + BinaryMessageCommand original = new BinaryMessageCommand(thresholdMessage, false); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(thresholdMessage, msgCommand.getMessage()); + } + + @Test + public void testCompressionJustAboveThreshold() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create message just above threshold (1025 bytes) + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 1025; i++) { + sb.append('Y'); + } + String aboveThresholdMessage = sb.toString(); + + BinaryMessageCommand original = new BinaryMessageCommand(aboveThresholdMessage, false); + BinaryWireIO.write(baos, original); + + // Message should be compressed, verify it's smaller than original + int wireSize = baos.size(); + // Wire size should be less than original due to compression + // (accounting for protocol overhead) + assertTrue(wireSize < aboveThresholdMessage.length()); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(aboveThresholdMessage, msgCommand.getMessage()); + } + + @Test + public void testHighlyCompressibleMessage() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create highly compressible message (many repeated characters) + String compressible = "AAAAAAAAAA".repeat(1000); // 10,000 'A's + + BinaryMessageCommand original = new BinaryMessageCommand(compressible, false); + BinaryWireIO.write(baos, original); + + // Compressed size should be much smaller than original + int wireSize = baos.size(); + assertTrue(wireSize < compressible.length() / 5); // Should compress to less than 20% + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(compressible, msgCommand.getMessage()); + } + + // ===== NUMERIC BOUNDARY TESTS ===== + + @ParameterizedTest + @ValueSource(ints = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE}) + public void testIntegerBoundaries(int value) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryProtocol.writeInt(baos, value); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + int result = BinaryProtocol.readInt(bais); + assertEquals(value, result); + } + + @ParameterizedTest + @ValueSource(longs = {Long.MIN_VALUE, -1L, 0L, 1L, Long.MAX_VALUE}) + public void testLongBoundaries(long value) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryProtocol.writeLong(baos, value); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + long result = BinaryProtocol.readLong(bais); + assertEquals(value, result); + } + + @Test + public void testSpecialFloatValues() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test special float values + BinaryProtocol.writeFloat(baos, Float.NaN); + BinaryProtocol.writeFloat(baos, Float.POSITIVE_INFINITY); + BinaryProtocol.writeFloat(baos, Float.NEGATIVE_INFINITY); + BinaryProtocol.writeFloat(baos, Float.MIN_VALUE); + BinaryProtocol.writeFloat(baos, Float.MAX_VALUE); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + assertTrue(Float.isNaN(BinaryProtocol.readFloat(bais))); + assertEquals(Float.POSITIVE_INFINITY, BinaryProtocol.readFloat(bais)); + assertEquals(Float.NEGATIVE_INFINITY, BinaryProtocol.readFloat(bais)); + assertEquals(Float.MIN_VALUE, BinaryProtocol.readFloat(bais)); + assertEquals(Float.MAX_VALUE, BinaryProtocol.readFloat(bais)); + } + + @Test + public void testSpecialDoubleValues() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test special double values + BinaryProtocol.writeDouble(baos, Double.NaN); + BinaryProtocol.writeDouble(baos, Double.POSITIVE_INFINITY); + BinaryProtocol.writeDouble(baos, Double.NEGATIVE_INFINITY); + BinaryProtocol.writeDouble(baos, Double.MIN_VALUE); + BinaryProtocol.writeDouble(baos, Double.MAX_VALUE); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + assertTrue(Double.isNaN(BinaryProtocol.readDouble(bais))); + assertEquals(Double.POSITIVE_INFINITY, BinaryProtocol.readDouble(bais)); + assertEquals(Double.NEGATIVE_INFINITY, BinaryProtocol.readDouble(bais)); + assertEquals(Double.MIN_VALUE, BinaryProtocol.readDouble(bais)); + assertEquals(Double.MAX_VALUE, BinaryProtocol.readDouble(bais)); + } + + // ===== SETTINGS COMMAND EDGE CASES ===== + + @Test + public void testSetSettingsCommandWithMixedTypes() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + Map settings = new HashMap<>(); + settings.put("stringValue", "test"); + settings.put("intValue", 42); + settings.put("longValue", 9876543210L); + settings.put("boolValue", true); + settings.put("floatValue", 3.14f); + settings.put("doubleValue", 2.71828); + settings.put("nullValue", null); + + BinarySetSettingsCommand original = new BinarySetSettingsCommand(settings); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinarySetSettingsCommand); + BinarySetSettingsCommand settingsCommand = (BinarySetSettingsCommand) readCommand; + Map readSettings = settingsCommand.getParams(); + + assertEquals("test", readSettings.get("stringValue")); + assertEquals(42, readSettings.get("intValue")); + assertEquals(9876543210L, readSettings.get("longValue")); + assertEquals(true, readSettings.get("boolValue")); + assertEquals(3.14f, ((Number) readSettings.get("floatValue")).floatValue(), 0.001); + assertEquals(2.71828, ((Number) readSettings.get("doubleValue")).doubleValue(), 0.00001); + assertNull(readSettings.get("nullValue")); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolPerformanceTest.java b/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolPerformanceTest.java new file mode 100644 index 000000000..9001ac095 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolPerformanceTest.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm.v2; + +import io.btrace.core.comm.Command; +import io.btrace.core.comm.InstrumentCommand; +import io.btrace.core.comm.MessageCommand; +import io.btrace.core.comm.WireIO; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.Test; + +/** + * Performance tests comparing the binary protocol to Java serialization. This is not included in + * the regular test suite to avoid slowing down normal builds. + */ +public class BinaryProtocolPerformanceTest { + + private static final int ITERATIONS = 10000; + private static final byte[] SAMPLE_CODE = new byte[1024]; // 1KB of code + private static final String LARGE_MESSAGE = generateLargeMessage(10 * 1024); // 10KB message + + static { + // Initialize sample code with random data + for (int i = 0; i < SAMPLE_CODE.length; i++) { + SAMPLE_CODE[i] = (byte) (Math.random() * 256); + } + } + + private static String generateLargeMessage(int size) { + StringBuilder sb = new StringBuilder(size); + for (int i = 0; i < size; i++) { + sb.append((char) ('a' + (i % 26))); + } + return sb.toString(); + } + + /** + * This test compares the performance of binary protocol vs Java serialization for the + * InstrumentCommand, which contains bytecode and arguments. + */ + @Test + public void testInstrumentCommandPerformance() throws IOException, ClassNotFoundException { + // Create test data + Map args = new HashMap<>(); + args.put("className", "com.example.TestClass"); + args.put("methodName", "testMethod"); + args.put("probeId", "12345"); + + // Binary protocol + long binaryStartTime = System.nanoTime(); + long binaryTotalSize = 0; + + for (int i = 0; i < ITERATIONS; i++) { + // Serialize + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryCommand cmd = new BinaryInstrumentCommand(SAMPLE_CODE, args); + BinaryWireIO.write(baos, cmd); + byte[] serialized = baos.toByteArray(); + binaryTotalSize += serialized.length; + + // Deserialize + ByteArrayInputStream bais = new ByteArrayInputStream(serialized); + BinaryCommand deserialized = BinaryWireIO.read(bais); + } + + long binaryEndTime = System.nanoTime(); + long binaryDuration = binaryEndTime - binaryStartTime; + + // Java serialization + long javaStartTime = System.nanoTime(); + long javaTotalSize = 0; + + for (int i = 0; i < ITERATIONS; i++) { + // Serialize + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + Command cmd = new InstrumentCommand(SAMPLE_CODE, args); + WireIO.write(oos, cmd); + oos.close(); + byte[] serialized = baos.toByteArray(); + javaTotalSize += serialized.length; + + // Deserialize + ByteArrayInputStream bais = new ByteArrayInputStream(serialized); + ObjectInputStream ois = new ObjectInputStream(bais); + Command deserialized = WireIO.read(ois); + ois.close(); + } + + long javaEndTime = System.nanoTime(); + long javaDuration = javaEndTime - javaStartTime; + + // Print results + System.out.println("InstrumentCommand Performance Test Results:"); + System.out.println(" Binary Protocol:"); + System.out.println(" Time: " + (binaryDuration / 1_000_000) + " ms"); + System.out.println(" Avg Size: " + (binaryTotalSize / ITERATIONS) + " bytes"); + System.out.println(" Java Serialization:"); + System.out.println(" Time: " + (javaDuration / 1_000_000) + " ms"); + System.out.println(" Avg Size: " + (javaTotalSize / ITERATIONS) + " bytes"); + System.out.println(" Improvement:"); + System.out.println(" Time: " + (javaDuration / (double) binaryDuration) + "x faster"); + System.out.println(" Size: " + (javaTotalSize / (double) binaryTotalSize) + "x smaller"); + } + + /** + * This test compares the performance of binary protocol vs Java serialization for the + * MessageCommand with compression. + */ + @Test + public void testMessageCommandPerformance() throws IOException, ClassNotFoundException { + // Binary protocol + long binaryStartTime = System.nanoTime(); + long binaryTotalSize = 0; + + for (int i = 0; i < ITERATIONS; i++) { + // Serialize + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BinaryCommand cmd = new BinaryMessageCommand(LARGE_MESSAGE, true); + BinaryWireIO.write(baos, cmd); + byte[] serialized = baos.toByteArray(); + binaryTotalSize += serialized.length; + + // Deserialize + ByteArrayInputStream bais = new ByteArrayInputStream(serialized); + BinaryCommand deserialized = BinaryWireIO.read(bais); + } + + long binaryEndTime = System.nanoTime(); + long binaryDuration = binaryEndTime - binaryStartTime; + + // Java serialization + long javaStartTime = System.nanoTime(); + long javaTotalSize = 0; + + for (int i = 0; i < ITERATIONS; i++) { + // Serialize + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(baos); + Command cmd = new MessageCommand(LARGE_MESSAGE); + WireIO.write(oos, cmd); + oos.close(); + byte[] serialized = baos.toByteArray(); + javaTotalSize += serialized.length; + + // Deserialize + ByteArrayInputStream bais = new ByteArrayInputStream(serialized); + ObjectInputStream ois = new ObjectInputStream(bais); + Command deserialized = WireIO.read(ois); + ois.close(); + } + + long javaEndTime = System.nanoTime(); + long javaDuration = javaEndTime - javaStartTime; + + // Print results + System.out.println("MessageCommand Performance Test Results:"); + System.out.println(" Binary Protocol (with compression):"); + System.out.println(" Time: " + (binaryDuration / 1_000_000) + " ms"); + System.out.println(" Avg Size: " + (binaryTotalSize / ITERATIONS) + " bytes"); + System.out.println(" Java Serialization:"); + System.out.println(" Time: " + (javaDuration / 1_000_000) + " ms"); + System.out.println(" Avg Size: " + (javaTotalSize / ITERATIONS) + " bytes"); + System.out.println(" Improvement:"); + System.out.println(" Time: " + (javaDuration / (double) binaryDuration) + "x faster"); + System.out.println(" Size: " + (javaTotalSize / (double) binaryTotalSize) + "x smaller"); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolTest.java b/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolTest.java new file mode 100644 index 000000000..e282b4408 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/comm/v2/BinaryProtocolTest.java @@ -0,0 +1,657 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.comm.v2; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import io.btrace.core.ArgsMap; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; + +/** Tests for the binary protocol implementation. */ +public class BinaryProtocolTest { + + @Test + public void testBinaryProtocolBasicTypes() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Write test data + BinaryProtocol.writeByte(baos, (byte) 123); + BinaryProtocol.writeInt(baos, 42); + BinaryProtocol.writeLong(baos, 9876543210L); + BinaryProtocol.writeFloat(baos, 3.14f); + BinaryProtocol.writeDouble(baos, 2.71828); + BinaryProtocol.writeBoolean(baos, true); + BinaryProtocol.writeString(baos, "Hello, World!"); + byte[] testArray = {1, 2, 3, 4, 5}; + BinaryProtocol.writeByteArray(baos, testArray); + + // Read test data + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + assertEquals((byte) 123, BinaryProtocol.readByte(bais)); + assertEquals(42, BinaryProtocol.readInt(bais)); + assertEquals(9876543210L, BinaryProtocol.readLong(bais)); + assertEquals(3.14f, BinaryProtocol.readFloat(bais)); + assertEquals(2.71828, BinaryProtocol.readDouble(bais)); + assertTrue(BinaryProtocol.readBoolean(bais)); + assertEquals("Hello, World!", BinaryProtocol.readString(bais)); + byte[] readArray = BinaryProtocol.readByteArray(bais); + assertArrayEquals(testArray, readArray); + } + + @Test + public void testBinaryExitCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryExitCommand original = new BinaryExitCommand(42); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryExitCommand); + BinaryExitCommand exitCommand = (BinaryExitCommand) readCommand; + assertEquals(42, exitCommand.getExitCode()); + assertEquals(BinaryCommand.EXIT, exitCommand.getType()); + assertTrue(exitCommand.isUrgent()); + } + + @Test + public void testBinaryMessageCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryMessageCommand original = new BinaryMessageCommand("Test message", true); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals("Test message", msgCommand.getMessage()); + assertEquals(BinaryCommand.MESSAGE, msgCommand.getType()); + assertEquals(original.isUrgent(), msgCommand.isUrgent()); + } + + @Test + public void testBinaryMessageCommandWithCompression() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create a large message that will trigger compression + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 2000; i++) { + sb.append("This is a test message that will be compressed. "); + } + String largeMessage = sb.toString(); + + // Create and write command + BinaryMessageCommand original = new BinaryMessageCommand(largeMessage, true); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryMessageCommand); + BinaryMessageCommand msgCommand = (BinaryMessageCommand) readCommand; + assertEquals(largeMessage, msgCommand.getMessage()); + } + + @Test + public void testBinaryInstrumentCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create test data + byte[] code = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + Map args = new HashMap<>(); + args.put("key1", "value1"); + args.put("key2", "value2"); + + // Create and write command + BinaryInstrumentCommand original = new BinaryInstrumentCommand(code, args); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryInstrumentCommand); + BinaryInstrumentCommand instrCommand = (BinaryInstrumentCommand) readCommand; + assertArrayEquals(code, instrCommand.getCode()); + ArgsMap readArgs = instrCommand.getArguments(); + assertEquals(2, readArgs.size()); + assertEquals("value1", readArgs.get("key1")); + assertEquals("value2", readArgs.get("key2")); + } + + @Test + public void testBinaryGridDataCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create test data + List columnNames = new ArrayList<>(); + columnNames.add("Column1"); + columnNames.add("Column2"); + columnNames.add("Column3"); + + List data = new ArrayList<>(); + data.add(new Object[] {"Row1Col1", 123, 3.14}); + data.add(new Object[] {"Row2Col1", 456, 2.71}); + data.add(new Object[] {"Row3Col1", 789, "Row3Col3"}); + + // Create and write command + BinaryGridDataCommand original = new BinaryGridDataCommand("TestGrid", columnNames, data); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryGridDataCommand); + BinaryGridDataCommand gridCommand = (BinaryGridDataCommand) readCommand; + assertEquals("TestGrid", gridCommand.getName()); + + List readColumnNames = gridCommand.getColumnNames(); + assertEquals(3, readColumnNames.size()); + assertEquals("Column1", readColumnNames.get(0)); + assertEquals("Column2", readColumnNames.get(1)); + assertEquals("Column3", readColumnNames.get(2)); + + List readData = gridCommand.getData(); + assertEquals(3, readData.size()); + assertEquals("Row1Col1", readData.get(0)[0]); + assertEquals(123, readData.get(0)[1]); + assertEquals(3.14, readData.get(0)[2]); + assertEquals("Row2Col1", readData.get(1)[0]); + assertEquals(456, readData.get(1)[1]); + assertEquals(2.71, readData.get(1)[2]); + assertEquals("Row3Col1", readData.get(2)[0]); + assertEquals(789, readData.get(2)[1]); + assertEquals("Row3Col3", readData.get(2)[2]); + } + + @Test + public void testCommandAdapter() throws IOException { + // Test command conversion from binary to original and back + BinaryExitCommand exitCmd = new BinaryExitCommand(42); + io.btrace.core.comm.Command originalCmd = CommandAdapter.toBtraceCommand(exitCmd); + assertEquals(io.btrace.core.comm.Command.EXIT, originalCmd.getType()); + + BinaryCommand convertedBack = CommandAdapter.toBinaryCommand(originalCmd); + assertTrue(convertedBack instanceof BinaryExitCommand); + assertEquals(42, ((BinaryExitCommand) convertedBack).getExitCode()); + } + + // Tests for the 13 previously untested command types + + @Test + public void testBinaryErrorCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryErrorCommand original = + new BinaryErrorCommand( + "java.lang.IllegalStateException", "Test error message", "stack-trace"); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryErrorCommand); + BinaryErrorCommand errorCommand = (BinaryErrorCommand) readCommand; + assertEquals("java.lang.IllegalStateException", errorCommand.getExceptionClass()); + assertEquals("Test error message", errorCommand.getMessage()); + assertEquals("stack-trace", errorCommand.getStackTrace()); + assertEquals(BinaryCommand.ERROR, errorCommand.getType()); + } + + @Test + public void testBinaryErrorCommandNullMessage() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command with null message + BinaryErrorCommand original = new BinaryErrorCommand("java.lang.RuntimeException", null, null); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryErrorCommand); + BinaryErrorCommand errorCommand = (BinaryErrorCommand) readCommand; + assertEquals("java.lang.RuntimeException", errorCommand.getExceptionClass()); + assertEquals(null, errorCommand.getMessage()); + assertEquals(null, errorCommand.getStackTrace()); + } + + @Test + public void testBinaryEventCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryEventCommand original = new BinaryEventCommand("test.event.fired"); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryEventCommand); + BinaryEventCommand eventCommand = (BinaryEventCommand) readCommand; + assertEquals("test.event.fired", eventCommand.getEvent()); + assertEquals(BinaryCommand.EVENT, eventCommand.getType()); + } + + @Test + public void testBinaryRenameCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryRenameCommand original = new BinaryRenameCommand("NewProbeName"); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryRenameCommand); + BinaryRenameCommand renameCommand = (BinaryRenameCommand) readCommand; + assertEquals("NewProbeName", renameCommand.getNewName()); + assertEquals(BinaryCommand.RENAME, renameCommand.getType()); + } + + @Test + public void testBinaryStatusCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test success status + BinaryStatusCommand original = new BinaryStatusCommand(1, true); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryStatusCommand); + BinaryStatusCommand statusCommand = (BinaryStatusCommand) readCommand; + assertEquals(1, statusCommand.getFlag()); + assertTrue(statusCommand.isSuccess()); + assertEquals(BinaryCommand.STATUS, statusCommand.getType()); + } + + @Test + public void testBinaryStatusCommandFailure() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test failure status + BinaryStatusCommand original = new BinaryStatusCommand(2, false); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryStatusCommand); + BinaryStatusCommand statusCommand = (BinaryStatusCommand) readCommand; + assertEquals(2, statusCommand.getFlag()); + assertTrue(!statusCommand.isSuccess()); + } + + @Test + public void testBinaryNumberMapDataCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create test data with various number types + Map data = new HashMap<>(); + data.put("intValue", 42); + data.put("longValue", 9876543210L); + data.put("floatValue", 3.14f); + data.put("doubleValue", 2.71828); + data.put("bigIntValue", new BigInteger("123456789012345678901234567890")); + data.put("bigDecValue", new BigDecimal("12345.67890123456789")); + + // Create and write command + BinaryNumberMapDataCommand original = new BinaryNumberMapDataCommand("TestNumberMap", data); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryNumberMapDataCommand); + BinaryNumberMapDataCommand mapCommand = (BinaryNumberMapDataCommand) readCommand; + assertEquals("TestNumberMap", mapCommand.getName()); + assertEquals(BinaryCommand.NUMBER_MAP, mapCommand.getType()); + + Map readData = mapCommand.getData(); + assertEquals(6, readData.size()); + assertEquals(42, readData.get("intValue").intValue()); + assertEquals(9876543210L, readData.get("longValue").longValue()); + assertEquals(3.14f, readData.get("floatValue").floatValue(), 0.001); + assertEquals(2.71828, readData.get("doubleValue").doubleValue(), 0.00001); + assertEquals(new BigInteger("123456789012345678901234567890"), readData.get("bigIntValue")); + assertEquals(new BigDecimal("12345.67890123456789"), readData.get("bigDecValue")); + } + + @Test + public void testBinaryNumberMapDataCommandEmpty() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command with empty map + Map data = new HashMap<>(); + BinaryNumberMapDataCommand original = new BinaryNumberMapDataCommand("EmptyMap", data); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryNumberMapDataCommand); + BinaryNumberMapDataCommand mapCommand = (BinaryNumberMapDataCommand) readCommand; + assertEquals("EmptyMap", mapCommand.getName()); + assertTrue(mapCommand.getData().isEmpty()); + } + + @Test + public void testBinaryStringMapDataCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create test data + Map data = new HashMap<>(); + data.put("key1", "value1"); + data.put("key2", "value2"); + data.put("key3", "value3"); + + // Create and write command + BinaryStringMapDataCommand original = new BinaryStringMapDataCommand("TestStringMap", data); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryStringMapDataCommand); + BinaryStringMapDataCommand mapCommand = (BinaryStringMapDataCommand) readCommand; + assertEquals("TestStringMap", mapCommand.getName()); + assertEquals(BinaryCommand.STRING_MAP, mapCommand.getType()); + + Map readData = mapCommand.getData(); + assertEquals(3, readData.size()); + assertEquals("value1", readData.get("key1")); + assertEquals("value2", readData.get("key2")); + assertEquals("value3", readData.get("key3")); + } + + @Test + public void testBinaryNumberDataCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test with Integer + BinaryNumberDataCommand original = new BinaryNumberDataCommand("TestInt", 42); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryNumberDataCommand); + BinaryNumberDataCommand numberCommand = (BinaryNumberDataCommand) readCommand; + assertEquals("TestInt", numberCommand.getName()); + assertEquals(42, numberCommand.getValue().intValue()); + assertEquals(BinaryCommand.NUMBER, numberCommand.getType()); + } + + @Test + public void testBinaryNumberDataCommandDouble() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test with Double + BinaryNumberDataCommand original = new BinaryNumberDataCommand("TestDouble", 3.14159); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryNumberDataCommand); + BinaryNumberDataCommand numberCommand = (BinaryNumberDataCommand) readCommand; + assertEquals("TestDouble", numberCommand.getName()); + assertEquals(3.14159, numberCommand.getValue().doubleValue(), 0.00001); + } + + @Test + public void testBinaryNumberDataCommandLong() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test with Long + BinaryNumberDataCommand original = new BinaryNumberDataCommand("TestLong", 9876543210L); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryNumberDataCommand); + BinaryNumberDataCommand numberCommand = (BinaryNumberDataCommand) readCommand; + assertEquals("TestLong", numberCommand.getName()); + assertEquals(9876543210L, numberCommand.getValue().longValue()); + } + + @Test + public void testBinaryNumberDataCommandBigDecimal() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Test with BigDecimal + BinaryNumberDataCommand original = + new BinaryNumberDataCommand("TestBigDecimal", new BigDecimal("12345.67890123456789")); + BinaryWireIO.write(baos, original); + + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + assertTrue(readCommand instanceof BinaryNumberDataCommand); + BinaryNumberDataCommand numberCommand = (BinaryNumberDataCommand) readCommand; + assertEquals("TestBigDecimal", numberCommand.getName()); + assertEquals(new BigDecimal("12345.67890123456789"), numberCommand.getValue()); + } + + @Test + public void testBinaryRetransformationStartNotification() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryRetransformationStartNotification original = + new BinaryRetransformationStartNotification(150); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryRetransformationStartNotification); + BinaryRetransformationStartNotification notification = + (BinaryRetransformationStartNotification) readCommand; + assertEquals(150, notification.getNumClasses()); + assertEquals(BinaryCommand.RETRANSFORMATION_START, notification.getType()); + } + + @Test + public void testBinaryRetransformClassNotification() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryRetransformClassNotification original = + new BinaryRetransformClassNotification("com.example.MyClass", 10, 150); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryRetransformClassNotification); + BinaryRetransformClassNotification notification = + (BinaryRetransformClassNotification) readCommand; + assertEquals("com.example.MyClass", notification.getClassName()); + assertEquals(10, notification.getIndex()); + assertEquals(150, notification.getTotal()); + assertEquals(BinaryCommand.RETRANSFORM_CLASS, notification.getType()); + } + + @Test + public void testBinarySetSettingsCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create test settings + Map settings = new HashMap<>(); + settings.put("debug", true); + settings.put("timeout", 5000); + settings.put("threshold", 1.5); + settings.put("name", "TestProbe"); + + // Create and write command + BinarySetSettingsCommand original = new BinarySetSettingsCommand(settings); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinarySetSettingsCommand); + BinarySetSettingsCommand settingsCommand = (BinarySetSettingsCommand) readCommand; + assertEquals(BinaryCommand.SET_PARAMS, settingsCommand.getType()); + + Map readSettings = settingsCommand.getParams(); + assertEquals(4, readSettings.size()); + assertEquals(true, readSettings.get("debug")); + assertEquals(5000, readSettings.get("timeout")); + assertEquals(1.5, ((Number) readSettings.get("threshold")).doubleValue(), 0.001); + assertEquals("TestProbe", readSettings.get("name")); + } + + @Test + public void testBinaryListProbesCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create test probe list + List probes = new ArrayList<>(); + probes.add("probe1"); + probes.add("probe2"); + probes.add("probe3"); + + // Create and write command + BinaryListProbesCommand original = new BinaryListProbesCommand(); + original.setProbes(probes); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryListProbesCommand); + BinaryListProbesCommand listCommand = (BinaryListProbesCommand) readCommand; + assertEquals(BinaryCommand.LIST_PROBES, listCommand.getType()); + + List readProbes = listCommand.getProbes(); + assertEquals(3, readProbes.size()); + assertEquals("probe1", readProbes.get(0)); + assertEquals("probe2", readProbes.get(1)); + assertEquals("probe3", readProbes.get(2)); + } + + @Test + public void testBinaryListProbesCommandEmpty() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command with empty list + BinaryListProbesCommand original = new BinaryListProbesCommand(); + original.setProbes(new ArrayList<>()); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryListProbesCommand); + BinaryListProbesCommand listCommand = (BinaryListProbesCommand) readCommand; + assertTrue(listCommand.getProbes().isEmpty()); + } + + @Test + public void testBinaryDisconnectCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryDisconnectCommand original = new BinaryDisconnectCommand("probe-12345"); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryDisconnectCommand); + BinaryDisconnectCommand disconnectCommand = (BinaryDisconnectCommand) readCommand; + assertEquals("probe-12345", disconnectCommand.getProbeId()); + assertEquals(BinaryCommand.DISCONNECT, disconnectCommand.getType()); + } + + @Test + public void testBinaryReconnectCommand() throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + // Create and write command + BinaryReconnectCommand original = new BinaryReconnectCommand("probe-67890"); + BinaryWireIO.write(baos, original); + + // Read command + ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); + BinaryCommand readCommand = BinaryWireIO.read(bais); + + // Verify command + assertTrue(readCommand instanceof BinaryReconnectCommand); + BinaryReconnectCommand reconnectCommand = (BinaryReconnectCommand) readCommand; + assertEquals("probe-67890", reconnectCommand.getProbeId()); + assertEquals(BinaryCommand.RECONNECT, reconnectCommand.getType()); + } +} diff --git a/btrace-core/src/test/java/io/btrace/core/extensions/ExternalTypeAnnotationTest.java b/btrace-core/src/test/java/io/btrace/core/extensions/ExternalTypeAnnotationTest.java new file mode 100644 index 000000000..15066b3de --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/core/extensions/ExternalTypeAnnotationTest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.core.extensions; + +import static org.junit.jupiter.api.Assertions.*; + +import java.lang.annotation.*; +import org.junit.jupiter.api.Test; + +class ExternalTypeAnnotationTest { + @ExternalType("com.example.App") + interface FakeApi { + @ExternalType.Static + Object create(String name); + + int counter(); + } + + @Test + void annotationValuePreserved() { + ExternalType a = FakeApi.class.getAnnotation(ExternalType.class); + assertNotNull(a); + assertEquals("com.example.App", a.value()); + } + + @Test + void staticAnnotationOnMethod() throws NoSuchMethodException { + assertNotNull( + FakeApi.class + .getDeclaredMethod("create", String.class) + .getAnnotation(ExternalType.Static.class)); + assertNull(FakeApi.class.getDeclaredMethod("counter").getAnnotation(ExternalType.Static.class)); + } + + @Test + void retentionIsRuntime() { + Retention r = ExternalType.class.getAnnotation(Retention.class); + assertEquals(RetentionPolicy.RUNTIME, r.value()); + } +} diff --git a/btrace-core/src/test/java/io/btrace/extension/ExtensionBridgeImplPolicyTest.java b/btrace-core/src/test/java/io/btrace/extension/ExtensionBridgeImplPolicyTest.java new file mode 100644 index 000000000..598b07a83 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/extension/ExtensionBridgeImplPolicyTest.java @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.extension; + +import static org.junit.jupiter.api.Assertions.*; + +import io.btrace.core.extensions.Permission; +import io.btrace.core.extensions.PermissionSet; +import io.btrace.extension.impl.ExtensionBridgeImpl; +import java.nio.file.Paths; +import java.util.Collections; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class ExtensionBridgeImplPolicyTest { + + private static final String EXT_ID_BASE = "test-ext"; + private static final String SERVICE_IFACE = "test.ext.Service"; // with ServiceLoader provider + private static final String SERVICE_IFACE2 = "test.ext2.Service2"; // conventional Impl only + + private static class DummyLoader extends ExtensionLoader { + final ExtensionDescriptorDTO desc; + boolean apiOnBoot; + boolean loaded; + + DummyLoader(ExtensionDescriptorDTO desc) { + this.desc = desc; + } + + @Override + public ExtensionDescriptorDTO findExtensionForService(String serviceClassName) { + return desc; + } + + @Override + public java.util.List discoverExtensions() { + return Collections.singletonList(desc); + } + + @Override + public java.util.Collection getAvailableExtensions() { + return Collections.singletonList(desc); + } + + @Override + public boolean ensureApiOnBootstrap(ExtensionDescriptorDTO descriptor) { + apiOnBoot = true; + return true; + } + + @Override + public boolean load(ExtensionDescriptorDTO descriptor) { + loaded = true; + return true; + } + } + + private ExtensionDescriptorDTO.Builder baseBuilder(String serviceFqcn, String extId) { + return new ExtensionDescriptorDTO.Builder() + .id(extId) + .version("1.0.0") + .name("Test") + .description("Test") + .jarPath(Paths.get("/tmp/test.jar")) + .services(Collections.singletonList(serviceFqcn)) + .requiredExtensions(Collections.emptyList()) + .repository(null) + .requiredPermissions(PermissionSet.empty()); + } + + @BeforeEach + void resetPolicy() { + PermissionPolicy p = PermissionPolicy.get(); + p.setAllowExtensionsCsv(""); + p.setDenyExtensionsCsv(""); + p.setAllowPrivileged(false); + } + + @Test + void denyListTriggersFallbackAndRegistersFailure() throws Exception { + String extId = EXT_ID_BASE + "-deny"; + PermissionPolicy.get().setDenyExtensionsCsv(extId); + ExtensionDescriptorDTO dto = baseBuilder(SERVICE_IFACE, extId).build(); + DummyLoader dl = new DummyLoader(dto); + ExtensionBridgeImpl bridge = new ExtensionBridgeImpl(dl); + + Class clz = bridge.getExtensionClass(SERVICE_IFACE); + assertNull( + clz, "Expected null when denied; serviceClass=" + SERVICE_IFACE + ", extId=" + extId); + assertTrue(dl.apiOnBoot, "API should be ensured on bootstrap; extId=" + extId); + assertFalse(dl.loaded, "Implementation must not be loaded when denied; extId=" + extId); + String reason = ExtensionRegistry.getFailedExtensions().get(extId); + assertEquals( + "Blocked by policy (denyExtensions)", + reason, + "Unexpected failure reason for extId=" + extId + ": " + reason); + } + + @Test + void privilegedWithoutAllowTriggersFallback() throws Exception { + String extId = EXT_ID_BASE + "-priv"; + PermissionSet perms = PermissionSet.of(Permission.THREADS); + ExtensionDescriptorDTO dto = + baseBuilder(SERVICE_IFACE, extId).requiredPermissions(perms).build(); + DummyLoader dl = new DummyLoader(dto); + ExtensionBridgeImpl bridge = new ExtensionBridgeImpl(dl); + + Class clz = bridge.getExtensionClass(SERVICE_IFACE); + assertNull(clz, "Expected null when privileged extension is not allowed; extId=" + extId); + assertTrue( + dl.apiOnBoot, "API should be ensured on bootstrap for privileged fallback; extId=" + extId); + assertFalse( + dl.loaded, + "Privileged implementation should not be loaded when not allowed; extId=" + extId); + String reason = ExtensionRegistry.getFailedExtensions().get(extId); + assertNotNull(reason, "Expected a failure reason to be recorded; extId=" + extId); + assertTrue( + reason.startsWith("Blocked privileged extension."), + "Unexpected failure reason for extId=" + extId + ": " + reason); + } + + @Test + void allowedLoadsAndFindsConventionalImpl() throws Exception { + // Allow privileged to ensure no policy block + PermissionPolicy.get().setAllowPrivileged(true); + String extId = EXT_ID_BASE + "-conv"; + ExtensionDescriptorDTO dto = baseBuilder(SERVICE_IFACE2, extId).build(); + DummyLoader dl = new DummyLoader(dto); + // Use current classloader which has test classes + dto.setClassLoader(this.getClass().getClassLoader()); + ExtensionBridgeImpl bridge = new ExtensionBridgeImpl(dl); + + // Resolve conventional Impl for SERVICE_IFACE2 + Class impl2 = bridge.getExtensionClass(SERVICE_IFACE2); + assertNotNull( + impl2, + "Expected conventional Impl to be resolved; service=" + + SERVICE_IFACE2 + + ", extId=" + + extId + + ", loaded=" + + dl.loaded); + assertEquals( + "test.ext2.Service2Impl", + impl2.getName(), + "Resolved class name mismatch; got=" + (impl2 != null ? impl2.getName() : "null")); + } + + @Test + void allowedLoadsAndFindsServiceLoaderProvider() throws Exception { + PermissionPolicy.get().setAllowPrivileged(true); + String extId = EXT_ID_BASE + "-spi"; + ExtensionDescriptorDTO dto = baseBuilder(SERVICE_IFACE, extId).build(); + DummyLoader dl = new DummyLoader(dto); + dto.setClassLoader(this.getClass().getClassLoader()); + ExtensionBridgeImpl bridge = new ExtensionBridgeImpl(dl); + + Class impl = bridge.getExtensionClass(SERVICE_IFACE); + assertNotNull( + impl, + "Expected SPI provider to be resolved; service=" + + SERVICE_IFACE + + ", extId=" + + extId + + ", loaded=" + + dl.loaded); + assertEquals( + "test.ext.SpiImpl", + impl.getName(), + "SPI provider class name mismatch: " + (impl != null ? impl.getName() : "null")); + } +} diff --git a/btrace-core/src/test/java/io/btrace/extension/ExtensionLoaderImplConcurrencyTest.java b/btrace-core/src/test/java/io/btrace/extension/ExtensionLoaderImplConcurrencyTest.java new file mode 100644 index 000000000..876a88105 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/extension/ExtensionLoaderImplConcurrencyTest.java @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.extension; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import io.btrace.core.extensions.PermissionSet; +import io.btrace.extension.impl.ExtensionConfig; +import io.btrace.extension.impl.ExtensionLoaderImpl; +import java.io.IOException; +import java.lang.instrument.ClassDefinition; +import java.lang.instrument.ClassFileTransformer; +import java.lang.instrument.Instrumentation; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.jar.Attributes; +import java.util.jar.JarFile; +import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +class ExtensionLoaderImplConcurrencyTest { + @TempDir Path tempDir; + + @Test + void loadIsIdempotentUnderConcurrency() throws Exception { + Path extDir = tempDir.resolve("test-ext"); + Files.createDirectories(extDir); + + String implName = "test-ext-impl.jar"; + Path apiJar = extDir.resolve("test-ext-api.jar"); + Path implJar = extDir.resolve(implName); + writeJar(apiJar, implName); + writeJar(implJar, null); + + DummyInstrumentation instrumentation = new DummyInstrumentation(); + ExtensionLoaderImpl loader = + new ExtensionLoaderImpl( + Collections.emptyList(), + getClass().getClassLoader(), + ExtensionConfig.createDefault(), + instrumentation, + "3.0.0"); + + ExtensionDescriptorDTO descriptor = + new ExtensionDescriptorDTO.Builder() + .id("test-ext") + .version("1.0.0") + .name("Test") + .description("Test") + .jarPath(extDir) + .services(List.of()) + .requiredExtensions(List.of()) + .repository(null) + .requiredPermissions(PermissionSet.empty()) + .build(); + + int threads = 8; + CountDownLatch start = new CountDownLatch(1); + CountDownLatch done = new CountDownLatch(threads); + AtomicInteger success = new AtomicInteger(); + ExecutorService executor = Executors.newFixedThreadPool(threads); + try { + for (int i = 0; i < threads; i++) { + executor.execute( + () -> { + try { + start.await(); + if (loader.load(descriptor)) { + success.incrementAndGet(); + } + } catch (InterruptedException ignored) { + Thread.currentThread().interrupt(); + } finally { + done.countDown(); + } + }); + } + start.countDown(); + assertTrue(done.await(5, TimeUnit.SECONDS), "Load operations did not finish in time"); + } finally { + executor.shutdownNow(); + } + + assertEquals(threads, success.get()); + assertEquals(1, instrumentation.appendCount.get()); + assertTrue(descriptor.isLoaded()); + assertNotNull(descriptor.getClassLoader()); + assertEquals(1, loader.getLoadedExtensions().size()); + } + + private static void writeJar(Path jarPath, String implJarName) throws IOException { + Manifest manifest = new Manifest(); + Attributes attrs = manifest.getMainAttributes(); + attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0"); + if (implJarName != null) { + attrs.putValue("BTrace-Extension-Impl", implJarName); + } + try (JarOutputStream jos = new JarOutputStream(Files.newOutputStream(jarPath), manifest)) { + // empty jar is sufficient for loader tests + } + } + + private static final class DummyInstrumentation implements Instrumentation { + private final AtomicInteger appendCount = new AtomicInteger(); + + @Override + public void addTransformer(ClassFileTransformer transformer, boolean canRetransform) {} + + @Override + public void addTransformer(ClassFileTransformer transformer) {} + + @Override + public boolean removeTransformer(ClassFileTransformer transformer) { + return false; + } + + @Override + public boolean isRetransformClassesSupported() { + return false; + } + + @Override + public void retransformClasses(Class... classes) {} + + @Override + public boolean isRedefineClassesSupported() { + return false; + } + + @Override + public void redefineClasses(ClassDefinition... definitions) {} + + @Override + public boolean isModifiableClass(Class theClass) { + return false; + } + + @Override + public Class[] getAllLoadedClasses() { + return new Class[0]; + } + + @Override + public Class[] getInitiatedClasses(ClassLoader loader) { + return new Class[0]; + } + + @Override + public long getObjectSize(Object objectToSize) { + return 0L; + } + + @Override + public void appendToBootstrapClassLoaderSearch(JarFile jarfile) { + appendCount.incrementAndGet(); + } + + @Override + public void appendToSystemClassLoaderSearch(JarFile jarfile) {} + + @Override + public boolean isNativeMethodPrefixSupported() { + return false; + } + + @Override + public void setNativeMethodPrefix(ClassFileTransformer transformer, String prefix) {} + + @Override + public void redefineModule( + Module module, + Set extraReads, + Map> extraExports, + Map> extraOpens, + Set> extraUses, + Map, List>> extraProvides) {} + + @Override + public boolean isModifiableModule(Module module) { + return false; + } + } +} diff --git a/btrace-core/src/test/java/io/btrace/extension/impl/BTraceVersionRangeTest.java b/btrace-core/src/test/java/io/btrace/extension/impl/BTraceVersionRangeTest.java new file mode 100644 index 000000000..2f9855bfc --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/extension/impl/BTraceVersionRangeTest.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.extension.impl; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class BTraceVersionRangeTest { + + // --- range-format requirements (X.Y+) --- + + @Test + void exactMajorMinorRange_satisfiedByEqualVersion() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("3.0.0")); + } + + @Test + void exactMajorMinorRange_satisfiedByHigherPatch() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("3.0.5")); + } + + @Test + void exactMajorMinorRange_satisfiedByHigherMinor() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("3.1.0")); + } + + @Test + void exactMajorMinorRange_satisfiedByHigherMajor() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("4.0.0")); + } + + @Test + void exactMajorMinorRange_notSatisfiedByLowerMinor() { + assertFalse(BTraceVersionRange.parse("3.1+").satisfiedBy("3.0.9")); + } + + @Test + void exactMajorMinorRange_notSatisfiedByLowerMajor() { + assertFalse(BTraceVersionRange.parse("3.0+").satisfiedBy("2.9.9")); + } + + // --- plain version requirements (no +) --- + + @Test + void plainVersion_treatedAsMinimum() { + assertTrue(BTraceVersionRange.parse("3.0.0").satisfiedBy("3.0.0")); + } + + @Test + void plainVersion_satisfiedByHigherPatch() { + assertTrue(BTraceVersionRange.parse("3.0.0").satisfiedBy("3.0.1")); + } + + @Test + void plainVersion_notSatisfiedByLower() { + assertFalse(BTraceVersionRange.parse("3.1.0").satisfiedBy("3.0.9")); + } + + // --- qualifier stripping in actual version --- + + @Test + void snapshotQualifier_stripped() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("3.0.0-SNAPSHOT")); + } + + @Test + void rcQualifier_stripped() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("3.1.0-RC1")); + } + + // --- unknown / empty actual version bypasses check --- + + @Test + void unknownActualVersion_alwaysSatisfies() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("unknown")); + } + + @Test + void emptyActualVersion_alwaysSatisfies() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy("")); + } + + @Test + void nullActualVersion_alwaysSatisfies() { + assertTrue(BTraceVersionRange.parse("3.0+").satisfiedBy(null)); + } + + // --- empty / null requirement imposes no constraint --- + + @Test + void emptyRequirement_alwaysSatisfied() { + assertTrue(BTraceVersionRange.parse("").satisfiedBy("2.0.0")); + } + + @Test + void nullRequirement_alwaysSatisfied() { + assertTrue(BTraceVersionRange.parse(null).satisfiedBy("2.0.0")); + } + + // --- three-part range (X.Y.Z+) --- + + @Test + void threePartRange_satisfiedByEqualVersion() { + assertTrue(BTraceVersionRange.parse("3.0.1+").satisfiedBy("3.0.1")); + } + + @Test + void threePartRange_notSatisfiedBySmallerPatch() { + assertFalse(BTraceVersionRange.parse("3.0.1+").satisfiedBy("3.0.0")); + } +} diff --git a/btrace-core/src/test/java/io/btrace/extension/impl/SecurityValidationTest.java b/btrace-core/src/test/java/io/btrace/extension/impl/SecurityValidationTest.java new file mode 100644 index 000000000..8c568fb4c --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/extension/impl/SecurityValidationTest.java @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.extension.impl; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +/** Tests for security validation methods in extension loading. */ +class SecurityValidationTest { + + @Nested + @DisplayName("Extension ID validation") + class ExtensionIdValidationTests { + + @Test + @DisplayName("accepts valid extension IDs") + void acceptsValidIds() { + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("btrace-spark")); + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("btrace-hadoop")); + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("my-extension-1.0")); + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("ext123")); + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("my.extension")); + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("my_extension")); + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("MyExtension")); + } + + @Test + @DisplayName("rejects null and empty IDs") + void rejectsNullAndEmpty() { + assertFalse(EmbeddedExtensionRepository.isValidExtensionId(null)); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId(" ")); + } + + @Test + @DisplayName("rejects path traversal with forward slash") + void rejectsForwardSlash() { + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("../etc/passwd")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("foo/bar")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("/etc/passwd")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext/../../etc")); + } + + @Test + @DisplayName("rejects path traversal with backslash") + void rejectsBackslash() { + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("..\\windows\\system32")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("foo\\bar")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("C:\\Windows")); + } + + @Test + @DisplayName("rejects parent directory references") + void rejectsParentDirectory() { + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("..")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("foo..bar")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("..ext")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext..")); + } + + @Test + @DisplayName("rejects IDs starting with special characters") + void rejectsSpecialStart() { + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("-extension")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId(".extension")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("_extension")); + // Note: IDs starting with digits are allowed (valid Maven artifact IDs) + assertTrue(EmbeddedExtensionRepository.isValidExtensionId("1extension")); + } + + @Test + @DisplayName("rejects IDs with invalid characters") + void rejectsInvalidCharacters() { + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext@name")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext#name")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext name")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext$name")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext;name")); + assertFalse(EmbeddedExtensionRepository.isValidExtensionId("ext`name")); + } + } + + @Nested + @DisplayName("Class name validation") + class ClassNameValidationTests { + + @Test + @DisplayName("accepts valid class names") + void acceptsValidClassNames() { + assertTrue(EmbeddedExtensionRepository.isValidClassName("com.example.MyClass")); + assertTrue(EmbeddedExtensionRepository.isValidClassName("MyClass")); + assertTrue(EmbeddedExtensionRepository.isValidClassName("io.btrace.Extension")); + assertTrue(EmbeddedExtensionRepository.isValidClassName("com.example.Outer$Inner")); + assertTrue(EmbeddedExtensionRepository.isValidClassName("_MyClass")); + assertTrue(EmbeddedExtensionRepository.isValidClassName("Class123")); + } + + @Test + @DisplayName("rejects null and empty class names") + void rejectsNullAndEmpty() { + assertFalse(EmbeddedExtensionRepository.isValidClassName(null)); + assertFalse(EmbeddedExtensionRepository.isValidClassName("")); + } + + @Test + @DisplayName("rejects invalid class names") + void rejectsInvalidNames() { + assertFalse(EmbeddedExtensionRepository.isValidClassName("123Class")); // starts with number + assertFalse(EmbeddedExtensionRepository.isValidClassName("-MyClass")); // starts with hyphen + assertFalse(EmbeddedExtensionRepository.isValidClassName("com..example")); // double dot + assertFalse(EmbeddedExtensionRepository.isValidClassName(".com.example")); // starts with dot + assertFalse(EmbeddedExtensionRepository.isValidClassName("com.example.")); // ends with dot + } + + @Test + @DisplayName("rejects class names with special characters") + void rejectsSpecialCharacters() { + assertFalse( + EmbeddedExtensionRepository.isValidClassName("com/example/Class")); // path separator + assertFalse(EmbeddedExtensionRepository.isValidClassName("com\\example\\Class")); // backslash + assertFalse(EmbeddedExtensionRepository.isValidClassName("com.example@Class")); // at sign + assertFalse(EmbeddedExtensionRepository.isValidClassName("com.example#Class")); // hash + } + + @Test + @DisplayName("rejects potential code injection") + void rejectsCodeInjection() { + assertFalse(EmbeddedExtensionRepository.isValidClassName("Class;System.exit(0)")); + assertFalse(EmbeddedExtensionRepository.isValidClassName("Class\nSystem.exit(0)")); + } + } + + @Nested + @DisplayName("Bytecode validation") + class BytecodeValidationTests { + + @Test + @DisplayName("ClassDataLoader validates bytecode magic number") + void classDataLoaderValidatesMagic() { + // This test documents the expected behavior - ClassDataLoader should reject + // non-class files. Actual integration tests would require mocking the resource loader. + + // Valid class file starts with CAFEBABE + byte[] validMagic = + new byte[] { + (byte) 0xCA, + (byte) 0xFE, + (byte) 0xBA, + (byte) 0xBE, + 0x00, + 0x00, + 0x00, + 0x34, // version + 0x00, + 0x01 // constant_pool_count + }; + assertTrue(validMagic.length >= 10); + assertTrue(validMagic[0] == (byte) 0xCA); + assertTrue(validMagic[1] == (byte) 0xFE); + assertTrue(validMagic[2] == (byte) 0xBA); + assertTrue(validMagic[3] == (byte) 0xBE); + + // Invalid: wrong magic + byte[] invalidMagic = + new byte[] { + (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x01 + }; + assertFalse(invalidMagic[0] == (byte) 0xCA); + } + } +} diff --git a/btrace-core/src/test/java/io/btrace/extension/processor/CompileTestHarness.java b/btrace-core/src/test/java/io/btrace/extension/processor/CompileTestHarness.java new file mode 100644 index 000000000..d083778b7 --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/extension/processor/CompileTestHarness.java @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.extension.processor; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.OutputStream; +import java.io.StringWriter; +import java.io.Writer; +import java.net.URI; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.stream.Collectors; +import javax.tools.Diagnostic; +import javax.tools.DiagnosticCollector; +import javax.tools.FileObject; +import javax.tools.ForwardingJavaFileManager; +import javax.tools.JavaCompiler; +import javax.tools.JavaFileManager; +import javax.tools.JavaFileObject; +import javax.tools.SimpleJavaFileObject; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; + +/** + * In-memory javac harness. Feeds the processor a set of named source strings and returns the + * generated source files + diagnostics. + */ +public final class CompileTestHarness { + public static final class Result { + public final boolean success; + public final Map generatedSources; + public final List> diagnostics; + + Result( + boolean success, + Map generated, + List> diags) { + this.success = success; + this.generatedSources = generated; + this.diagnostics = diags; + } + + public String errors() { + return formatErrors(diagnostics); + } + } + + public static Result compile(Map sources) throws IOException { + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + if (compiler == null) { + throw new IllegalStateException("No JavaCompiler available — run tests on a JDK, not JRE"); + } + DiagnosticCollector diags = new DiagnosticCollector<>(); + StandardJavaFileManager std = + compiler.getStandardFileManager(diags, Locale.ROOT, StandardCharsets.UTF_8); + InMemoryFileManager mgr = new InMemoryFileManager(std); + + List units = new ArrayList<>(); + for (Map.Entry e : sources.entrySet()) { + units.add(new StringSource(e.getKey(), e.getValue())); + } + + String cp = System.getProperty("java.class.path"); + List options = + Arrays.asList("-classpath", cp, "-processor", ExternalTypeProcessor.class.getName()); + + JavaCompiler.CompilationTask task = compiler.getTask(null, mgr, diags, options, null, units); + boolean ok = task.call(); + return new Result(ok, mgr.generatedSources(), diags.getDiagnostics()); + } + + public static final class RunnableResult { + public final boolean success; + public final List> diagnostics; + public final ClassLoader loader; + + RunnableResult( + boolean success, List> diags, ClassLoader loader) { + this.success = success; + this.diagnostics = diags; + this.loader = loader; + } + + public String errors() { + return formatErrors(diagnostics); + } + } + + static String formatErrors(List> diags) { + return diags.stream() + .filter(d -> d.getKind() == Diagnostic.Kind.ERROR) + .map(Object::toString) + .collect(Collectors.joining("\n")); + } + + public static RunnableResult compileAndLoad(Map sources) throws IOException { + JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); + if (compiler == null) { + throw new IllegalStateException("No JavaCompiler available — run tests on a JDK, not JRE"); + } + DiagnosticCollector diags = new DiagnosticCollector<>(); + StandardJavaFileManager std = + compiler.getStandardFileManager(diags, Locale.ROOT, StandardCharsets.UTF_8); + InMemoryFileManager mgr = new InMemoryFileManager(std); + + List units = new ArrayList<>(); + for (Map.Entry e : sources.entrySet()) { + units.add(new StringSource(e.getKey(), e.getValue())); + } + List options = + Arrays.asList( + "-classpath", System.getProperty("java.class.path"), + "-processor", ExternalTypeProcessor.class.getName()); + + JavaCompiler.CompilationTask task = compiler.getTask(null, mgr, diags, options, null, units); + boolean ok = task.call(); + if (!ok) return new RunnableResult(false, diags.getDiagnostics(), null); + + ClassLoader loader = + new ClassLoader(CompileTestHarness.class.getClassLoader()) { + @Override + protected Class findClass(String name) throws ClassNotFoundException { + ByteArrayOutputStream baos = mgr.bytes.get(name); + if (baos == null) throw new ClassNotFoundException(name); + byte[] b = baos.toByteArray(); + return defineClass(name, b, 0, b.length); + } + }; + return new RunnableResult(true, diags.getDiagnostics(), loader); + } + + static final class StringSource extends SimpleJavaFileObject { + private final String src; + + StringSource(String fqn, String src) { + super(URI.create("string:///" + fqn.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE); + this.src = src; + } + + @Override + public CharSequence getCharContent(boolean ignoreEncodingErrors) { + return src; + } + } + + static final class InMemoryFileManager extends ForwardingJavaFileManager { + final Map bytes = new LinkedHashMap<>(); + private final Map sources = new LinkedHashMap<>(); + + InMemoryFileManager(JavaFileManager m) { + super(m); + } + + @Override + public JavaFileObject getJavaFileForOutput( + Location location, String className, JavaFileObject.Kind kind, FileObject sibling) { + if (kind == JavaFileObject.Kind.SOURCE) { + return new SimpleJavaFileObject( + URI.create("mem:///" + className.replace('.', '/') + kind.extension), kind) { + private String content = null; + + @Override + public CharSequence getCharContent(boolean ignoreEncodingErrors) { + return content != null ? content : ""; + } + + @Override + public Writer openWriter() { + StringWriter sw = new StringWriter(); + return new Writer() { + @Override + public void write(char[] cbuf, int off, int len) { + sw.write(cbuf, off, len); + } + + @Override + public void flush() {} + + @Override + public void close() { + content = sw.toString(); + sources.put(className, content); + } + }; + } + }; + } + ByteArrayOutputStream baos = + bytes.computeIfAbsent(className, k -> new ByteArrayOutputStream()); + return new SimpleJavaFileObject( + URI.create("mem:///" + className.replace('.', '/') + kind.extension), kind) { + @Override + public OutputStream openOutputStream() { + return baos; + } + }; + } + + Map generatedSources() { + return sources; + } + } + + private CompileTestHarness() {} +} diff --git a/btrace-core/src/test/java/io/btrace/extension/processor/ExternalTypeProcessorTest.java b/btrace-core/src/test/java/io/btrace/extension/processor/ExternalTypeProcessorTest.java new file mode 100644 index 000000000..26f02061b --- /dev/null +++ b/btrace-core/src/test/java/io/btrace/extension/processor/ExternalTypeProcessorTest.java @@ -0,0 +1,280 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.extension.processor; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.LinkedHashMap; +import java.util.Map; +import org.junit.jupiter.api.Test; + +class ExternalTypeProcessorTest { + + @Test + void generatesAdapterForAnnotatedInterface() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.JobStart", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.app.Real\")\n" + + "public interface JobStart {\n" + + " int jobId();\n" + + "}\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertTrue(r.success, "compile failed:\n" + r.errors()); + assertTrue( + r.generatedSources.containsKey("com.example.JobStart$Ext"), + "expected adapter com.example.JobStart$Ext; generated: " + r.generatedSources.keySet()); + } + + @Test + void generatedAdapterContainsDispatchersForEachMethod() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.JobStart", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.app.Real\")\n" + + "public interface JobStart {\n" + + " int jobId();\n" + + " long time();\n" + + " @ExternalType.Static\n" + + " Object create(String name);\n" + + "}\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertTrue(r.success, r.errors()); + String adapter = r.generatedSources.get("com.example.JobStart$Ext"); + assertNotNull(adapter); + assertTrue(adapter.contains("public static int jobId("), adapter); + assertTrue(adapter.contains("public static long time("), adapter); + assertTrue(adapter.contains("public static java.lang.Object create("), adapter); + } + + @Test + void virtualDispatcherUsesLazyMethodHandle() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.JobStart", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.app.Real\")\n" + + "public interface JobStart {\n" + + " int jobId();\n" + + "}\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertTrue(r.success, r.errors()); + String adapter = r.generatedSources.get("com.example.JobStart$Ext"); + assertTrue(adapter.contains("private static volatile java.lang.invoke.MethodHandle"), adapter); + assertTrue(adapter.contains("findVirtual"), adapter); + assertTrue(adapter.contains("self.getClass().getClassLoader()"), adapter); + assertTrue(adapter.contains("(int)"), adapter); + } + + @Test + void staticDispatcherUsesTccl() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.SparkUtils", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.app.SparkUtils\")\n" + + "public interface SparkUtils {\n" + + " @ExternalType.Static\n" + + " java.lang.String version();\n" + + "}\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertTrue(r.success, r.errors()); + String adapter = r.generatedSources.get("com.example.SparkUtils$Ext"); + assertTrue(adapter.contains("findStatic"), adapter); + assertTrue(adapter.contains("Thread.currentThread().getContextClassLoader()"), adapter); + assertFalse( + adapter.contains("java.lang.Object self"), + "static dispatcher must not take a receiver parameter: " + adapter); + } + + @Test + void generatedAdapterInvokesRealMethod() throws Exception { + // The "external" class is just a regular class in the compile unit. + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.target.Counter", + "" + + "package com.example.target;\n" + + "public class Counter {\n" + + " private final int v;\n" + + " public Counter(int v) { this.v = v; }\n" + + " public int value() { return v; }\n" + + "}\n"); + sources.put( + "com.example.adapter.CounterApi", + "" + + "package com.example.adapter;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.target.Counter\")\n" + + "public interface CounterApi {\n" + + " int value();\n" + + "}\n"); + + CompileTestHarness.RunnableResult r = CompileTestHarness.compileAndLoad(sources); + assertTrue(r.success, r.errors()); + + Class counter = r.loader.loadClass("com.example.target.Counter"); + Object instance = counter.getConstructor(int.class).newInstance(42); + + Class adapter = r.loader.loadClass("com.example.adapter.CounterApi$Ext"); + java.lang.reflect.Method m = adapter.getMethod("value", Object.class); + int got = (int) m.invoke(null, instance); + assertEquals(42, got); + } + + @Test + void staticDispatcherResolvesViaContextClassLoader() throws Exception { + // The "external" class lives only in the in-memory loader; static dispatch must + // use the TCCL (set here) to find it at runtime. + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.target.Greeter", + "" + + "package com.example.target;\n" + + "public class Greeter {\n" + + " public static String hello() { return \"hello\"; }\n" + + "}\n"); + sources.put( + "com.example.adapter.GreeterApi", + "" + + "package com.example.adapter;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.target.Greeter\")\n" + + "public interface GreeterApi {\n" + + " @ExternalType.Static\n" + + " java.lang.String hello();\n" + + "}\n"); + + CompileTestHarness.RunnableResult r = CompileTestHarness.compileAndLoad(sources); + assertTrue(r.success, r.errors()); + + ClassLoader saved = Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(r.loader); + Class adapter = r.loader.loadClass("com.example.adapter.GreeterApi$Ext"); + java.lang.reflect.Method m = adapter.getMethod("hello"); + assertEquals("hello", m.invoke(null)); + } finally { + Thread.currentThread().setContextClassLoader(saved); + } + } + + @Test + void staticDispatcherFallsBackToSystemLoaderWhenTcclNull() throws Exception { + // Simulates a bootstrap/JVM-internal thread where TCCL is null. + // The adapter must fall back to ClassLoader.getSystemClassLoader() instead of throwing NPE. + // Uses java.lang.System, which is always on the boot/system classloader. + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.SysApi", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"java.lang.System\")\n" + + "public interface SysApi {\n" + + " @ExternalType.Static\n" + + " long currentTimeMillis();\n" + + "}\n"); + + CompileTestHarness.RunnableResult r = CompileTestHarness.compileAndLoad(sources); + assertTrue(r.success, r.errors()); + + ClassLoader saved = Thread.currentThread().getContextClassLoader(); + try { + Thread.currentThread().setContextClassLoader(null); + Class adapter = r.loader.loadClass("com.example.SysApi$Ext"); + java.lang.reflect.Method m = adapter.getMethod("currentTimeMillis"); + long ts = (long) m.invoke(null); + assertTrue(ts > 0, "expected valid timestamp via system-CL fallback; got " + ts); + } finally { + Thread.currentThread().setContextClassLoader(saved); + } + } + + @Test + void rejectsAnnotationOnClass() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.NotAnInterface", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.app.Real\")\n" + + "public class NotAnInterface {}\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertFalse(r.success, "expected compile to fail"); + assertTrue(r.errors().contains("@ExternalType can only be applied to interfaces"), r.errors()); + } + + @Test + void rejectsEmptyValue() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.Empty", + "" + + "package com.example;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"\")\n" + + "public interface Empty { int x(); }\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertFalse(r.success, "expected compile to fail"); + assertTrue( + r.errors().contains("@ExternalType.value() must be a non-empty class name"), r.errors()); + } + + @Test + void generatedAdapterHandlesParameterizedTypes() throws Exception { + Map sources = new LinkedHashMap<>(); + sources.put( + "com.example.Listy", + "" + + "package com.example;\n" + + "import java.util.List;\n" + + "import io.btrace.core.extensions.ExternalType;\n" + + "@ExternalType(\"com.example.app.Real\")\n" + + "public interface Listy {\n" + + " java.util.List items();\n" + + " void process(java.util.List items);\n" + + "}\n"); + + CompileTestHarness.Result r = CompileTestHarness.compile(sources); + assertTrue( + r.success, + "compile failed; generated source likely has a bad type literal. errors:\n" + r.errors()); + String adapter = r.generatedSources.get("com.example.Listy$Ext"); + assertNotNull(adapter); + // Raw type must appear in the MethodType literal (no angle brackets). + assertTrue(adapter.contains("MethodType.methodType(java.util.List.class"), adapter); + assertFalse(adapter.contains("java.util.List.class"), adapter); + } +} diff --git a/btrace-core/src/test/java/test/ext/Service.java b/btrace-core/src/test/java/test/ext/Service.java new file mode 100644 index 000000000..7582ee950 --- /dev/null +++ b/btrace-core/src/test/java/test/ext/Service.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 test.ext; + +public interface Service {} diff --git a/btrace-core/src/test/java/test/ext/ServiceImpl.java b/btrace-core/src/test/java/test/ext/ServiceImpl.java new file mode 100644 index 000000000..eafbb8910 --- /dev/null +++ b/btrace-core/src/test/java/test/ext/ServiceImpl.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 test.ext; + +public class ServiceImpl implements Service {} diff --git a/btrace-core/src/test/java/test/ext/SpiImpl.java b/btrace-core/src/test/java/test/ext/SpiImpl.java new file mode 100644 index 000000000..3e02f35ab --- /dev/null +++ b/btrace-core/src/test/java/test/ext/SpiImpl.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 test.ext; + +public class SpiImpl implements Service {} diff --git a/btrace-core/src/test/java/test/ext2/Service2.java b/btrace-core/src/test/java/test/ext2/Service2.java new file mode 100644 index 000000000..d39f58208 --- /dev/null +++ b/btrace-core/src/test/java/test/ext2/Service2.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 test.ext2; + +public interface Service2 {} diff --git a/btrace-core/src/test/java/test/ext2/Service2Impl.java b/btrace-core/src/test/java/test/ext2/Service2Impl.java new file mode 100644 index 000000000..b4f2b4b3d --- /dev/null +++ b/btrace-core/src/test/java/test/ext2/Service2Impl.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 test.ext2; + +public class Service2Impl implements Service2 {} diff --git a/btrace-core/src/test/resources/META-INF/services/test.ext.Service b/btrace-core/src/test/resources/META-INF/services/test.ext.Service new file mode 100644 index 000000000..01be1e98f --- /dev/null +++ b/btrace-core/src/test/resources/META-INF/services/test.ext.Service @@ -0,0 +1,2 @@ +test.ext.SpiImpl + diff --git a/btrace-dist/build.gradle b/btrace-dist/build.gradle index 3add40fe1..b49c4237d 100644 --- a/btrace-dist/build.gradle +++ b/btrace-dist/build.gradle @@ -1,12 +1,11 @@ plugins { - id 'maven' + id 'java' id 'maven-publish' - id "com.jfrog.bintray" version "1.8.5" - id "com.github.johnrengelman.shadow" version "6.1.0" - id "nebula.ospackage" version "8.5.6" - id "java" - id "io.sdkman.vendors" version "2.0.0" - id "signing" + id 'signing' + alias(libs.plugins.shadow) + alias(libs.plugins.ospackage) + alias(libs.plugins.sdkman.vendors) + id 'io.btrace.fat-agent' } import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar @@ -16,18 +15,112 @@ repositories { mavenCentral() } -def distBase = "${project.buildDir}/resources/main" +def distBase = layout.buildDirectory.dir("resources/main").get().asFile.absolutePath def distTarget = "${distBase}/v${project.version}" def libsDir = new File("${distTarget}/libs") +def includes = [:] + +java { + toolchain { + languageVersion.set(JavaLanguageVersion.of(8)) + } +} + +includes['agent'] = { + if (it.directory) { + return true + } + if (it.path.endsWith('.jar')) { + return true + } + return it.path.startsWith('org/jctools/') || + it.path.startsWith('io/btrace/agent/') || + it.path.startsWith('io/btrace/instr/') || + it.path.startsWith('io/btrace/runtime/') || + it.path.startsWith('io/btrace/extension/') || + it.path.startsWith('io/btrace/core/comm/') || + it.path.startsWith('io/btrace/core/handlers/') || + // core/extensions moved to shared section + // include the messages resource bundle and class in the agent jar (bootstrap can't load resources) + it.path == 'io/btrace/core/Messages.class' || + it.path == 'io/btrace/core/messages.properties' +} + +includes['boot'] = { + if (it.directory) { + return true + } + if (it.path.endsWith('.jar')) { + return true + } + if (it.path.startsWith('io/btrace/core/')) { + if (it.path == 'io/btrace/core/Messages.class' || it.path == 'io/btrace/core/messages.properties') { + // messages resource bundle&class are hoisted to agent and client jars + return false + } + return true + } + if (it.path.startsWith('org/objectweb/asm/')) { + if (it.path.startsWith('org/objectweb/asm/commons/') || + it.path.startsWith('org/objectweb/asm/util/') || + it.path.startsWith('org/objectweb/asm/xml/')) { + return false + } + return true + } + if (it.path.startsWith('META-INF/services')) { + return !it.path.contains('com.sun.') && !it.path.contains('javax.annotation.') + } + // btrace-runtime classes should ONLY be in .classdata form (agent section), not as regular .class files + return it.path.startsWith("org/slf4j/") || + it.path.startsWith('io/btrace/extension/') || + it.path.startsWith('org/jctools/') + // Extensions are loaded from extensions/ directory +} + +includes['client'] = { + if (it.directory) { + return true + } + if (it.path.endsWith('.jar')) { + return true + } + if (it.path.startsWith('io/btrace')) { + return !it.path.startsWith('io/btrace/agent') + } + if (it.path.startsWith('com/googlecode/lanterna/')) { + return true + } + if (it.path.startsWith('META-INF/services')) { + return !it.path.contains('com.sun.') && !it.path.contains('javax.annotation.') + } + return it.path.startsWith("org/slf4j") || + it.path.startsWith('org/objectweb/asm') || + it.path.startsWith('org/jctools') +} + + +configurations { + artifact.extendsFrom implementation + bootstrapInputs { + canBeConsumed = false + canBeResolved = true + } +} + dependencies { - compile project(':btrace-agent') - compile project(':btrace-client') - compile project(':btrace-compiler') + implementation project(':btrace-agent') + implementation project(':btrace-client') + implementation project(':btrace-compiler') + bootstrapInputs project(':btrace-agent') + + testImplementation platform(libs.junit) + testImplementation libs.junit.jupiter } jar { - onlyIf { false } + onlyIf { false } // Disable default jar task } sourcesJar { @@ -40,127 +133,363 @@ sourceSets { } } artifacts { - archives file("${distTarget}/libs/btrace-agent.jar") + archives file("${distTarget}/libs/btrace.jar") } -task agentJar(type: ShadowJar) { +// Intermediate shadow jar with all dependencies and relocations +// This is NOT an output artifact, just used for building the masked jar +task allClassesShadow(type: ShadowJar) { group 'Build' - baseName = 'btrace-agent' - version = null - classifier = null - destinationDir = libsDir + archiveBaseName.set('btrace-all-temp') + archiveVersion.set('') + archiveClassifier.set('shadow') + destinationDirectory = layout.buildDirectory.dir("tmp") + configurations = [project.configurations.artifact] + + // Relocate dependencies + relocate 'org.jctools', 'io.btrace.libs.org.jctools' + relocate 'org.objectweb.asm', 'io.btrace.libs.org.objectweb.asm' + relocate 'org.slf4j', 'io.btrace.libs.org.slf4j' + + // Don't create a manifest for this intermediate jar manifest { - attributes( - "Premain-Class": "org.openjdk.btrace.agent.Main", - "Agent-Class": "org.openjdk.btrace.agent.Main", - "Can-Redefine-Classes": true, - "Can-Retransform-Classes": true, - "Boot-Class-Path": "btrace-boot.jar" - ) + attributes([:]) } +} - include { - if (it.directory) { - return true - } - if (it.path.endsWith('.jar')) { - return true - } - return it.path.startsWith('org/openjdk/btrace/agent/') || - it.path.startsWith('org/openjdk/btrace/instr/') || - // include the messages resource bundle and class in the agent jar (bootstrap can't load resources) - it.path == 'org/openjdk/btrace/core/Messages.class' || - it.path == 'org/openjdk/btrace/core/messages.properties' +// uberJar removed - btrace.jar (masked jar) is the single source of truth + +// ==================== Masked JAR ==================== +// Single JAR with .classdata masking for bootstrap isolation +// Bootstrap classes are stored as .class, non-bootstrap as .classdata +// Uses existing shadow JARs to get properly relocated classes + +def maskedJarTmpDir = layout.buildDirectory.dir("masked-jar-tmp").get().asFile + +// Task to prepare agent classes with .classdata extension +task prepareAgentClassdata(type: Copy) { + group 'Build' + description 'Prepare agent classes with .classdata extension' + dependsOn allClassesShadow, processResources + + inputs.files allClassesShadow.archiveFile + outputs.dir "${maskedJarTmpDir}/agent" + + into "${maskedJarTmpDir}/agent" + + from(provider { zipTree(allClassesShadow.archiveFile) }) { + include 'io/btrace/BTrace.class' + include 'io/btrace/libs/org/jctools/**/*.class' + include 'io/btrace/agent/**/*.class' + include 'io/btrace/instr/**/*.class' + include 'io/btrace/instr/jaxb.index' // Required for JAXB probe descriptor loading + include 'io/btrace/runtime/**/*.class' + include 'io/btrace/extension/**/*.class' + include 'io/btrace/core/comm/**/*.class' + include 'io/btrace/core/handlers/**/*.class' + include 'io/btrace/core/Messages.class' + include 'io/btrace/core/messages.properties' + // Exclude classes that go in shared section + exclude 'io/btrace/core/extensions/**' + exclude 'io/btrace/core/annotations/**' + // Exclude bootstrap runtime classes (now in btrace-core) + exclude 'io/btrace/runtime/BTraceRuntimeAccess.class' + exclude 'io/btrace/runtime/BTraceRuntimeAccess$*.class' + exclude 'io/btrace/runtime/LinkingFlag.class' + // BTraceBootstrap is the BSM for flat DSL indy calls; lives in bootstrap CL only + exclude 'io/btrace/runtime/BTraceBootstrap.class' + exclude 'META-INF/**' + rename { name -> name.endsWith('.class') ? name.replace('.class', '.classdata') : name } + } + + duplicatesStrategy = DuplicatesStrategy.EXCLUDE +} + +// Task to prepare client classes with .classdata extension +task prepareClientClassdata(type: Copy) { + group 'Build' + description 'Prepare client classes with .classdata extension' + dependsOn allClassesShadow, processResources + + inputs.files allClassesShadow.archiveFile + outputs.dir "${maskedJarTmpDir}/client" + + into "${maskedJarTmpDir}/client" + + from(provider { zipTree(allClassesShadow.archiveFile) }) { + include 'io/btrace/client/**/*.class' + include 'io/btrace/extcli/**/*.class' + include 'io/btrace/compiler/**/*.class' + include 'io/btrace/libs/org/objectweb/asm/**/*.class' + include 'io/btrace/libs/org/jctools/**/*.class' + include 'io/btrace/libs/org/slf4j/**/*.class' + include 'com/googlecode/lanterna/**/*.class' + // Exclude classes that are in bootstrap or shared + exclude 'io/btrace/core/**' + exclude 'io/btrace/runtime/**' + exclude 'io/btrace/extension/**' + exclude 'META-INF/**' + rename { name -> name.endsWith('.class') ? name.replace('.class', '.classdata') : name } } - configurations = [project.configurations.compile] - relocate 'org.jctools', 'org.openjdk.btrace.libs.org.jctools' - relocate 'org.objectweb.asm', 'org.openjdk.btrace.libs.org.objectweb.asm' + // Messages is excluded from the core/** block above but is required by Main.usage(). + // It cannot be in bootstrap (Messages.class.getClassLoader() would return null there, + // breaking ResourceBundle.getBundle()), so it must be in the client masked section. + from(provider { zipTree(allClassesShadow.archiveFile) }) { + include 'io/btrace/core/Messages.class' + include 'io/btrace/core/messages.properties' + rename { name -> name.endsWith('.class') ? name.replace('.class', '.classdata') : name } + } + + duplicatesStrategy = DuplicatesStrategy.EXCLUDE } -task bootJar(type: ShadowJar) { +// Task to prepare shared classes with .classdata extension (used by both agent and client) +task prepareSharedClassdata(type: Copy) { group 'Build' - baseName = 'btrace-boot' - version = null - classifier = null - destinationDir = libsDir + description 'Prepare shared classes with .classdata extension (for both agent and client)' + dependsOn allClassesShadow, processResources + + inputs.files allClassesShadow.archiveFile + outputs.dir "${maskedJarTmpDir}/shared" + + into "${maskedJarTmpDir}/shared" + + from(provider { zipTree(allClassesShadow.archiveFile) }) { + // Only include classes used by both client and agent + include 'io/btrace/core/comm/**/*.class' + include 'io/btrace/core/extensions/**/*.class' + include 'io/btrace/core/annotations/**/*.class' + include 'io/btrace/libs/org/objectweb/asm/**/*.class' + // Exclude ASM packages not needed + exclude 'io/btrace/libs/org/objectweb/asm/commons/**' + exclude 'io/btrace/libs/org/objectweb/asm/util/**' + exclude 'io/btrace/libs/org/objectweb/asm/xml/**' + exclude 'META-INF/**' + rename { name -> name.endsWith('.class') ? name.replace('.class', '.classdata') : name } + } + duplicatesStrategy = DuplicatesStrategy.EXCLUDE +} - include { - if (it.directory) { +def bootIncludes = { + if (it.directory) { + return true + } + if (it.path.endsWith('.jar')) { + return true + } + if (it.path.startsWith('io/btrace/core/')) { + if (it.path == 'io/btrace/core/Messages.class' + || it.path == 'io/btrace/core/messages.properties') { + return false + } + if (it.path.startsWith('io/btrace/core/extensions/')) { + return false + } + // Include handlers - probe classes need them in their static initializers + if (it.path.startsWith('io/btrace/core/handlers/')) { return true } - if (it.path.endsWith('.jar')) { + if (it.path.startsWith('io/btrace/core/comm/')) { + return false + } + // Include annotations - needed by compiler at compile-time + if (it.path.startsWith('io/btrace/core/annotations/')) { return true } - if (it.path.startsWith('org/openjdk/btrace/core/')) { - if (it.path == 'org/openjdk/btrace/core/Messages.class' || it.path == 'org/openjdk/btrace/core/messages.properties') { - // messages resource bundle&class are hoisted to agent and client jars - return false - } + return true + } + // Include BTrace flat DSL class — needed by javac when compiling scripts + if (it.path == 'io/btrace/BTrace.class') { + return true + } + if (it.path.startsWith('META-INF/services')) { + return !it.path.contains('com.sun.') && !it.path.contains('javax.annotation.') + } + // Include BTraceRuntimeAccess and LinkingFlag from btrace-core (bootstrap classes) + if (it.path.startsWith('io/btrace/runtime/')) { + // Match BTraceRuntimeAccess but NOT BTraceRuntimeAccessImpl + if (it.path.startsWith('io/btrace/runtime/BTraceRuntimeAccess.class') + || it.path.startsWith('io/btrace/runtime/BTraceRuntimeAccess$') + || it.path.startsWith('io/btrace/runtime/LinkingFlag')) { return true } - if (it.path.startsWith('org/jctools/')) { - if (it.path.startsWith('org/jctools/map/')) { - return false - } + // Include invokedynamic bootstrap classes (they use volatile fields to reach agent implementations) + if (it.path.startsWith('io/btrace/runtime/Indy') + || it.path.startsWith('io/btrace/runtime/ExtensionIndy')) { return true } - if (it.path.startsWith('org/objectweb/asm/')) { - if (it.path.startsWith('org/objectweb/asm/commons/') || - it.path.startsWith('org/objectweb/asm/util/') || - it.path.startsWith('org/objectweb/asm/xml/')) { - return false - } + // BTraceBootstrap is the BSM for flat DSL INVOKEDYNAMIC calls; must be visible + // to application classloaders so the JVM can resolve the bootstrap method + if (it.path.startsWith('io/btrace/runtime/BTraceBootstrap')) { + return true + } + // Include Auxiliary class - probe classes are defined via MethodHandles.privateLookupIn(Auxiliary.class) + // and must be bootstrap-visible so they're accessible from application classloaders + if (it.path.startsWith('io/btrace/runtime/auxiliary/Auxiliary')) { return true } - return it.path.startsWith('org/openjdk/btrace/runtime/') || - it.path.startsWith('org/openjdk/btrace/services/') || - it.path.startsWith('org/openjdk/btrace/statsd/') + return false } + // Include ExtensionBridge interface (referenced by ExtensionIndy) + if (it.path == 'io/btrace/extension/ExtensionBridge.class') { + return true + } + // Include slf4j for bootstrap classes (DebugSupport needs it) + if (it.path.startsWith('org/slf4j/')) { + return true + } + return false +} - configurations = [project.configurations.compile] - relocate 'org.jctools', 'org.openjdk.btrace.libs.org.jctools' - relocate 'org.objectweb.asm', 'org.openjdk.btrace.libs.org.objectweb.asm' +task bootstrapJar(type: ShadowJar) { + archiveBaseName.set('btrace-bootstrap') + archiveVersion.set('') + archiveClassifier.set('') + + include bootIncludes + + configurations = [project.configurations.bootstrapInputs] + relocate 'org.jctools', 'io.btrace.libs.boot.org.jctools' + relocate 'org.objectweb.asm', 'io.btrace.libs.org.objectweb.asm' + relocate 'org.slf4j', 'io.btrace.libs.org.slf4j' } -task clientJar(type: ShadowJar) { +// Single JAR with .classdata masking for bootstrap isolation +task btraceJar(type: Jar) { group 'Build' - baseName = 'btrace-client' - version = null - classifier = null - destinationDir = libsDir + description 'Creates single JAR with .classdata masking for bootstrap isolation' + archiveBaseName.set('btrace') + archiveVersion.set('') + archiveClassifier.set('') + destinationDirectory = libsDir + + dependsOn prepareAgentClassdata, prepareClientClassdata, prepareSharedClassdata + dependsOn project(':btrace-boot').tasks.jar + dependsOn bootstrapJar + + // 1. Include boot loader class (must be in bootstrap as .class) + from(project(':btrace-boot').sourceSets.main.output) { + include 'io/btrace/boot/**/*.class' + } - exclude 'afu/**' - exclude 'javax/**' - exclude 'com/**' - exclude 'sun/**' - exclude 'org/relaxng/**' - exclude 'org/checkerframework/**' - exclude 'org/codehaus/**' + // 2. Include bootstrap classes from bootstrapJar (as .class) + from(zipTree(bootstrapJar.archiveFile)) { + include '**/*.class' + include 'META-INF/services/**' + include '**/jaxb.index' // Required for JAXB probe descriptor loading + exclude 'io/btrace/core/comm/**' + // Include annotations in bootstrap (needed by ExtensionIndy at runtime) + // Exclude manifest from bootstrap jar + exclude 'META-INF/MANIFEST.MF' + } - exclude 'org/jctools/maps/**' - exclude 'org/jctools/util/**' - exclude 'META-INF/services/com.sun.*' - exclude 'META-INF/services/javax.annotation.*' + // 3. Include masked agent classes (as .classdata) + into('META-INF/btrace/agent') { + from("${maskedJarTmpDir}/agent") { + include '**/*.classdata' + include '**/messages.properties' + include '**/jaxb.index' // Required for JAXB probe descriptor loading + } + } - exclude 'org/objectweb/asm/xml/**' + // 4. Include masked client classes (as .classdata) + into('META-INF/btrace/client') { + from("${maskedJarTmpDir}/client") { + include '**/*.classdata' + include '**/messages.properties' + } + } - exclude 'org/openjdk/btrace/agent/**' + // 5. Include shared classes (as .classdata) - used by both agent and client + into('META-INF/btrace/shared') { + from("${maskedJarTmpDir}/shared") { + include '**/*.classdata' + } + } - configurations = [project.configurations.compile] - relocate 'org.jctools', 'org.openjdk.btrace.libs.org.jctools' - relocate 'org.objectweb.asm', 'org.openjdk.btrace.libs.org.objectweb.asm' + // 6. Include extensions in root (needed by bootstrap) + // Note: Messages class is NOT included in bootstrap - it uses ResourceBundle.getBundle() + // with Messages.class.getClassLoader() which returns null for bootstrap classes, + // causing NPE. Messages is only in agent/client sections where classloader is non-null. + from(project(':btrace-core').sourceSets.main.output) { + include 'io/btrace/core/extensions/**/*.class' + } + + manifest { + attributes( + 'Premain-Class': 'io.btrace.boot.Loader', + 'Agent-Class': 'io.btrace.boot.Loader', + 'Main-Class': 'io.btrace.boot.Loader', + 'Can-Redefine-Classes': true, + 'Can-Retransform-Classes': true, + 'Boot-Class-Path': 'btrace.jar', + 'BTrace-Version': version, + 'BTrace-Agent-Main': 'io.btrace.agent.Main', + 'BTrace-Client-Main': 'io.btrace.client.Main' + ) + } + + duplicatesStrategy = DuplicatesStrategy.EXCLUDE +} + +tasks.named('compileTestJava') { + dependsOn btraceJar + dependsOn 'copyDtraceLib', 'copyExtensions' +} + +test { + dependsOn btraceJar + useJUnitPlatform() } -task fixPermissions(type: Exec) { +/** + * Fat agent JAR configuration via BTrace Fat Agent Plugin. + * + * Creates a fat agent JAR with embedded extensions for single-JAR deployment. + * + * Structure: + * btrace-agent-fat.jar + * ├── META-INF/ + * │ ├── MANIFEST.MF (BTrace-Embedded-Extensions: ext1,ext2) + * │ └── btrace-extensions/ + * │ └── ext-id/ + * │ └── extension.properties + * ├── org/openjdk/btrace/... # Agent + API classes (.class) + * └── org/openjdk/btrace/ext/impl/... # Impl classes (.classdata) + * + * Usage: + * ./gradlew :btrace-dist:fatAgentJar -PembedExtensions=btrace-spark,btrace-metrics + */ +btraceFatAgent { + baseName = 'btrace-agent-fat' + outputDir = libsDir + + // Reference the single masked JAR (agent + boot merged into btraceJar) + agentJarTask = 'btraceJar' + + // Auto-discover extensions from subprojects + autoDiscover = true + filterProperty = 'embedExtensions' + + // Package relocations + relocate 'org.jctools', 'io.btrace.libs.agent.org.jctools' + relocate 'org.objectweb.asm', 'io.btrace.libs.org.objectweb.asm' + relocate 'org.slf4j', 'io.btrace.libs.org.slf4j' +} + +task fixPermissions { onlyIf { !OperatingSystem.current().isWindows() } - commandLine 'chmod', '500', "${distTarget}/bin/btrace" - commandLine 'chmod', '500', "${distTarget}/bin/btracec" - commandLine 'chmod', '500', "${distTarget}/bin/btracer" + + doLast { + ant.chmod(dir: "${distTarget}/bin", perm: '500', includes: '*', excludes: '*.bat') + } + + dependsOn processResources } task copyDtraceLib(type: Copy) { @@ -168,29 +497,94 @@ task copyDtraceLib(type: Copy) { into "${distTarget}/libs/" } +task copyExtensions(type: Copy) { + group 'Build' + description 'Copy extension ZIP archives to extensions/ directory' + into "${distTarget}/extensions/" +} + +// Copy the btracex CLI shaded jar into libs + +// Discover all extension subprojects and wire copyExtensions dynamically to avoid hard-coded paths +gradle.projectsEvaluated { + def extProjects = rootProject.subprojects.findAll { it.plugins.hasPlugin('io.btrace.extension') } + if (extProjects.isEmpty()) { + logger.lifecycle("[btrace-dist] No BTrace extension projects found. Skipping extension packaging.") + } else { + tasks.named('copyExtensions').configure { t -> + extProjects.each { sp -> + // Depend on packaging task and copy any *-extension.zip from its distributions folder + t.dependsOn("${sp.path}:packageExtension") + t.from(sp.layout.buildDirectory.dir('distributions')) { + include "*-extension.zip" + } + } + } + } +} + +task explodeExtensions { + group 'Build' + description 'Explode extension ZIP archives into extension subdirectories' + dependsOn copyExtensions + + doLast { + def extensionsDir = file("${distTarget}/extensions") + if (!extensionsDir.exists()) { + return + } + + extensionsDir.listFiles().each { file -> + if (file.name.endsWith('-extension.zip')) { + // Extract extension name from filename: btrace-metrics-2.3.0-SNAPSHOT-extension.zip -> btrace-metrics + def extensionName = file.name.replaceAll(/-\d+.*-extension\.zip$/, '') + def targetDir = new File(extensionsDir, extensionName) + targetDir.mkdirs() + + // Explode ZIP into extension directory + copy { + from zipTree(file) + into targetDir + } + + logger.info("Exploded extension ${file.name} into ${extensionName}/") + } + } + } +} + task buildZip(type: Zip) { + dependsOn btraceJar, fixPermissions, explodeExtensions from "${distTarget}" include "**/*" - archiveName "btrace-v${project.version}-bin.zip" - destinationDir(file("$project.buildDir/distributions")) + + archiveBaseName.set('btrace') + archiveVersion.set("v${project.version}") + archiveClassifier.set("bin") + destinationDirectory = layout.buildDirectory.dir("distributions") } task buildSdkmanZip(type: Zip) { from "${distBase}" include "**/*" - archiveName "btrace-v${project.version}-sdkman-bin.zip" - destinationDir(file("$project.buildDir/distributions")) + + archiveBaseName.set('btrace') + archiveVersion.set("v${project.version}") + archiveClassifier.set("sdkman-bin") + destinationDirectory = layout.buildDirectory.dir("distributions") } task buildTgz(type: Tar) { - archiveName "btrace-v${project.version}-bin.tar.gz" into ('/'){ from "${distTarget}" include '**/*' } - destinationDir file("$project.buildDir/distributions") - extension 'tar.gz' + archiveBaseName.set('btrace') + archiveVersion.set("v${project.version}") + archiveClassifier.set("bin") + destinationDirectory = layout.buildDirectory.dir("distributions") + archiveExtension.set('tar.gz') compression = Compression.GZIP } @@ -221,6 +615,7 @@ ospackage { link('/usr/local/bin/btrace', '/opt/btrace/bin/btrace') link('/usr/local/bin/btracer', '/opt/btrace/bin/btracer') link('/usr/local/bin/btracec', '/opt/btrace/bin/btracec') + link('/usr/local/bin/btracex', '/opt/btrace/bin/btracex') } buildDeb { @@ -228,42 +623,212 @@ buildDeb { } copyDtraceLib.dependsOn project(':btrace-dtrace').build -buildTgz.dependsOn agentJar, bootJar, clientJar, fixPermissions, copyDtraceLib -buildZip.dependsOn agentJar, bootJar, clientJar, fixPermissions, copyDtraceLib -buildSdkmanZip.dependsOn agentJar, bootJar, clientJar, fixPermissions, copyDtraceLib -buildDeb.dependsOn agentJar, bootJar, clientJar, fixPermissions, copyDtraceLib -buildRpm.dependsOn agentJar, bootJar, clientJar, fixPermissions, copyDtraceLib +shadowJar.dependsOn btraceJar, copyDtraceLib, copyExtensions +buildTgz.dependsOn btraceJar, fixPermissions, copyDtraceLib, processResources, explodeExtensions +buildZip.dependsOn btraceJar, fixPermissions, copyDtraceLib, processResources, explodeExtensions +buildSdkmanZip.dependsOn btraceJar, fixPermissions, copyDtraceLib, processResources, explodeExtensions +buildDeb.dependsOn btraceJar, fixPermissions, copyDtraceLib, processResources, explodeExtensions +buildRpm.dependsOn btraceJar, fixPermissions, copyDtraceLib, processResources, explodeExtensions build.dependsOn buildSdkmanZip, buildZip, buildTgz, buildDeb, buildRpm -test { +// Docker build tasks +task buildDockerContext(type: Copy, dependsOn: [btraceJar, copyDtraceLib, processResources, fixPermissions]) { + group 'Docker' + description 'Prepare Docker build context with BTrace distribution' + + from "${distTarget}" + into layout.buildDirectory.dir("docker-context/btrace") + filePermissions { unix(0644) } + doLast { - project(':btrace-instr').tasks.test.execute() + // Copy entrypoint script + copy { + from "${projectDir}/../docker/docker-entrypoint.sh" + into layout.buildDirectory.dir("docker-context") + } + // Copy .dockerignore to build context so Docker can use it + copy { + from "${projectDir}/../docker/.dockerignore" + into layout.buildDirectory.dir("docker-context") + } + } +} + +task buildDockerImage(type: Exec, dependsOn: buildDockerContext) { + group 'Docker' + description 'Build main Debian-based Docker image' + + onlyIf { + project.hasProperty('dockerEnabled') && + (project.hasProperty('dockerBuildx') ? + 'docker buildx version'.execute().waitFor() == 0 : + 'docker --version'.execute().waitFor() == 0) + } + + workingDir "${projectDir}/../docker" + + def buildArgs = [ + 'docker', 'build', + '--build-arg', "BTRACE_VERSION=${project.version}", + '-t', "btrace/btrace:${project.version}", + '-t', "btrace/btrace:latest", + '-f', 'Dockerfile', + layout.buildDirectory.dir("docker-context").get().asFile.absolutePath + ] + + if (project.hasProperty('dockerBuildx')) { + buildArgs.add(1, 'buildx') + buildArgs.addAll(['--platform', 'linux/amd64,linux/arm64']) + } + + commandLine buildArgs +} + +task buildDockerImageAlpine(type: Exec, dependsOn: buildDockerContext) { + group 'Docker' + description 'Build Alpine-based Docker image' + + onlyIf { + project.hasProperty('dockerEnabled') && + (project.hasProperty('dockerBuildx') ? + 'docker buildx version'.execute().waitFor() == 0 : + 'docker --version'.execute().waitFor() == 0) + } + + workingDir "${projectDir}/../docker" + + def buildArgs = [ + 'docker', 'build', + '--build-arg', "BTRACE_VERSION=${project.version}", + '-t', "btrace/btrace:${project.version}-alpine", + '-t', "btrace/btrace:latest-alpine", + '-f', 'Dockerfile.alpine', + layout.buildDirectory.dir("docker-context").get().asFile.absolutePath + ] + + if (project.hasProperty('dockerBuildx')) { + buildArgs.add(1, 'buildx') + buildArgs.addAll(['--platform', 'linux/amd64,linux/arm64']) + } + + commandLine buildArgs +} + +task buildDockerImageDistroless(type: Exec, dependsOn: buildDockerContext) { + group 'Docker' + description 'Build distroless Docker image' + + onlyIf { + project.hasProperty('dockerEnabled') && + (project.hasProperty('dockerBuildx') ? + 'docker buildx version'.execute().waitFor() == 0 : + 'docker --version'.execute().waitFor() == 0) + } + + workingDir "${projectDir}/../docker" + + def buildArgs = [ + 'docker', 'build', + '--build-arg', "BTRACE_VERSION=${project.version}", + '-t', "btrace/btrace:${project.version}-distroless", + '-t', "btrace/btrace:latest-distroless", + '-f', 'Dockerfile.distroless', + layout.buildDirectory.dir("docker-context").get().asFile.absolutePath + ] + + if (project.hasProperty('dockerBuildx')) { + buildArgs.add(1, 'buildx') + buildArgs.addAll(['--platform', 'linux/amd64']) } + + commandLine buildArgs +} + +task buildDockerImages { + group 'Docker' + description 'Build all Docker image variants' + dependsOn buildDockerImage, buildDockerImageAlpine, buildDockerImageDistroless } ['agent', 'boot', 'client'].each { name -> - tasks.create(name: "${name}SourcesJar", type: Jar) { + // Define a temporary directory for the sources + def tempDir = layout.buildDirectory.dir("tmp/${name}Sources").get().asFile + + // first, we will copy the classes and make sure there are no empty directories + tasks.create(name: "${name}CopySources", type: Copy) { + doFirst { + tempDir.deleteDir() // Ensure the directory is clean + } + + into tempDir + + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + gradle.projectsEvaluated { + rootProject.childProjects.each { projectName, siblingProject -> + // Skip the current project to avoid duplication + if (siblingProject != project) { + from(siblingProject.sourceSets.main.allSource) { + include includes["${name}"] + exclude 'META-INF/**' + } + } + } + } + + doLast { + // Recursively delete empty directories + def deleteEmptyDirs + deleteEmptyDirs = { dir -> + dir.eachDir { subDir -> + deleteEmptyDirs(subDir) + if (!subDir.listFiles().any()) { + subDir.deleteDir() + } + } + } + deleteEmptyDirs(tempDir) + } + } + + // we will use the output of the previous task to crate the JAR + tasks.create(name: "${name}SourcesJar", type: Jar, dependsOn: "${name}CopySources") { group 'Documentation' description "Build the btrace-${name} sources jar." - appendix "${name}" - classifier 'sources' - from sourceSets.main.allSource - exclude excludes["${name}"] - } + archiveAppendix = "${name}" + archiveClassifier = "sources" + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + from tempDir + } tasks.create(name: "${name}Javadoc", type: Javadoc) { group 'Documentation' description "Generates Javadoc API documentation for the btrace-${name}." title = "btrace-${name}" - source = sourceSets.main.allJava - destinationDir = file("${project.docsDir}/${name}/javadoc") - classpath = files(compileJava.destinationDir) + configurations.compile.asFileTree - exclude excludes["${name}"] + destinationDir = layout.buildDirectory.dir("docs/${name}/javadoc").get().asFile + classpath = files(compileJava.destinationDirectory) + configurations.artifact.asFileTree options.addStringOption('Xdoclint:all,-missing', '-quiet') failOnError false + + project.parent.subprojects.each { subproject -> + // Skip the current project to avoid duplication + if (subproject != project) { + // Add source from sibling projects based on filter + source subproject.sourceSets.main.java.matching { + include includes["${name}"] + } + } + } + + // Include classpath of all sibling projects + project.parent.subprojects.each { subproject -> + // Skip the current project to avoid duplication + if (subproject != project) { + classpath += subproject.sourceSets.main.compileClasspath + } + } } @@ -271,53 +836,15 @@ test { group 'Documentation' description "Build the btrace-${name} javadoc jar." - appendix name - classifier 'javadoc' + archiveAppendix = "${name}" + archiveClassifier = "javadoc" from tasks["${name}Javadoc"].getOutputs() } } -// Support for releasing to BinTray; see https://github.com/bintray/gradle-bintray-plugin -// Add 'gradle.properties' file containing the following properties: -// * bintray.user -// * bintray.key -// * gpg.passphrase -bintray { - user = project.hasProperty("bintray.user") ? project.property("bintray.user") : System.getenv('BINTRAY_USER') - key = project.hasProperty("bintray.key") ? project.property("bintray.key") : System.getenv('BINTRAY_API_KEY') - - publications = ['agent', 'client', 'boot'] - - dryRun = System.properties['bintrayUpload'] != null ? !(Boolean.getBoolean('bintrayUpload')) : true - publish = true - - pkg { - repo = 'maven' - name = 'btrace' - desc = 'BTrace' - userOrg = 'btraceio' - websiteUrl = 'https://github.com/btraceio/btrace' - issueTrackerUrl = 'https://github.com/btraceio/btrace/issues' - vcsUrl = 'https://github.com/btraceio/btrace.git' - licenses = ['GPL-2.0+CE'] - labels = [] - publicDownloadNumbers = true - version { - name = project.version //Bintray logical version name - released = new Date() - vcsTag = 'v' + project.version - //Optional configuration for GPG signing - gpg { - sign = project.hasProperty("gpg.passphrase") //Determines whether to GPG sign the files. The default is false - passphrase = sign ? project.property("gpg.passphrase") : "" //Optional. The passphrase for GPG signing' - } - } - } -} - sdkman { - consumerKey = project.hasProperty("sdkman.key") ? project.property("sdkman.key") : System.getenv('SDKMAN_API_KEY') - consumerToken = project.hasProperty("sdkman.token") ? project.property("sdkman.token") : System.getenv('SDKMAN_API_TOKEN') + consumerKey = project.hasProperty("sdkman.key") ? project.property("sdkman.key") : System.getenv('SDKMAN_KEY') + consumerToken = project.hasProperty("sdkman.token") ? project.property("sdkman.token") : System.getenv('SDKMAN_TOKEN') candidate = "btrace" version = "${project.version}" url = "https://github.com/btraceio/btrace/releases/download/v${project.version}/btrace-v${project.version}-sdkman-bin.zip" @@ -333,60 +860,26 @@ sdkman { publishing { repositories { maven { - def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/" - def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/" + // Central Portal URLs (OSSRH was sunset on June 30, 2025) + def releasesRepoUrl = "https://ossrh-staging-api.central.sonatype.com/service/local/staging/deploy/maven2/" + def snapshotsRepoUrl = "https://central.sonatype.com/repository/maven-snapshots/" url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl credentials { - username = project.hasProperty("sonatype.user") ? project.property("sonatype.user") : System.getenv('BTRACE_SONATYPE_USER') - password = project.hasProperty("sonatype.password") ? project.property("sonatype.password") : System.getenv('BTRACE_SONATYPE_PWD') + // Use Central Portal user token credentials + username = project.hasProperty("sonatype.user") ? project.property("sonatype.user") : System.getenv('SONATYPE_USER') + password = project.hasProperty("sonatype.password") ? project.property("sonatype.password") : System.getenv('SONATYPE_PASSWORD') } } } publications { - agent(MavenPublication) { - artifactId 'btrace-agent' + btrace(MavenPublication) { + artifactId 'btrace' groupId 'io.btrace' - artifact agentJar - artifact agentSourcesJar { - classifier "sources" - } - artifact agentJavadocJar { - classifier "javadoc" - } + artifact btraceJar pom.withXml { - addPomDetails(asNode(), 'btrace-agent') - } - } - - client(MavenPublication) { - artifactId 'btrace-client' - groupId 'io.btrace' - artifact clientJar - artifact clientSourcesJar { - classifier "sources" - } - artifact clientJavadocJar { - classifier "javadoc" - } - pom.withXml { - addPomDetails(asNode(), 'btrace-client') - } - } - - boot(MavenPublication) { - artifactId 'btrace-boot' - groupId 'io.btrace' - artifact bootJar - artifact bootSourcesJar { - classifier "sources" - } - artifact bootJavadocJar { - classifier "javadoc" - } - pom.withXml { - addPomDetails(asNode(), 'btrace-boot') + addPomDetails(asNode(), 'btrace') } } } @@ -396,7 +889,7 @@ def addPomDetails(node, name) { node.appendNode('name', name) node.appendNode('url', 'https://github.com/btraceio/btrace') node.appendNode('description', 'BTrace: A safe, dynamic tracing tool for the Java platform') - def scmNode = node.appendNode('scm'); + def scmNode = node.appendNode('scm') scmNode.appendNode('url', 'https://github.com/btraceio/btrace') scmNode.appendNode('connection', 'scm:git:https://github.com/btraceio/btrace.git') scmNode.appendNode('developerConnection', 'scm:git:https://github.com/btraceio/btrace.git') @@ -418,7 +911,5 @@ signing { if (signingKey != null && signingPwd != null) { useInMemoryPgpKeys(signingKey, signingPwd) } - sign publishing.publications.agent - sign publishing.publications.boot - sign publishing.publications.client -} \ No newline at end of file + sign publishing.publications.btrace +} diff --git a/btrace-dist/src/main/resources/bin/btrace b/btrace-dist/src/main/resources/bin/btrace index ad56f26c8..1e3a9c3b1 100755 --- a/btrace-dist/src/main/resources/bin/btrace +++ b/btrace-dist/src/main/resources/bin/btrace @@ -17,13 +17,10 @@ JAVA_ARGS="-XX:+IgnoreUnrecognizedVMOptions" if [ -d "${JAVA_HOME}/jmods" ]; then JAVA_ARGS="$JAVA_ARGS -XX:+AllowRedefinitionToAddDeleteMethods" JAVA_ARGS="$JAVA_ARGS --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" fi -if [ -f "${BTRACE_HOME}/libs/btrace-client.jar" ]; then +CLIENT_JAR="${BTRACE_HOME}/libs/btrace.jar" +if [ -f "${CLIENT_JAR}" ]; then if [ -d "${JAVA_HOME}" ]; then TOOLS_JAR="$JAVA_HOME/lib/tools.jar" @@ -63,7 +60,7 @@ if [ -f "${BTRACE_HOME}/libs/btrace-client.jar" ]; then echo "Unable to locate tools.jar. Please, make sure JAVA_HOME points to a valid JDK installation" exit 1 fi - ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${BTRACE_HOME}/libs/btrace-client.jar:${TOOLS_JAR}:/usr/share/lib/java/dtrace.jar org.openjdk.btrace.client.Main $* + ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${CLIENT_JAR}:${TOOLS_JAR}:/usr/share/lib/java/dtrace.jar io.btrace.boot.Loader $* else echo "Please set a valid JAVA_HOME before running this script" exit 1 diff --git a/btrace-dist/src/main/resources/bin/btrace.bat b/btrace-dist/src/main/resources/bin/btrace.bat index a36074757..32cd49743 100644 --- a/btrace-dist/src/main/resources/bin/btrace.bat +++ b/btrace-dist/src/main/resources/bin/btrace.bat @@ -1,4 +1,5 @@ @echo off +setlocal enableextensions rem %~dp0 is expanded pathname of the current script under NT set DEFAULT_BTRACE_HOME=%~dp0.. @@ -6,19 +7,16 @@ set DEFAULT_BTRACE_HOME=%~dp0.. if "%BTRACE_HOME%"=="" set BTRACE_HOME=%DEFAULT_BTRACE_HOME% set DEFAULT_BTRACE_HOME= -if not exist "%BTRACE_HOME%\libs\btrace-client.jar" goto noBTraceHome +set "CLIENT_JAR=%BTRACE_HOME%\libs\btrace.jar" +if not exist "%CLIENT_JAR%" goto noBTraceHome if "%JAVA_HOME%" == "" goto noJavaHome - set JAVA_ARGS="-XX:+IgnoreUnrecognizedVMOptions" - if exists "%JAVA_HOME%/jmods/" ( - set JAVA_ARGS="%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" + set "JAVA_ARGS=-XX:+IgnoreUnrecognizedVMOptions" + if exist "%JAVA_HOME%/jmods/" ( + set "JAVA_ARGS=%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" + set "JAVA_ARGS=%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" ) - "%JAVA_HOME%/bin/java" "%JAVA_ARGS%" -cp "%BTRACE_HOME%/libs/btrace-client.jar;%JAVA_HOME%/lib/tools.jar" org.openjdk.btrace.client.Main %* + "%JAVA_HOME%\bin\java" %JAVA_ARGS% -cp "%CLIENT_JAR%;%JAVA_HOME%\lib\tools.jar" io.btrace.boot.Loader %* goto end :noJavaHome echo Please set JAVA_HOME before running this script @@ -26,3 +24,4 @@ if "%JAVA_HOME%" == "" goto noJavaHome :noBTraceHome echo Please set BTRACE_HOME before running this script :end +endlocal diff --git a/btrace-dist/src/main/resources/bin/btracec b/btrace-dist/src/main/resources/bin/btracec index 3e992ffd1..cc671b71e 100755 --- a/btrace-dist/src/main/resources/bin/btracec +++ b/btrace-dist/src/main/resources/bin/btracec @@ -15,15 +15,12 @@ fi JAVA_ARGS="-XX:+IgnoreUnrecognizedVMOptions" if [ -d "${JAVA_HOME}/jmods" ]; then JAVA_ARGS="$JAVA_ARGS --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" fi -if [ -f "${BTRACE_HOME}/libs/btrace-client.jar" ]; then +CLIENT_JAR="${BTRACE_HOME}/libs/btrace.jar" +if [ -f "${CLIENT_JAR}" ]; then if [ -d "${JAVA_HOME}" ]; then if [ "$1" = "--version" ]; then - ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${BTRACE_HOME}/libs/btrace-client.jar org.openjdk.btrace.client.Main --version + ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${CLIENT_JAR} io.btrace.boot.Loader --version exit 0 fi TOOLS_JAR="$JAVA_HOME/lib/tools.jar" @@ -54,7 +51,7 @@ if [ -f "${BTRACE_HOME}/libs/btrace-client.jar" ]; then exit 1 fi - ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${BTRACE_HOME}/libs/btrace-client.jar:${TOOLS_JAR} org.openjdk.btrace.compiler.Compiler $* + ${JAVA_HOME}/bin/java ${JAVA_ARGS} -Dbtrace.client.main=io.btrace.compiler.Compiler -cp ${CLIENT_JAR}:${TOOLS_JAR} io.btrace.boot.Loader $* else echo "Please set a valid JAVA_HOME before running this script" exit 1 diff --git a/btrace-dist/src/main/resources/bin/btracec.bat b/btrace-dist/src/main/resources/bin/btracec.bat index 8ad97d8ce..0082d064c 100644 --- a/btrace-dist/src/main/resources/bin/btracec.bat +++ b/btrace-dist/src/main/resources/bin/btracec.bat @@ -1,4 +1,5 @@ @echo off +setlocal enableextensions rem %~dp0 is expanded pathname of the current script under NT set DEFAULT_BTRACE_HOME=%~dp0.. @@ -6,26 +7,25 @@ set DEFAULT_BTRACE_HOME=%~dp0.. if "%BTRACE_HOME%"=="" set BTRACE_HOME=%DEFAULT_BTRACE_HOME% set DEFAULT_BTRACE_HOME= -if not exist "%BTRACE_HOME%\libs\btrace-client.jar" goto noBTraceHome +set "CLIENT_JAR=%BTRACE_HOME%\libs\btrace.jar" +if not exist "%CLIENT_JAR%" goto noBTraceHome if "%JAVA_HOME%" == "" goto noJavaHome - if exists "%JAVA_HOME%/jmods/" ( - set JAVA_ARGS="%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" + set "JAVA_ARGS=-XX:+IgnoreUnrecognizedVMOptions" + if exist "%JAVA_HOME%/jmods/" ( + set "JAVA_ARGS=%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" + set "JAVA_ARGS=%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" ) if "%1" == "--version" ( - %JAVA_HOME%\bin\java "%JAVA_ARGS%" -cp %BTRACE_HOME%/build/btrace-client.jar org.openjdk.btrace.client.Main --version + "%JAVA_HOME%\bin\java" %JAVA_ARGS% -cp "%CLIENT_JAR%" io.btrace.boot.Loader --version goto end ) - "%JAVA_HOME%/bin/java" "%JAVA_ARGS%" -cp "%BTRACE_HOME%/libs/btrace-client.jar;%JAVA_HOME%/lib/tools.jar" org.openjdk.btrace.compiler.Compiler %* + "%JAVA_HOME%\bin\java" %JAVA_ARGS% -Dbtrace.client.main=io.btrace.compiler.Compiler -cp "%CLIENT_JAR%;%JAVA_HOME%\lib\tools.jar" io.btrace.boot.Loader %* goto end :noJavaHome echo Please set JAVA_HOME before running this script goto end :noBTraceHome echo Please set BTRACE_HOME before running this script -:end \ No newline at end of file +:end +endlocal diff --git a/btrace-dist/src/main/resources/bin/btracep b/btrace-dist/src/main/resources/bin/btracep index d5239e6de..6b3a2418b 100755 --- a/btrace-dist/src/main/resources/bin/btracep +++ b/btrace-dist/src/main/resources/bin/btracep @@ -17,16 +17,13 @@ JAVA_ARGS="-XX:+IgnoreUnrecognizedVMOptions" if [ -d "${JAVA_HOME}/jmods" ]; then JAVA_ARGS="$JAVA_ARGS -XX:+AllowRedefinitionToAddDeleteMethods" JAVA_ARGS="$JAVA_ARGS --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" fi -if [ -f "${BTRACE_HOME}/libs/btrace-client.jar" ]; then +CLIENT_JAR="${BTRACE_HOME}/libs/btrace.jar" +if [ -f "${CLIENT_JAR}" ]; then if [ -d "${JAVA_HOME}" ]; then if [ "$1" = "--version" ]; then - ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${BTRACE_HOME}/libs/btrace-client.jar org.openjdk.btrace.client.Main --version + ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${CLIENT_JAR} io.btrace.boot.Loader --version exit 0 fi TOOLS_JAR="$JAVA_HOME/lib/tools.jar" @@ -57,7 +54,7 @@ if [ -f "${BTRACE_HOME}/libs/btrace-client.jar" ]; then exit 1 fi - ${JAVA_HOME}/bin/java ${JAVA_ARGS} -cp ${BTRACE_HOME}/libs/btrace-client.jar:${TOOLS_JAR} org.openjdk.btrace.client.ProbePrinter $* + ${JAVA_HOME}/bin/java ${JAVA_ARGS} -Dbtrace.client.main=io.btrace.client.ProbePrinter -cp ${CLIENT_JAR}:${TOOLS_JAR} io.btrace.boot.Loader $* else echo "Please set a valid JAVA_HOME before running this script" exit 1 diff --git a/btrace-dist/src/main/resources/bin/btracep.bat b/btrace-dist/src/main/resources/bin/btracep.bat index 2c1558d09..37ac65086 100644 --- a/btrace-dist/src/main/resources/bin/btracep.bat +++ b/btrace-dist/src/main/resources/bin/btracep.bat @@ -1,4 +1,5 @@ @echo off +setlocal enableextensions rem %~dp0 is expanded pathname of the current script under NT set DEFAULT_BTRACE_HOME=%~dp0.. @@ -6,26 +7,25 @@ set DEFAULT_BTRACE_HOME=%~dp0.. if "%BTRACE_HOME%"=="" set BTRACE_HOME=%DEFAULT_BTRACE_HOME% set DEFAULT_BTRACE_HOME= -if not exist "%BTRACE_HOME%\libs\btrace-client.jar" goto noBTraceHome +set "CLIENT_JAR=%BTRACE_HOME%\libs\btrace.jar" +if not exist "%CLIENT_JAR%" goto noBTraceHome if "%JAVA_HOME%" == "" goto noJavaHome - if exists "%JAVA_HOME%/jmods/" ( - set JAVA_ARGS="%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" + set "JAVA_ARGS=-XX:+IgnoreUnrecognizedVMOptions" + if exist "%JAVA_HOME%/jmods/" ( + set "JAVA_ARGS=%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" + set "JAVA_ARGS=%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" ) if "%1" == "--version" ( - %JAVA_HOME%\bin\java "%JAVA_ARGS%" -cp %BTRACE_HOME%/build/btrace-client.jar org.openjdk.btrace.client.Main --version + "%JAVA_HOME%\bin\java" %JAVA_ARGS% -cp "%CLIENT_JAR%" io.btrace.boot.Loader --version goto end ) - "%JAVA_HOME%/bin/java" "%JAVA_ARGS%" -cp "%BTRACE_HOME%/libs/btrace-client.jar;%JAVA_HOME%/lib/tools.jar" org.openjdk.btrace.client.ProbePrinter $* + "%JAVA_HOME%\bin\java" %JAVA_ARGS% -Dbtrace.client.main=io.btrace.client.ProbePrinter -cp "%CLIENT_JAR%;%JAVA_HOME%\lib\tools.jar" io.btrace.boot.Loader %* goto end :noJavaHome echo Please set JAVA_HOME before running this script goto end :noBTraceHome echo Please set BTRACE_HOME before running this script -:end \ No newline at end of file +:end +endlocal diff --git a/btrace-dist/src/main/resources/bin/btracer b/btrace-dist/src/main/resources/bin/btracer index 0384b974c..caefa1a08 100755 --- a/btrace-dist/src/main/resources/bin/btracer +++ b/btrace-dist/src/main/resources/bin/btracer @@ -40,11 +40,8 @@ JAVA_ARGS="-XX:+IgnoreUnrecognizedVMOptions" if [ -d "${JAVA_HOME}/jmods" ]; then JAVA_ARGS="$JAVA_ARGS -XX:+AllowRedefinitionToAddDeleteMethods" JAVA_ARGS="$JAVA_ARGS --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - JAVA_ARGS="$JAVA_ARGS --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" fi +CLIENT_JAR="${BTRACE_HOME}/libs/btrace.jar" OPTIONS= @@ -83,6 +80,7 @@ if [ -d "${JAVA_HOME}" ]; then ;; -statsd) OPTIONS="statsd=$2,$OPTIONS" + shift ;; --noserver) OPTIONS="noServer=true,$OPTIONS" @@ -91,7 +89,11 @@ if [ -d "${JAVA_HOME}" ]; then OPTIONS="stdout=true,$OPTIONS" ;; --version) - $JAVA_HOME/bin/java ${JAVA_ARGS} -cp ${BTRACE_HOME}/libs/btrace-client.jar org.openjdk.btrace.client.Main --version + if [ -z "${CLIENT_JAR}" ]; then + echo "Please set BTRACE_HOME before running this script" + exit 1 + fi + $JAVA_HOME/bin/java ${JAVA_ARGS} -cp ${CLIENT_JAR} io.btrace.boot.Loader --version exit 0 ;; -h) @@ -104,8 +106,8 @@ if [ -d "${JAVA_HOME}" ]; then shift done - if [ -f "${BTRACE_HOME}/libs/btrace-agent.jar" ]; then - ${JAVA_HOME}/bin/java -Xshare:off ${JAVA_ARGS} -javaagent:${BTRACE_HOME}/libs/btrace-agent.jar=$OPTIONS,script="$@" + if [ -f "${BTRACE_HOME}/libs/btrace.jar" ]; then + ${JAVA_HOME}/bin/java -Xshare:off ${JAVA_ARGS} -javaagent:${BTRACE_HOME}/libs/btrace.jar=$OPTIONS,script="$@" else echo "Please set BTRACE_HOME before running this script" fi diff --git a/btrace-dist/src/main/resources/bin/btracer.bat b/btrace-dist/src/main/resources/bin/btracer.bat index b5a2e46b2..01119dd64 100644 --- a/btrace-dist/src/main/resources/bin/btracer.bat +++ b/btrace-dist/src/main/resources/bin/btracer.bat @@ -1,4 +1,5 @@ @echo off +setlocal enableextensions rem %~dp0 is expanded pathname of the current script under NT set DEFAULT_BTRACE_HOME=%~dp0.. @@ -6,9 +7,10 @@ set DEFAULT_BTRACE_HOME=%~dp0.. if "%BTRACE_HOME%"=="" set BTRACE_HOME=%DEFAULT_BTRACE_HOME% set DEFAULT_BTRACE_HOME= -if not exist "%BTRACE_HOME%\libs \btrace-agent.jar" goto noBTraceHome +set "CLIENT_JAR=%BTRACE_HOME%\libs\btrace.jar" +if not exist "%CLIENT_JAR%" goto noBTraceHome -set OPTIONS= +set "OPTIONS=" if "%1"=="" ( call:usage @@ -16,85 +18,83 @@ if "%1"=="" ( ) if "%JAVA_HOME%" == "" goto noJavaHome -if exists "%JAVA_HOME%/jmods/" ( - set JAVA_ARGS="%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED" - set JAVA_ARGS="%JAVA_ARGS% --add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" +set "JAVA_ARGS=-XX:+IgnoreUnrecognizedVMOptions" + +if exist "%JAVA_HOME%/jmods/" ( + set "JAVA_ARGS=%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" + set "JAVA_ARGS=%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" ) if "%1" == "--version" ( - %JAVA_HOME%\bin\java "%JAVA_ARGS%" -cp %BTRACE_HOME%/build/btrace-client.jar org.openjdk.btrace.client.Main --version + "%JAVA_HOME%\bin\java" %JAVA_ARGS% -cp "%CLIENT_JAR%" io.btrace.boot.Loader --version goto end ) -set inloop=1 :loop IF "%1"=="-v" ( - set OPTIONS="debug=true,%OPTIONS" + set "OPTIONS=debug=true,%OPTIONS%" goto next ) IF "%1"=="-u" ( - set OPTIONS="unsafe=true,%OPTIONS" + set "OPTIONS=unsafe=true,%OPTIONS%" goto next ) if "%1"=="-p" ( - set OPTIONS="port=%2,%OPTIONS" + set "OPTIONS=port=%2,%OPTIONS%" shift goto next ) if "%1"=="-d" ( - set OPTIONS="dumpClasses=true,dumpDir=%2,%OPTIONS" - shift + set "OPTIONS=dumpClasses=true,dumpDir=%2,%OPTIONS%" + shift goto next ) if "%1"=="-o" ( - set OPTIONS="scriptOutputFile=%2,%OPTIONS" + set "OPTIONS=scriptOutputFile=%2,%OPTIONS%" shift goto next ) if "%1"=="-pd" ( - set OPTIONS="probeDescPath=%2,%OPTIONS" + set "OPTIONS=probeDescPath=%2,%OPTIONS%" shift goto next ) if "%1"=="-bcp" ( - OPTIONS="bootClassPath=%2,%OPTIONS" + set "OPTIONS=bootClassPath=%2,%OPTIONS%" shift goto next ) if "%1"=="-scp" ( - set OPTIONS="systemClassPath=%2,%OPTIONS" + set "OPTIONS=systemClassPath=%2,%OPTIONS%" shift goto next ) if "%1"=="--noserver" ( - set OPTIONS="noServer=true,%OPTIONS" + set "OPTIONS=noServer=true,%OPTIONS%" goto next ) if "%1"=="--stdout" ( - set OPTIONS="stdout=true,%OPTIONS" + set "OPTIONS=stdout=true,%OPTIONS%" goto next ) if "%1"=="-statsd" ( - set OPTIONS="statsd=%2,%OPTIONS" + set "OPTIONS=statsd=%2,%OPTIONS%" + shift goto next ) - call :usage - goto end - - set inloop=0 + if "%1"=="-h" ( + call :usage + goto end + ) + goto launch :next - if %inloop==1 ( - shift - goto loop - ) + shift + goto loop -%JAVA_HOME%\bin\java -Xshare:off "%JAVA_ARGS%" "-javaagent:%BTRACE_HOME%/libs/btrace-agent.jar=%OPTIONS,script=%~1" %2 %3 %4 %5 %6 %7 %8 %9 -goto end +:launch + "%JAVA_HOME%\bin\java" -Xshare:off %JAVA_ARGS% "-javaagent:%CLIENT_JAR%=%OPTIONS%,script=%~1" %2 %3 %4 %5 %6 %7 %8 %9 + goto end :noJavaHome echo Please set JAVA_HOME before running this script @@ -120,3 +120,4 @@ goto end echo -h This message :end +endlocal diff --git a/btrace-dist/src/main/resources/bin/btracex b/btrace-dist/src/main/resources/bin/btracex new file mode 100644 index 000000000..c8a48485b --- /dev/null +++ b/btrace-dist/src/main/resources/bin/btracex @@ -0,0 +1,26 @@ +#! /bin/sh + +if [ -z "$BTRACE_HOME" -o ! -d "$BTRACE_HOME" ]; then + PRG="$0" + progname=$(basename "$0") + PRG=$(readlink "$PRG") + if [ -z "$PRG" ]; then PRG=$0; fi + BTRACE_HOME=$(dirname "$PRG")/.. + BTRACE_HOME=$(cd "$BTRACE_HOME" && pwd) +fi + +JAVA_ARGS="-XX:+IgnoreUnrecognizedVMOptions" + +CLIENT_JAR="${BTRACE_HOME}/libs/btrace.jar" +if [ -f "${CLIENT_JAR}" ]; then + if [ -d "${JAVA_HOME}" ]; then + CP="${CLIENT_JAR}" + ${JAVA_HOME}/bin/java ${JAVA_ARGS} -Dbtrace.client.main=io.btrace.extcli.Main -cp ${CP} io.btrace.boot.Loader "$@" + else + echo "Please set a valid JAVA_HOME before running this script" + exit 1 + fi +else + echo "Please set BTRACE_HOME before running this script" + exit 1 +fi diff --git a/btrace-dist/src/main/resources/bin/btracex.bat b/btrace-dist/src/main/resources/bin/btracex.bat new file mode 100644 index 000000000..b79e0cee9 --- /dev/null +++ b/btrace-dist/src/main/resources/bin/btracex.bat @@ -0,0 +1,28 @@ +@echo off +setlocal enableextensions + +if not defined BTRACE_HOME ( + set SCRIPT=%~f0 + for %%i in ("%SCRIPT%") do set BTRACE_HOME=%%~dpi..\ +) + +if not defined JAVA_HOME ( + echo Please set JAVA_HOME before running this script + exit /b 1 +) + +set "JAR=%BTRACE_HOME%\libs\btrace.jar" +if not exist "%JAR%" ( + echo Could not find %JAR% + exit /b 1 +) + +set "JAVA_ARGS=-XX:+IgnoreUnrecognizedVMOptions" +if exist "%JAVA_HOME%/jmods/" ( + set "JAVA_ARGS=%JAVA_ARGS% -XX:+AllowRedefinitionToAddDeleteMethods" + set "JAVA_ARGS=%JAVA_ARGS% --add-exports jdk.internal.jvmstat/sun.jvmstat.monitor=ALL-UNNAMED" +) + +"%JAVA_HOME%\bin\java" %JAVA_ARGS% -Dbtrace.client.main=io.btrace.extcli.Main -cp "%JAR%" io.btrace.boot.Loader %* + +endlocal diff --git a/btrace-dist/src/main/resources/conf/extensions.conf b/btrace-dist/src/main/resources/conf/extensions.conf new file mode 100644 index 000000000..398549e9a --- /dev/null +++ b/btrace-dist/src/main/resources/conf/extensions.conf @@ -0,0 +1,66 @@ +# BTrace Extension Configuration +# +# This file controls which extensions are loaded and how they behave. +# Configuration is read from (in priority order): +# 1. Command-line: -Dbtrace.extensions.config=/path/to/config +# 2. User config: ~/.btrace/extensions.conf +# 3. System config: $BTRACE_HOME/conf/extensions.conf +# +# Only the first file found is used (no merging). + +# ============================================================================ +# Extension Control +# ============================================================================ + +# extensions.enabled +# Whitelist of extension IDs to load (comma-separated). +# If empty or not set, all discovered extensions are enabled. +# If set, ONLY listed extensions will be loaded. +# +# Examples: +# extensions.enabled=btrace-metrics +# extensions.enabled=btrace-metrics,my-custom-extension +# +extensions.enabled= + +# extensions.disabled +# Blacklist of extension IDs to prevent from loading (comma-separated). +# Takes precedence over extensions.enabled. +# Use this to selectively disable specific extensions. +# +# Examples: +# extensions.disabled=btrace-old-version +# extensions.disabled=extension-a,extension-b +# +extensions.disabled= + +# extensions.autoload +# Control when extensions are loaded: +# true = Lazy loading (extensions loaded on demand when scripts use them) +# false = Eager loading (all enabled extensions loaded at agent startup) +# +# Default: true +# Lazy loading reduces startup time and memory usage. +# Eager loading ensures all extensions are available immediately. +# +extensions.autoload=true + +# ============================================================================ +# Extension-Specific Settings +# ============================================================================ + +# Extension-specific properties use the format: +# .= +# +# These settings are passed to the extension when it's loaded. +# Check extension documentation for supported settings. + +# Example: BTrace Metrics Extension Settings +# btrace-metrics.histogram.default-precision=3 +# btrace-metrics.histogram.max-value=3600000000 +# btrace-metrics.stats.window-size=1000 + +# Example: Custom Extension Settings +# my-extension.feature.enabled=true +# my-extension.endpoint=http://localhost:8080 +# my-extension.timeout=5000 diff --git a/btrace-dist/src/main/resources/samples/AWTEventTracer.java b/btrace-dist/src/main/resources/samples/AWTEventTracer.java index 4111d7e23..e9ce5fc32 100644 --- a/btrace-dist/src/main/resources/samples/AWTEventTracer.java +++ b/btrace-dist/src/main/resources/samples/AWTEventTracer.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; import java.awt.*; import java.awt.event.FocusEvent; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This simple script traces every AWT focus event in diff --git a/btrace-dist/src/main/resources/samples/AllCalls1.java b/btrace-dist/src/main/resources/samples/AllCalls1.java index 37bbebe33..83758c74e 100644 --- a/btrace-dist/src/main/resources/samples/AllCalls1.java +++ b/btrace-dist/src/main/resources/samples/AllCalls1.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TargetMethodOrField; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TargetMethodOrField; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/AllCalls1Sampled.java b/btrace-dist/src/main/resources/samples/AllCalls1Sampled.java index bc04872d1..771eee0aa 100644 --- a/btrace-dist/src/main/resources/samples/AllCalls1Sampled.java +++ b/btrace-dist/src/main/resources/samples/AllCalls1Sampled.java @@ -1,39 +1,31 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Sampled; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TargetMethodOrField; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Sampled; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TargetMethodOrField; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/AllCalls2.java b/btrace-dist/src/main/resources/samples/AllCalls2.java index b5d8adb4e..1773f72fb 100644 --- a/btrace-dist/src/main/resources/samples/AllCalls2.java +++ b/btrace-dist/src/main/resources/samples/AllCalls2.java @@ -1,40 +1,32 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TargetInstance; -import org.openjdk.btrace.core.annotations.TargetMethodOrField; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TargetInstance; +import io.btrace.core.annotations.TargetMethodOrField; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/AllCalls2Sampled.java b/btrace-dist/src/main/resources/samples/AllCalls2Sampled.java index 1e5c61f09..de4cf4810 100644 --- a/btrace-dist/src/main/resources/samples/AllCalls2Sampled.java +++ b/btrace-dist/src/main/resources/samples/AllCalls2Sampled.java @@ -1,41 +1,33 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Sampled; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TargetInstance; -import org.openjdk.btrace.core.annotations.TargetMethodOrField; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Sampled; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TargetInstance; +import io.btrace.core.annotations.TargetMethodOrField; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/AllCalls3.java b/btrace-dist/src/main/resources/samples/AllCalls3.java index caeb292cb..2b18cd662 100644 --- a/btrace-dist/src/main/resources/samples/AllCalls3.java +++ b/btrace-dist/src/main/resources/samples/AllCalls3.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.types.AnyType; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.types.AnyType; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.printArray; +import static io.btrace.core.BTraceUtils.printArray; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/AllCalls3Sampled.java b/btrace-dist/src/main/resources/samples/AllCalls3Sampled.java index 9ae345457..478880924 100644 --- a/btrace-dist/src/main/resources/samples/AllCalls3Sampled.java +++ b/btrace-dist/src/main/resources/samples/AllCalls3Sampled.java @@ -1,39 +1,31 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.types.AnyType; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Sampled; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.types.AnyType; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Sampled; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.printArray; +import static io.btrace.core.BTraceUtils.printArray; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/AllLines.java b/btrace-dist/src/main/resources/samples/AllLines.java index d62efc411..d21b19236 100644 --- a/btrace-dist/src/main/resources/samples/AllLines.java +++ b/btrace-dist/src/main/resources/samples/AllLines.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; -import static org.openjdk.btrace.core.BTraceUtils.print; +import static io.btrace.BTrace.print; /* * This sample prints a line every time any line diff --git a/btrace-dist/src/main/resources/samples/AllMethods.java b/btrace-dist/src/main/resources/samples/AllMethods.java index 8c5a992c2..5d8d0dbdb 100644 --- a/btrace-dist/src/main/resources/samples/AllMethods.java +++ b/btrace-dist/src/main/resources/samples/AllMethods.java @@ -1,37 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Injected; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.ServiceType; -import org.openjdk.btrace.services.impl.Printer; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Injected; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Self; +import io.btrace.services.impl.Printer; /** * This script traces method entry into every method of @@ -40,7 +31,7 @@ */ @BTrace public class AllMethods { - @Injected(ServiceType.RUNTIME) + @Injected private static Printer printer; @OnMethod( diff --git a/btrace-dist/src/main/resources/samples/AllMethods1.java b/btrace-dist/src/main/resources/samples/AllMethods1.java index e50fa6dba..e91dab4df 100644 --- a/btrace-dist/src/main/resources/samples/AllMethods1.java +++ b/btrace-dist/src/main/resources/samples/AllMethods1.java @@ -1,36 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.BTrace.*; /** * This script traces method entry into every method of diff --git a/btrace-dist/src/main/resources/samples/AllMethodsLevels.java b/btrace-dist/src/main/resources/samples/AllMethodsLevels.java index f2fcb9013..ac595c015 100644 --- a/btrace-dist/src/main/resources/samples/AllMethodsLevels.java +++ b/btrace-dist/src/main/resources/samples/AllMethodsLevels.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.BTraceUtils; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Level; -import org.openjdk.btrace.core.annotations.OnEvent; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.BTraceUtils; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Level; +import io.btrace.core.annotations.OnEvent; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeMethodName; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This script traces method entry into every method of diff --git a/btrace-dist/src/main/resources/samples/AllMethodsSampled.java b/btrace-dist/src/main/resources/samples/AllMethodsSampled.java index 375849ea1..99d66396e 100644 --- a/btrace-dist/src/main/resources/samples/AllMethodsSampled.java +++ b/btrace-dist/src/main/resources/samples/AllMethodsSampled.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Sampled; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Sampled; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.print; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.print; +import static io.btrace.BTrace.println; /** * This script traces method entry into every method of diff --git a/btrace-dist/src/main/resources/samples/AllSync.java b/btrace-dist/src/main/resources/samples/AllSync.java index 8c953f6db..3efd1cf5d 100644 --- a/btrace-dist/src/main/resources/samples/AllSync.java +++ b/btrace-dist/src/main/resources/samples/AllSync.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Where; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Where; -import static org.openjdk.btrace.core.BTraceUtils.identityStr; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.identityStr; +import static io.btrace.BTrace.println; /** * This script traces method/block entry into every method of diff --git a/btrace-dist/src/main/resources/samples/ArgArray.java b/btrace-dist/src/main/resources/samples/ArgArray.java index 509826d5b..aee4e085f 100644 --- a/btrace-dist/src/main/resources/samples/ArgArray.java +++ b/btrace-dist/src/main/resources/samples/ArgArray.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.types.AnyType; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.types.AnyType; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; -import static org.openjdk.btrace.core.BTraceUtils.printArray; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.printArray; +import static io.btrace.BTrace.println; /** * This sample demonstrates regular expression diff --git a/btrace-dist/src/main/resources/samples/Classload.java b/btrace-dist/src/main/resources/samples/Classload.java index 6955a5b2e..4275ae1e9 100644 --- a/btrace-dist/src/main/resources/samples/Classload.java +++ b/btrace-dist/src/main/resources/samples/Classload.java @@ -1,36 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Return; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Return; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * A simple BTrace program that prints stack trace diff --git a/btrace-dist/src/main/resources/samples/CommandArg.java b/btrace-dist/src/main/resources/samples/CommandArg.java index 8af0493f0..2e235e681 100644 --- a/btrace-dist/src/main/resources/samples/CommandArg.java +++ b/btrace-dist/src/main/resources/samples/CommandArg.java @@ -1,33 +1,25 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * This BTrace program demonstrates command line diff --git a/btrace-dist/src/main/resources/samples/ContractCheck.java b/btrace-dist/src/main/resources/samples/ContractCheck.java new file mode 100644 index 000000000..bc94f2ffc --- /dev/null +++ b/btrace-dist/src/main/resources/samples/ContractCheck.java @@ -0,0 +1,103 @@ +import io.btrace.contracts.ContractService; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Duration; +import io.btrace.core.annotations.Injected; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnEvent; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Return; + +import static io.btrace.core.BTraceUtils.*; + +/** + * Runtime behavioral contracts: latency budgets, call-rate limits, null-safety, and tagged + * code path profiling — without modifying the target code. + * + *

Requires the btrace-contracts extension in $BTRACE_HOME/extensions/. + * + *

Attach to a running JVM: + *

+ * btrace <pid> ContractCheck.java
+ *

+ * + *

Trigger an on-demand summary: + *

+ * btrace <pid> --event summary
+ *

+ */ +@BTrace +public class ContractCheck { + + @Injected + private static ContractService contracts; + + // ==================== Latency budgets ==================== + + /** + * Enforce a 500ms latency budget on all methods in the target package. + * Adjust the clazz pattern to match your project structure. + */ + @OnMethod( + clazz = "/com\\.myapp\\..*/", + method = "/.*/", + location = @Location(Kind.RETURN)) + public static void checkLatency( + @ProbeClassName String cls, + @ProbeMethodName String method, + @Duration long dur) { + contracts.checkLatency(strcat(cls, strcat(".", method)), dur, 500_000_000L); + } + + // ==================== Null safety ==================== + + @OnMethod( + clazz = "/com\\.myapp\\..*/", + method = "/.*/", + location = @Location(Kind.RETURN)) + public static void checkNullReturn( + @ProbeClassName String cls, + @ProbeMethodName String method, + @Return Object ret) { + contracts.checkNotNull(strcat(cls, strcat(".", method)), ret); + } + + // ==================== Tagged path comparison ==================== + + // Example: compare two implementations of the same operation. + // Tag them differently so getSummary() renders them side by side. + + @OnMethod( + clazz = "com.myapp.CachedQueryService", + method = "query", + location = @Location(Kind.RETURN)) + public static void onCachedQuery(@Duration long dur) { + contracts.trackCodePath("QueryService.query", dur, "cached"); + } + + @OnMethod( + clazz = "com.myapp.DirectQueryService", + method = "query", + location = @Location(Kind.RETURN)) + public static void onDirectQuery(@Duration long dur) { + contracts.trackCodePath("QueryService.query", dur, "direct"); + } + + // ==================== Reporting ==================== + + @OnTimer(10000) + public static void periodicCheck() { + if (contracts.hasViolations()) { + println("=== CONTRACT VIOLATIONS DETECTED ==="); + println(contracts.getSummary()); + } + } + + @OnEvent("summary") + public static void onDemandSummary() { + println(contracts.getSummary()); + } +} diff --git a/btrace-dist/src/main/resources/samples/DTraceInline.java b/btrace-dist/src/main/resources/samples/DTraceInline.java index 7bea58c33..ae5d044a5 100644 --- a/btrace-dist/src/main/resources/samples/DTraceInline.java +++ b/btrace-dist/src/main/resources/samples/DTraceInline.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.DTrace; -import org.openjdk.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.DTrace; +import io.btrace.core.annotations.OnMethod; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /* * This sample demonstrates DTrace/BTrace integration. diff --git a/btrace-dist/src/main/resources/samples/DTraceRefDemo.java b/btrace-dist/src/main/resources/samples/DTraceRefDemo.java index 410b4ba37..48fac3fa4 100644 --- a/btrace-dist/src/main/resources/samples/DTraceRefDemo.java +++ b/btrace-dist/src/main/resources/samples/DTraceRefDemo.java @@ -1,36 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.DTraceRef; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.DTraceRef; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /* * This sample demonstrates associating a D-script diff --git a/btrace-dist/src/main/resources/samples/Deadlock.java b/btrace-dist/src/main/resources/samples/Deadlock.java index 5821379bf..9de33d010 100644 --- a/btrace-dist/src/main/resources/samples/Deadlock.java +++ b/btrace-dist/src/main/resources/samples/Deadlock.java @@ -1,33 +1,25 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnTimer; -import static org.openjdk.btrace.core.BTraceUtils.Threads.deadlocks; +import static io.btrace.core.BTraceUtils.Threads.deadlocks; /** * This BTrace program demonstrates deadlocks diff --git a/btrace-dist/src/main/resources/samples/FileTracker.java b/btrace-dist/src/main/resources/samples/FileTracker.java index 618cfe6e1..fb2a60022 100644 --- a/btrace-dist/src/main/resources/samples/FileTracker.java +++ b/btrace-dist/src/main/resources/samples/FileTracker.java @@ -1,41 +1,33 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TLS; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TLS; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.BTrace.*; /** * This sample prints all files opened for read/write @@ -53,7 +45,7 @@ public class FileTracker { method = "" ) public static void onNewFileInputStream(@Self FileInputStream self, File f) { - name = Strings.str(f); + name = str(f); } @OnMethod( diff --git a/btrace-dist/src/main/resources/samples/FileTrackerJfr.java b/btrace-dist/src/main/resources/samples/FileTrackerJfr.java index bbcf421f6..24805c240 100644 --- a/btrace-dist/src/main/resources/samples/FileTrackerJfr.java +++ b/btrace-dist/src/main/resources/samples/FileTrackerJfr.java @@ -1,44 +1,36 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Event; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TLS; -import org.openjdk.btrace.core.jfr.JfrEvent; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Event; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TLS; +import io.btrace.core.jfr.JfrEvent; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; -import static org.openjdk.btrace.core.BTraceUtils.*; -import static org.openjdk.btrace.core.BTraceUtils.Jfr.*; +import static io.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.Jfr.*; /** * This sample prints all files opened for read/write @@ -47,8 +39,17 @@ * that is not tracked by this script. */ @BTrace -public class FileTracker { - @Event(name = "fileEvent", label = "BTrace File Event", description = "Sample BTrace file tracker", category = {"btrace", "samples"}, fields = "string fileName, string operation") +public class FileTrackerJfr { + @Event( + name = "fileEvent", + label = "BTrace File Event", + description = "Sample BTrace file tracker", + category = {"btrace", "samples"}, + fields = { + @Event.Field(type = Event.FieldType.STRING, name = "fileName"), + @Event.Field(type = Event.FieldType.STRING, name = "operation") + } + ) private static JfrEvent.Factory eventFactory; @TLS diff --git a/btrace-dist/src/main/resources/samples/FinalizeTracker.java b/btrace-dist/src/main/resources/samples/FinalizeTracker.java index 1228c9b81..7977ac665 100644 --- a/btrace-dist/src/main/resources/samples/FinalizeTracker.java +++ b/btrace-dist/src/main/resources/samples/FinalizeTracker.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.Self; import java.lang.reflect.Field; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; @BTrace public class FinalizeTracker { diff --git a/btrace-dist/src/main/resources/samples/GpuBridge.java b/btrace-dist/src/main/resources/samples/GpuBridge.java new file mode 100644 index 000000000..b0c81ee52 --- /dev/null +++ b/btrace-dist/src/main/resources/samples/GpuBridge.java @@ -0,0 +1,85 @@ +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Duration; +import io.btrace.core.annotations.Injected; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnEvent; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.gpu.GpuBridgeService; + +import static io.btrace.core.BTraceUtils.*; + +/** + * Traces GPU model inference via ONNX Runtime and DJL (Deep Java Library). + * Tracks inference latency, batch sizes, and model load times. + * + *

Attach to a JVM running ONNX or DJL inference: + *

+ * btrace <pid> GpuBridge.java
+ *

+ */ +@BTrace +public class GpuBridge { + + @Injected + private static GpuBridgeService gpu; + + // ==================== ONNX Runtime ==================== + + @OnMethod( + clazz = "ai.onnxruntime.OrtSession", + method = "run", + location = @Location(Kind.RETURN)) + public static void onOnnxInference(@Duration long dur) { + gpu.recordInference("onnx", "session", dur); + } + + @OnMethod( + clazz = "ai.onnxruntime.OrtSession", + method = "", + location = @Location(Kind.RETURN)) + public static void onOnnxModelLoad(@Duration long dur) { + gpu.recordModelLoad("onnx", "session", dur); + } + + // ==================== DJL (Deep Java Library) ==================== + + @OnMethod( + clazz = "/ai\\.djl\\.inference\\.Predictor/", + method = "predict", + location = @Location(Kind.RETURN)) + public static void onDjlPredict(@Duration long dur) { + gpu.recordInference("djl", "predictor", dur); + } + + @OnMethod( + clazz = "/ai\\.djl\\.repository\\.zoo\\.ModelZoo/", + method = "loadModel", + location = @Location(Kind.RETURN)) + public static void onDjlModelLoad(@Duration long dur) { + gpu.recordModelLoad("djl", "model-zoo", dur); + } + + // ==================== TensorFlow Java ==================== + + @OnMethod( + clazz = "/org\\.tensorflow\\.Session/", + method = "run", + location = @Location(Kind.RETURN)) + public static void onTensorFlowRun(@Duration long dur) { + gpu.recordInference("tensorflow", "session", dur); + } + + // ==================== Periodic summary ==================== + + @OnTimer(30000) + public static void periodicSummary() { + println(gpu.getSummary()); + } + + @OnEvent("summary") + public static void onDemandSummary() { + println(gpu.getSummary()); + } +} diff --git a/btrace-dist/src/main/resources/samples/HistoOnEvent.java b/btrace-dist/src/main/resources/samples/HistoOnEvent.java index 54d9017eb..c696908c3 100644 --- a/btrace-dist/src/main/resources/samples/HistoOnEvent.java +++ b/btrace-dist/src/main/resources/samples/HistoOnEvent.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnEvent; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnEvent; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * This sample collects histogram of javax.swing.JComponets diff --git a/btrace-dist/src/main/resources/samples/Histogram.java b/btrace-dist/src/main/resources/samples/Histogram.java index cc850bcd4..65ee05be7 100644 --- a/btrace-dist/src/main/resources/samples/Histogram.java +++ b/btrace-dist/src/main/resources/samples/Histogram.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.Self; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * This sample collects histogram of javax.swing.JComponets diff --git a/btrace-dist/src/main/resources/samples/HistogramBean.java b/btrace-dist/src/main/resources/samples/HistogramBean.java index aea65a74d..6579dd82b 100644 --- a/btrace-dist/src/main/resources/samples/HistogramBean.java +++ b/btrace-dist/src/main/resources/samples/HistogramBean.java @@ -1,39 +1,31 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.Property; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.Property; +import io.btrace.core.annotations.Self; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * This sample collects histogram of javax.swing.JComponets diff --git a/btrace-dist/src/main/resources/samples/JInfo.java b/btrace-dist/src/main/resources/samples/JInfo.java index ed87979d3..b6a2fc749 100644 --- a/btrace-dist/src/main/resources/samples/JInfo.java +++ b/btrace-dist/src/main/resources/samples/JInfo.java @@ -1,32 +1,24 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.BTrace; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /* * A simple sample that prints system properties, flags and exits. diff --git a/btrace-dist/src/main/resources/samples/JMap.java b/btrace-dist/src/main/resources/samples/JMap.java index ce7baef39..a427ab081 100644 --- a/btrace-dist/src/main/resources/samples/JMap.java +++ b/btrace-dist/src/main/resources/samples/JMap.java @@ -1,33 +1,25 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.BTrace; -import static org.openjdk.btrace.core.BTraceUtils.Sys; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Sys; +import static io.btrace.core.BTraceUtils.println; /* * A simple sample that dumps heap of the target at start and exits. diff --git a/btrace-dist/src/main/resources/samples/JStack.java b/btrace-dist/src/main/resources/samples/JStack.java index 9681026f4..feb67cbec 100644 --- a/btrace-dist/src/main/resources/samples/JStack.java +++ b/btrace-dist/src/main/resources/samples/JStack.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.BTrace; -import static org.openjdk.btrace.core.BTraceUtils.Sys.exit; -import static org.openjdk.btrace.core.BTraceUtils.Threads.deadlocks; -import static org.openjdk.btrace.core.BTraceUtils.Threads.jstackAll; +import static io.btrace.core.BTraceUtils.Sys.exit; +import static io.btrace.core.BTraceUtils.Threads.deadlocks; +import static io.btrace.core.BTraceUtils.Threads.jstackAll; /* * A simple sample prints stack traces and exits. This diff --git a/btrace-dist/src/main/resources/samples/JdbcQueries.java b/btrace-dist/src/main/resources/samples/JdbcQueries.java deleted file mode 100644 index 834895562..000000000 --- a/btrace-dist/src/main/resources/samples/JdbcQueries.java +++ /dev/null @@ -1,167 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - - -import org.openjdk.btrace.core.types.AnyType; -import org.openjdk.btrace.core.aggregation.Aggregation; -import org.openjdk.btrace.core.aggregation.AggregationFunction; -import org.openjdk.btrace.core.aggregation.AggregationKey; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Duration; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnEvent; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Return; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TLS; - -import java.sql.Statement; -import java.util.Map; - -import static org.openjdk.btrace.core.BTraceUtils.*; - -/** - * BTrace script to print timings for all executed JDBC statements on an event. Demonstrates - * different types of aggregation function. - *

- * - * @author Christian Glencross - */ -@BTrace -public class JdbcQueries { - - private static Map preparedStatementDescriptions = Collections.newWeakMap(); - - private static Aggregation histogram = Aggregations.newAggregation(AggregationFunction.QUANTIZE); - - private static Aggregation average = Aggregations.newAggregation(AggregationFunction.AVERAGE); - - private static Aggregation max = Aggregations.newAggregation(AggregationFunction.MAXIMUM); - - private static Aggregation min = Aggregations.newAggregation(AggregationFunction.MINIMUM); - - private static Aggregation sum = Aggregations.newAggregation(AggregationFunction.SUM); - - private static Aggregation count = Aggregations.newAggregation(AggregationFunction.COUNT); - - private static Aggregation globalCount = Aggregations.newAggregation(AggregationFunction.COUNT); - - @TLS - private static String preparingStatement; - - @TLS - private static String executingStatement; - - /** - * If "--stack" is passed on command line, print the Java stack trace of the JDBC statement. - *

- * Otherwise we print the SQL. - */ - private static boolean useStackTrace = Sys.$(2) != null && Strings.strcmp("--stack", Sys.$(2)) == 0; - - // The first couple of probes capture whenever prepared statement and callable statements are - // instantiated, in order to let us track what SQL they contain. - - /** - * Capture SQL used to create prepared statements. - * - * @param args the list of method parameters. args[1] is the SQL. - */ - @OnMethod(clazz = "+java.sql.Connection", method = "/prepare(Call|Statement)/") - public static void onPrepare(AnyType[] args) { - preparingStatement = useStackTrace ? Threads.jstackStr() : str(args[0]); - } - - /** - * Cache SQL associated with a prepared statement. - * - * @param arg the return value from the prepareXxx() method. - */ - @OnMethod(clazz = "+java.sql.Connection", method = "/prepare(Call|Statement)/", location = @Location(Kind.RETURN)) - public static void onPrepareReturn(@Return Statement preparedStatement) { - if (preparingStatement != null) { -// print("P"); // Debug Prepared - Collections.put(preparedStatementDescriptions, preparedStatement, preparingStatement); - preparingStatement = null; - } - } - - // The next couple of probes intercept the execution of a statement. If it execute with no-args, - // then it must be a prepared statement or callable statement. Get the SQL from the probes up above. - // Otherwise the SQL is in the first argument. - - @OnMethod(clazz = "+java.sql.Statement", method = "/execute($|Update|Query|Batch)/") - public static void onExecute(@Self Statement currentStatement, AnyType[] args) { - if (args.length == 0) { - // No SQL argument; lookup the SQL from the prepared statement - executingStatement = Collections.get(preparedStatementDescriptions, (Statement) currentStatement); - } else { - // Direct SQL in the first argument - executingStatement = useStackTrace ? Threads.jstackStr() : str(args[0]); - } - } - - @OnMethod(clazz = "+java.sql.Statement", method = "/execute($|Update|Query|Batch)/", location = @Location(Kind.RETURN)) - public static void onExecuteReturn(@Duration long durationL) { - - if (executingStatement == null) { - return; - } - -// print("X"); // Debug Executed - - AggregationKey key = Aggregations.newAggregationKey(executingStatement); - int duration = (int) durationL / 1000; - - Aggregations.addToAggregation(histogram, key, duration); - Aggregations.addToAggregation(average, key, duration); - Aggregations.addToAggregation(max, key, duration); - Aggregations.addToAggregation(min, key, duration); - Aggregations.addToAggregation(sum, key, duration); - Aggregations.addToAggregation(count, key, duration); - Aggregations.addToAggregation(globalCount, duration); - - executingStatement = null; - } - - @OnEvent - public static void onEvent() { - - // Top 10 queries only - Aggregations.truncateAggregation(histogram, 10); - - println("---------------------------------------------"); - Aggregations.printAggregation("Count", count); - Aggregations.printAggregation("Min", min); - Aggregations.printAggregation("Max", max); - Aggregations.printAggregation("Average", average); - Aggregations.printAggregation("Sum", sum); - Aggregations.printAggregation("Histogram", histogram); - Aggregations.printAggregation("Global Count", globalCount); - println("---------------------------------------------"); - } - -} diff --git a/btrace-dist/src/main/resources/samples/LlmTrace.java b/btrace-dist/src/main/resources/samples/LlmTrace.java new file mode 100644 index 000000000..941d3ddbd --- /dev/null +++ b/btrace-dist/src/main/resources/samples/LlmTrace.java @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the Classpath exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Duration; +import io.btrace.core.annotations.Injected; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnEvent; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.llm.LlmTraceService; + +import static io.btrace.core.BTraceUtils.*; + +/** + * Sample BTrace script that traces LLM API calls using the btrace-llm-trace extension. + * + *

This is a generic template. It intercepts Langchain4j's ChatLanguageModel.generate() + * method and records call metrics. Adapt the @OnMethod annotations to target your specific + * LLM SDK (OpenAI Java SDK, Anthropic Java SDK, Spring AI, etc.). + * + *

Usage: + * btrace <PID> LlmTrace.java + * + *

Send a named event "summary" to print the current stats: + * (Ctrl-C, option 3, enter "summary") + */ +@BTrace +public class LlmTrace { + + @Injected + private static LlmTraceService llm; + + /** + * Trace Langchain4j ChatLanguageModel.generate() calls. + * Captures latency on every call completion. + */ + @OnMethod( + clazz = "+dev.langchain4j.model.chat.ChatLanguageModel", + method = "generate", + location = @Location(Kind.RETURN)) + public static void onLangchain4jGenerate( + @ProbeClassName String className, + @Duration long duration) { + // Model name extracted from the class; token counts need return value parsing + // For a production script, parse the Response return value + llm.recordCall(className, duration); + println(strcat(strcat("LLM call: ", className), strcat(" ", strcat(str(duration / 1000000L), "ms")))); + } + + /** + * Trace Langchain4j StreamingChatLanguageModel calls. + */ + @OnMethod( + clazz = "+dev.langchain4j.model.chat.StreamingChatLanguageModel", + method = "generate", + location = @Location(Kind.RETURN)) + public static void onLangchain4jStreaming( + @ProbeClassName String className, + @Duration long duration) { + llm.call(className).streaming().duration(duration).record(); + } + + /** + * Trace errors from any ChatLanguageModel implementation. + */ + @OnMethod( + clazz = "+dev.langchain4j.model.chat.ChatLanguageModel", + method = "generate", + location = @Location(Kind.ERROR)) + public static void onLangchain4jError( + @ProbeClassName String className, + @Duration long duration) { + llm.recordError(className, "exception", duration); + println(strcat("LLM ERROR in: ", className)); + } + + /** + * Print summary on named event "summary". + */ + @OnEvent("summary") + public static void onSummary() { + println(llm.getSummary()); + } + + /** + * Print summary periodically (every 30 seconds). + */ + @OnTimer(30000) + public static void onTimer() { + if (llm.getTotalCalls() > 0) { + println(llm.getSummary()); + } + } +} diff --git a/btrace-dist/src/main/resources/samples/LogTracer.java b/btrace-dist/src/main/resources/samples/LogTracer.java index 50e914c66..95b813ba3 100644 --- a/btrace-dist/src/main/resources/samples/LogTracer.java +++ b/btrace-dist/src/main/resources/samples/LogTracer.java @@ -1,39 +1,31 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; import java.lang.reflect.Field; import java.util.logging.LogRecord; import java.util.logging.Logger; -import static org.openjdk.btrace.core.BTraceUtils.Reflective; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Reflective; +import static io.btrace.core.BTraceUtils.println; /** * Simple log message tracer class. This class diff --git a/btrace-dist/src/main/resources/samples/MemAlerter.java b/btrace-dist/src/main/resources/samples/MemAlerter.java index 4d6f6487a..5cb90197c 100644 --- a/btrace-dist/src/main/resources/samples/MemAlerter.java +++ b/btrace-dist/src/main/resources/samples/MemAlerter.java @@ -1,35 +1,27 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnLowMemory; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnLowMemory; import java.lang.management.MemoryUsage; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This sample traces memory threshold exceeds. diff --git a/btrace-dist/src/main/resources/samples/Memory.java b/btrace-dist/src/main/resources/samples/Memory.java index 79ad6642b..b7f0085b7 100644 --- a/btrace-dist/src/main/resources/samples/Memory.java +++ b/btrace-dist/src/main/resources/samples/Memory.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnTimer; -import static org.openjdk.btrace.core.BTraceUtils.Sys; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Sys; +import static io.btrace.core.BTraceUtils.println; /** * Simple BTrace program that prints memory diff --git a/btrace-dist/src/main/resources/samples/MultiClass.java b/btrace-dist/src/main/resources/samples/MultiClass.java index 692fac9e8..7ace1eb09 100644 --- a/btrace-dist/src/main/resources/samples/MultiClass.java +++ b/btrace-dist/src/main/resources/samples/MultiClass.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This BTrace class demonstrates that we can diff --git a/btrace-dist/src/main/resources/samples/NewArray.java b/btrace-dist/src/main/resources/samples/NewArray.java index f5fbede8a..c4e94148d 100644 --- a/btrace-dist/src/main/resources/samples/NewArray.java +++ b/btrace-dist/src/main/resources/samples/NewArray.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This script demonstrates the possibility to intercept diff --git a/btrace-dist/src/main/resources/samples/NewComponent.java b/btrace-dist/src/main/resources/samples/NewComponent.java index f1d5bf661..179651dd7 100644 --- a/btrace-dist/src/main/resources/samples/NewComponent.java +++ b/btrace-dist/src/main/resources/samples/NewComponent.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.Self; import java.awt.*; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * A BTrace program that can be run against a GUI diff --git a/btrace-dist/src/main/resources/samples/OnThrow.java b/btrace-dist/src/main/resources/samples/OnThrow.java index bd5890cb8..bb34db276 100644 --- a/btrace-dist/src/main/resources/samples/OnThrow.java +++ b/btrace-dist/src/main/resources/samples/OnThrow.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TLS; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TLS; -import static org.openjdk.btrace.core.BTraceUtils.Threads; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Threads; +import static io.btrace.core.BTraceUtils.println; /** * This example demonstrates printing stack trace diff --git a/btrace-dist/src/main/resources/samples/ProbeArgs.java b/btrace-dist/src/main/resources/samples/ProbeArgs.java index 9909df9d0..1f786b575 100644 --- a/btrace-dist/src/main/resources/samples/ProbeArgs.java +++ b/btrace-dist/src/main/resources/samples/ProbeArgs.java @@ -1,3 +1,21 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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. + */ + + /* * Copyright (c) 2018, Jaroslav Bachorik . * All rights reserved. @@ -21,10 +39,10 @@ */ -import org.openjdk.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.BTrace; -import static org.openjdk.btrace.core.BTraceUtils.Sys; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Sys; +import static io.btrace.core.BTraceUtils.println; @BTrace(trusted = true) public class ProbeArgs { diff --git a/btrace-dist/src/main/resources/samples/ProbeExit.java b/btrace-dist/src/main/resources/samples/ProbeExit.java index 72e52aabb..2d6b06cbf 100644 --- a/btrace-dist/src/main/resources/samples/ProbeExit.java +++ b/btrace-dist/src/main/resources/samples/ProbeExit.java @@ -1,35 +1,27 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnExit; -import org.openjdk.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnExit; +import io.btrace.core.annotations.OnTimer; -import static org.openjdk.btrace.core.BTraceUtils.Sys; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Sys; +import static io.btrace.core.BTraceUtils.println; /** * This program demonstrates OnExit probe. diff --git a/btrace-dist/src/main/resources/samples/Profiling.java b/btrace-dist/src/main/resources/samples/Profiling.java index 066cac2cf..5db683b05 100644 --- a/btrace-dist/src/main/resources/samples/Profiling.java +++ b/btrace-dist/src/main/resources/samples/Profiling.java @@ -1,39 +1,31 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.Profiler; -import org.openjdk.btrace.core.BTraceUtils; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Duration; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.ProbeMethodName; -import org.openjdk.btrace.core.annotations.Property; +import io.btrace.core.Profiler; +import io.btrace.core.BTraceUtils; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Duration; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.Property; /** * This script demonstrates new capabilities built into BTrace 1.2 diff --git a/btrace-dist/src/main/resources/samples/RagQuality.java b/btrace-dist/src/main/resources/samples/RagQuality.java new file mode 100644 index 000000000..960fee8b8 --- /dev/null +++ b/btrace-dist/src/main/resources/samples/RagQuality.java @@ -0,0 +1,79 @@ +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Duration; +import io.btrace.core.annotations.Injected; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnEvent; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.rag.RagQualityService; + +import static io.btrace.core.BTraceUtils.*; + +/** + * Traces RAG pipeline performance: vector DB query latency, similarity + * scores, and empty retrieval rates. Targets Pinecone Java client. + * + *

Attach to a JVM running a RAG pipeline: + *

+ * btrace <pid> RagQuality.java
+ *

+ */ +@BTrace +public class RagQuality { + + @Injected + private static RagQualityService rag; + + // ==================== Pinecone ==================== + + @OnMethod( + clazz = "/io\\.pinecone\\..*/", + method = "query", + location = @Location(Kind.RETURN)) + public static void onPineconeQuery(@Duration long dur) { + rag.recordQuery("pinecone", dur); + } + + // ==================== Milvus ==================== + + @OnMethod( + clazz = "/io\\.milvus\\.client\\..*/", + method = "search", + location = @Location(Kind.RETURN)) + public static void onMilvusSearch(@Duration long dur) { + rag.recordQuery("milvus", dur); + } + + // ==================== Weaviate ==================== + + @OnMethod( + clazz = "/io\\.weaviate\\.client\\..*/", + method = "/get|search/", + location = @Location(Kind.RETURN)) + public static void onWeaviateQuery(@Duration long dur) { + rag.recordQuery("weaviate", dur); + } + + // ==================== Chroma ==================== + + @OnMethod( + clazz = "/tech\\.amikos\\.chromadb\\..*/", + method = "query", + location = @Location(Kind.RETURN)) + public static void onChromaQuery(@Duration long dur) { + rag.recordQuery("chroma", dur); + } + + // ==================== Periodic summary ==================== + + @OnTimer(30000) + public static void periodicSummary() { + println(rag.getSummary()); + } + + @OnEvent("summary") + public static void onDemandSummary() { + println(rag.getSummary()); + } +} diff --git a/btrace-dist/src/main/resources/samples/Sizeof.java b/btrace-dist/src/main/resources/samples/Sizeof.java index a9965546b..302bc4ecd 100644 --- a/btrace-dist/src/main/resources/samples/Sizeof.java +++ b/btrace-dist/src/main/resources/samples/Sizeof.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; @BTrace public class Sizeof { diff --git a/btrace-dist/src/main/resources/samples/SocketTracker.java b/btrace-dist/src/main/resources/samples/SocketTracker.java index 561c76a79..c309d1548 100644 --- a/btrace-dist/src/main/resources/samples/SocketTracker.java +++ b/btrace-dist/src/main/resources/samples/SocketTracker.java @@ -1,36 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Return; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TLS; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Return; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TLS; import java.net.InetAddress; import java.net.ServerSocket; @@ -38,8 +30,8 @@ import java.net.SocketAddress; import java.nio.channels.SocketChannel; -import static org.openjdk.btrace.core.BTraceUtils.Strings; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Strings; +import static io.btrace.core.BTraceUtils.println; /** * This example tracks all server socket creations diff --git a/btrace-dist/src/main/resources/samples/SocketTracker1.java b/btrace-dist/src/main/resources/samples/SocketTracker1.java index b2e7bbfc5..b0ca8b609 100644 --- a/btrace-dist/src/main/resources/samples/SocketTracker1.java +++ b/btrace-dist/src/main/resources/samples/SocketTracker1.java @@ -1,44 +1,36 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.types.AnyType; -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnProbe; -import org.openjdk.btrace.core.annotations.Return; -import org.openjdk.btrace.core.annotations.Self; -import org.openjdk.btrace.core.annotations.TLS; +import io.btrace.core.types.AnyType; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnProbe; +import io.btrace.core.annotations.Return; +import io.btrace.core.annotations.Self; +import io.btrace.core.annotations.TLS; import java.net.InetAddress; import java.net.ServerSocket; import java.net.SocketAddress; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This example tracks all server socket creations diff --git a/btrace-dist/src/main/resources/samples/SubtypeTracer.java b/btrace-dist/src/main/resources/samples/SubtypeTracer.java index 6209374d8..6d02077c4 100644 --- a/btrace-dist/src/main/resources/samples/SubtypeTracer.java +++ b/btrace-dist/src/main/resources/samples/SubtypeTracer.java @@ -1,36 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; -import static org.openjdk.btrace.core.BTraceUtils.print; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.print; +import static io.btrace.BTrace.println; /** * A simple example that demonstrates subtype matching by +foo pattern diff --git a/btrace-dist/src/main/resources/samples/SysProp.java b/btrace-dist/src/main/resources/samples/SysProp.java index 78b47c4c4..e0e4d4052 100644 --- a/btrace-dist/src/main/resources/samples/SysProp.java +++ b/btrace-dist/src/main/resources/samples/SysProp.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; -import static org.openjdk.btrace.core.BTraceUtils.Sys; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Sys; +import static io.btrace.core.BTraceUtils.println; /** * This BTrace script demonstrates that it is okay diff --git a/btrace-dist/src/main/resources/samples/Test.java b/btrace-dist/src/main/resources/samples/Test.java index 56e6b13e4..823a3f618 100644 --- a/btrace-dist/src/main/resources/samples/Test.java +++ b/btrace-dist/src/main/resources/samples/Test.java @@ -1,31 +1,23 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.DTraceRef; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.DTraceRef; @DTraceRef("syscalls.d") @BTrace diff --git a/btrace-dist/src/main/resources/samples/ThreadBean.java b/btrace-dist/src/main/resources/samples/ThreadBean.java index 169fd8ffd..0e660bc8e 100644 --- a/btrace-dist/src/main/resources/samples/ThreadBean.java +++ b/btrace-dist/src/main/resources/samples/ThreadBean.java @@ -1,30 +1,21 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ - /* * This sample demonstrates simple preprocessor in BTrace. * When you run this sample against a Java process, you have diff --git a/btrace-dist/src/main/resources/samples/ThreadCounter.java b/btrace-dist/src/main/resources/samples/ThreadCounter.java index 297dd952c..2a65c6a41 100644 --- a/btrace-dist/src/main/resources/samples/ThreadCounter.java +++ b/btrace-dist/src/main/resources/samples/ThreadCounter.java @@ -1,37 +1,29 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Export; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Export; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.Counters; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.core.BTraceUtils.Counters; +import static io.btrace.core.BTraceUtils.println; /** * This sample creates a jvmstat counter and @@ -64,6 +56,6 @@ public static void ontimer() { // as from jvmstat counter directly. println(count); // or equivalently ... - println(Counters.perfLong("btrace.org.openjdk.btrace.samples.ThreadCounter.count")); + println(Counters.perfLong("btrace.io.btrace.samples.ThreadCounter.count")); } } diff --git a/btrace-dist/src/main/resources/samples/ThreadCounterBean.java b/btrace-dist/src/main/resources/samples/ThreadCounterBean.java index 8958b0f73..8ec7ee5a4 100644 --- a/btrace-dist/src/main/resources/samples/ThreadCounterBean.java +++ b/btrace-dist/src/main/resources/samples/ThreadCounterBean.java @@ -1,36 +1,28 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.OnTimer; -import org.openjdk.btrace.core.annotations.Property; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.Property; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.println; +import static io.btrace.BTrace.println; /** * This sample demonstrates that you can expose a BTrace diff --git a/btrace-dist/src/main/resources/samples/ThreadStart.java b/btrace-dist/src/main/resources/samples/ThreadStart.java index d2baab8ad..19f6b350d 100644 --- a/btrace-dist/src/main/resources/samples/ThreadStart.java +++ b/btrace-dist/src/main/resources/samples/ThreadStart.java @@ -1,34 +1,26 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.Self; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.Self; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /* * This BTrace script inserts a probe into diff --git a/btrace-dist/src/main/resources/samples/Timers.java b/btrace-dist/src/main/resources/samples/Timers.java index 3fe5d1ff7..542ac2937 100644 --- a/btrace-dist/src/main/resources/samples/Timers.java +++ b/btrace-dist/src/main/resources/samples/Timers.java @@ -1,33 +1,25 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.OnTimer; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.OnTimer; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * Demonstrates multiple timer probes with different periods to fire. diff --git a/btrace-dist/src/main/resources/samples/URLTracker.java b/btrace-dist/src/main/resources/samples/URLTracker.java index 3a68cff42..6e75f0258 100644 --- a/btrace-dist/src/main/resources/samples/URLTracker.java +++ b/btrace-dist/src/main/resources/samples/URLTracker.java @@ -1,40 +1,32 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.DTraceRef; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.TLS; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.DTraceRef; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.TLS; import java.net.Proxy; import java.net.URL; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /* * This sample prints every Java URL openURL and diff --git a/btrace-dist/src/main/resources/samples/WebServiceTracker.java b/btrace-dist/src/main/resources/samples/WebServiceTracker.java index aafd93110..da240107b 100644 --- a/btrace-dist/src/main/resources/samples/WebServiceTracker.java +++ b/btrace-dist/src/main/resources/samples/WebServiceTracker.java @@ -1,38 +1,30 @@ /* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. + * 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 * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). + * https://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. + * 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. */ -import org.openjdk.btrace.core.annotations.BTrace; -import org.openjdk.btrace.core.annotations.Duration; -import org.openjdk.btrace.core.annotations.Kind; -import org.openjdk.btrace.core.annotations.Location; -import org.openjdk.btrace.core.annotations.OnMethod; -import org.openjdk.btrace.core.annotations.ProbeClassName; -import org.openjdk.btrace.core.annotations.ProbeMethodName; +import io.btrace.core.annotations.BTrace; +import io.btrace.core.annotations.Duration; +import io.btrace.core.annotations.Kind; +import io.btrace.core.annotations.Location; +import io.btrace.core.annotations.OnMethod; +import io.btrace.core.annotations.ProbeClassName; +import io.btrace.core.annotations.ProbeMethodName; -import static org.openjdk.btrace.core.BTraceUtils.*; +import static io.btrace.core.BTraceUtils.*; /** * A simple BTrace program that prints a class name diff --git a/btrace-dist/src/main/resources/samples/btracedefs.h b/btrace-dist/src/main/resources/samples/btracedefs.h index fc8203f60..b96a065e7 100644 --- a/btrace-dist/src/main/resources/samples/btracedefs.h +++ b/btrace-dist/src/main/resources/samples/btracedefs.h @@ -24,9 +24,9 @@ */ -#define BTRACE_UTILS import static org.openjdk.btrace.core.BTraceUtils.*; +#define BTRACE_UTILS import static io.btrace.core.BTraceUtils.*; -#define BTRACE_ANNO import org.openjdk.btrace.core.annotations.*; +#define BTRACE_ANNO import io.btrace.core.annotations.*; #define BTRACE_IMPORT BTRACE_UTILS \ BTRACE_ANNO @@ -41,4 +41,4 @@ #define THREAD @Thread public static -#define PROPERTY @Property public static \ No newline at end of file +#define PROPERTY @Property public static diff --git a/btrace-dist/src/test/java/io/btrace/dist/BTraceJarPackagingTest.java b/btrace-dist/src/test/java/io/btrace/dist/BTraceJarPackagingTest.java new file mode 100644 index 000000000..95d39d23e --- /dev/null +++ b/btrace-dist/src/test/java/io/btrace/dist/BTraceJarPackagingTest.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dist; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.IOException; +import java.util.jar.Attributes; +import java.util.jar.JarFile; +import org.junit.jupiter.api.Test; + +class BTraceJarPackagingTest { + + @Test + void includesBootstrapLoaderInRootJar() throws IOException { + File resourcesDir = new File("build/resources/main"); + File[] versionDirs = resourcesDir.listFiles(File::isDirectory); + assertNotNull(versionDirs, "Expected versioned dist directory under build/resources/main"); + assertEquals(1, versionDirs.length, "Expected exactly one versioned dist directory"); + + File btraceJar = new File(versionDirs[0], "libs/btrace.jar"); + assertTrue(btraceJar.isFile(), "Expected assembled btrace.jar to exist"); + + try (JarFile jarFile = new JarFile(btraceJar)) { + assertNotNull( + jarFile.getJarEntry("io/btrace/boot/Loader.class"), + "Expected bootstrap loader class in root of masked JAR"); + assertNotNull( + jarFile.getJarEntry("META-INF/btrace/client/io/btrace/client/Main.classdata"), + "Expected masked client main class in client section"); + + Attributes attributes = jarFile.getManifest().getMainAttributes(); + assertEquals("io.btrace.boot.Loader", attributes.getValue("Main-Class")); + } + } +} diff --git a/btrace-dtrace/build.gradle b/btrace-dtrace/build.gradle index ec686e356..66c4c7461 100644 --- a/btrace-dtrace/build.gradle +++ b/btrace-dtrace/build.gradle @@ -2,8 +2,8 @@ import org.gradle.internal.os.OperatingSystem import org.gradle.internal.jvm.Jvm plugins { - id 'com.github.johnrengelman.shadow' version '6.1.0' id 'java' + alias(libs.plugins.shadow) } def nativeHeadersDir = "${buildDir}/generated/native/include" @@ -13,12 +13,15 @@ def isSolaris = OperatingSystem.current() == OperatingSystem.SOLARIS def osArch = System.getProperty("os.arch") dependencies { - compile project(':btrace-core') + implementation libs.slf4j + implementation libs.slf4j.simple + + implementation project(':btrace-core') } task nativeHeaders(type:Exec) { def classpath = sourceSets.main.runtimeClasspath.asPath - commandLine "javah", "-d", nativeHeadersDir, "-classpath", classpath, "org.openjdk.btrace.core.BTraceRuntime" + commandLine "javah", "-d", nativeHeadersDir, "-classpath", classpath, "io.btrace.core.BTraceRuntime" dependsOn classes } @@ -54,7 +57,11 @@ sourceSets { shadowJar { include 'org/openjdk/btrace/dtrace/**/*' - classifier = null + archiveClassifier = null +} + +sourcesJar { + duplicatesStrategy DuplicatesStrategy.EXCLUDE } build.dependsOn shadowJar diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTrace.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTrace.java new file mode 100644 index 000000000..801ebd1bc --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTrace.java @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import io.btrace.core.comm.Command; +import io.btrace.core.comm.CommandListener; +import io.btrace.core.comm.ErrorCommand; +import io.btrace.core.comm.MessageCommand; +import java.io.File; +import java.io.IOException; +import org.opensolaris.os.dtrace.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Simple wrapper class around DTrace/Java API. This wrapper accepts a BTrace command listener, + * DTrace file or string and DTrace macro arguments. The events from DTrace are wrapped as BTrace + * command instances and given to the listener. + * + * @author A. Sundararajan + */ +@SuppressWarnings("RedundantThrows") +public class DTrace { + private static final Logger log = LoggerFactory.getLogger(DTrace.class); + + /** + * Submits a D-script from given file and passes given argument array as DTrace macro arguments. + * The events from DTrace are wrapped as BTrace commands and listener given is notified. + * + * @param file D-script file to submit + * @param args DTrace macro arguments + * @param listener BTrace command listener that is notified + */ + public static void submit(File file, String[] args, CommandListener listener) + throws DTraceException, IOException { + Consumer cons = newConsumer(args, listener); + cons.compile(file, args); + start(cons, listener); + } + + /** + * Submits a D-script string and passes the given argument array as DTrace macro arguments. The + * events from DTrace are wrapped as BTrace commands and listener given is notified. + * + * @param program D-script as a string + * @param args DTrace macro arguments + * @param listener BTrace command listener that is notified + */ + public static void submit(String program, String[] args, CommandListener listener) + throws DTraceException { + Consumer cons = newConsumer(args, listener); + cons.compile(program, args); + start(cons, listener); + } + + private static void start(Consumer cons, CommandListener listener) throws DTraceException { + cons.enable(); + cons.go( + th -> { + try { + listener.onCommand(new ErrorCommand(th)); + } catch (IOException ioexp) { + log.error("Failed to send error command to listener", ioexp); + } + }); + } + + private static Consumer newConsumer(String[] args, CommandListener listener) + throws DTraceException { + Consumer cons = new LocalConsumer(); + cons.addConsumerListener( + new ConsumerAdapter() { + private void notify(Command cmd) { + try { + listener.onCommand(cmd); + } catch (IOException ioexp) { + log.error("Failed to send command to listener", ioexp); + } + } + + @Override + public void consumerStarted(ConsumerEvent ce) { + notify(new DTraceStartCommand(ce)); + } + + @Override + public void consumerStopped(ConsumerEvent ce) { + Consumer cons = ce.getSource(); + Aggregate ag = null; + try { + ag = cons.getAggregate(); + } catch (DTraceException dexp) { + notify(new ErrorCommand(dexp)); + } + StringBuilder buf = new StringBuilder(); + if (ag != null) { + for (Aggregation agg : ag.asMap().values()) { + String name = agg.getName(); + if (name != null && name.length() > 0) { + buf.append(name); + buf.append('\n'); + } + for (AggregationRecord rec : agg.asMap().values()) { + buf.append('\t'); + buf.append(rec.getTuple()); + buf.append(" "); + buf.append(rec.getValue()); + buf.append('\n'); + } + } + } + String msg = buf.toString(); + if (msg.length() > 0) { + notify(new MessageCommand(msg)); + } + notify(new DTraceStopCommand(ce)); + cons.close(); + } + + @Override + public void dataReceived(DataEvent de) { + notify(new DTraceDataCommand(de)); + } + + @Override + public void dataDropped(DropEvent de) { + notify(new DTraceDropCommand(de)); + } + + @Override + public void errorEncountered(ErrorEvent ee) throws ConsumerException { + try { + super.errorEncountered(ee); + } catch (ConsumerException ce) { + notify(new DTraceErrorCommand(ce, ee)); + throw ce; + } + } + }); + + // open DTrace Consumer + cons.open(); + + // unused macro arguments are fine + cons.setOption(Option.argref, ""); + // if no macro arg passed use "" or NULL + cons.setOption(Option.defaultargs, ""); + // allow empty D-scripts + cons.setOption(Option.empty, ""); + // be quiet! equivalent to DTrace's -q + cons.setOption(Option.quiet, ""); + // undefined user land symbols are fine + cons.setOption(Option.unodefs, ""); + // allow zero matching of probes (needed for late loading) + cons.setOption(Option.zdefs, ""); + try { + int pid = Integer.parseInt(args[0]); + cons.grabProcess(pid); + } catch (Exception ignored) { + } + return cons; + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceCommand.java new file mode 100644 index 000000000..a2d342740 --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceCommand.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +/** + * A marker interface to tell whether a given BTrace command is a wrapper of a DTrace event. + * + * @author A. Sundararajan + */ +public interface DTraceCommand {} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceConsumerCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceConsumerCommand.java new file mode 100644 index 000000000..679b7f342 --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceConsumerCommand.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import io.btrace.core.comm.EventCommand; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import org.opensolaris.os.dtrace.Consumer; +import org.opensolaris.os.dtrace.ConsumerEvent; + +/** + * Abstract command to represent consumer event from DTrace. + * + * @author A. Sundararajan + */ +public abstract class DTraceConsumerCommand extends EventCommand implements DTraceCommand { + private ConsumerEvent ce; + + public DTraceConsumerCommand(String type, ConsumerEvent ce) { + super(type); + this.ce = ce; + } + + /** Returns the underlying DTrace ConsumerEvent. */ + public ConsumerEvent getConsumerEvent() { + return ce; + } + + /** Returns the Consumer object. */ + public Consumer getConsumer() { + return ce.getSource(); + } + + public void write(ObjectOutput out) throws IOException { + out.writeObject(ce); + } + + public void read(ObjectInput in) throws ClassNotFoundException, IOException { + ce = (ConsumerEvent) in.readObject(); + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceDataCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceDataCommand.java new file mode 100644 index 000000000..681d8d872 --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceDataCommand.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import io.btrace.core.comm.MessageCommand; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.util.List; +import org.opensolaris.os.dtrace.DataEvent; +import org.opensolaris.os.dtrace.ProbeData; +import org.opensolaris.os.dtrace.Record; + +/** + * Command to represent data event from DTrace. + * + * @author A. Sundararajan + */ +public class DTraceDataCommand extends MessageCommand implements DTraceCommand { + private DataEvent de; + + public DTraceDataCommand(DataEvent de) { + super(asString(de), true); + this.de = de; + } + + /** Returns the underlying DTrace DataEvent. */ + public DataEvent getDataEvent() { + return de; + } + + public void write(ObjectOutput out) throws IOException { + super.write(out); + out.writeObject(de); + } + + public void read(ObjectInput in) throws ClassNotFoundException, IOException { + super.read(in); + de = (DataEvent) in.readObject(); + } + + private static String asString(DataEvent de) { + ProbeData pd = de.getProbeData(); + List records = pd.getRecords(); + StringBuilder buf = new StringBuilder(); + for (Record rec : records) { + buf.append(rec); + } + return buf.toString(); + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceDropCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceDropCommand.java new file mode 100644 index 000000000..4b6a417ad --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceDropCommand.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import io.btrace.core.comm.MessageCommand; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import org.opensolaris.os.dtrace.DropEvent; + +/** + * Command class that represents DTrace drop event. + * + * @author A. Sundararajan + */ +public class DTraceDropCommand extends MessageCommand implements DTraceCommand { + private DropEvent de; + + public DTraceDropCommand(DropEvent de) { + super(asString(de), true); + this.de = de; + } + + /** Returns the underlying DTrace drop event */ + public DropEvent getDropEvent() { + return de; + } + + public void write(ObjectOutput out) throws IOException { + super.write(out); + out.writeObject(out); + } + + public void read(ObjectInput in) throws ClassNotFoundException, IOException { + super.read(in); + de = (DropEvent) in.readObject(); + } + + private static String asString(DropEvent de) { + return de.getDrop().getDefaultMessage(); + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceErrorCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceErrorCommand.java new file mode 100644 index 000000000..1a6baa21f --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceErrorCommand.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import io.btrace.core.comm.ErrorCommand; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import org.opensolaris.os.dtrace.ErrorEvent; + +/** + * Command that represents error message from DTrace. + * + * @author A. Sundararajan + */ +public class DTraceErrorCommand extends ErrorCommand implements DTraceCommand { + private ErrorEvent ee; + + public DTraceErrorCommand(Exception exp, ErrorEvent ee) { + super(exp); + this.ee = ee; + } + + /** Returns the underlying DTrace error event. */ + public ErrorEvent getErrorEvent() { + return ee; + } + + public void write(ObjectOutput out) throws IOException { + super.write(out); + out.writeObject(ee); + } + + public void read(ObjectInput in) throws ClassNotFoundException, IOException { + super.read(in); + ee = (ErrorEvent) in.readObject(); + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceExtension.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceExtension.java new file mode 100644 index 000000000..db9575fea --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceExtension.java @@ -0,0 +1,204 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import io.btrace.core.comm.Command; +import io.btrace.core.comm.ErrorCommand; +import io.btrace.core.comm.MessageCommand; +import io.btrace.core.extensions.Extension; +import io.btrace.core.extensions.ExtensionContext; +import java.io.File; +import java.io.IOException; +import org.opensolaris.os.dtrace.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * DTrace extension for BTrace. + * + *

Provides integration with Solaris DTrace for executing D-scripts from BTrace. + * + *

Use the following code to obtain an instance: + * + *

Example usage: + * + *


+ * {@literal @}Injected
+ * private static DTraceExtension dtrace;
+ *

+ */ +public final class DTraceExtension extends Extension { + private static final Logger log = LoggerFactory.getLogger(DTraceExtension.class); + + private volatile ExtensionContext ctx; + private volatile Consumer consumer; + + @Override + public void initialize(ExtensionContext ctx) { + super.initialize(ctx); + this.ctx = ctx; + } + + @Override + public void close() { + Consumer cons = this.consumer; + if (cons != null) { + try { + cons.close(); + } catch (Exception e) { + log.debug("Error closing DTrace consumer", e); + } + this.consumer = null; + } + } + + /** + * Submits a D-script from the given file. + * + * @param file D-script file to submit + * @param args DTrace macro arguments + * @throws DTraceException if compilation or execution fails + * @throws IOException if file cannot be read + */ + public void submit(File file, String[] args) throws DTraceException, IOException { + Consumer cons = newConsumer(args); + cons.compile(file, args); + start(cons); + } + + /** + * Submits a D-script string. + * + * @param program D-script as a string + * @param args DTrace macro arguments + * @throws DTraceException if compilation or execution fails + */ + public void submit(String program, String[] args) throws DTraceException { + Consumer cons = newConsumer(args); + cons.compile(program, args); + start(cons); + } + + private void start(Consumer cons) throws DTraceException { + cons.enable(); + cons.go( + th -> { + send(new ErrorCommand(th)); + }); + } + + private Consumer newConsumer(String[] args) throws DTraceException { + Consumer cons = new LocalConsumer(); + this.consumer = cons; + + cons.addConsumerListener( + new ConsumerAdapter() { + @Override + public void consumerStarted(ConsumerEvent ce) { + send(new DTraceStartCommand(ce)); + } + + @Override + public void consumerStopped(ConsumerEvent ce) { + Consumer c = ce.getSource(); + Aggregate ag = null; + try { + ag = c.getAggregate(); + } catch (DTraceException dexp) { + send(new ErrorCommand(dexp)); + } + StringBuilder buf = new StringBuilder(); + if (ag != null) { + for (Aggregation agg : ag.asMap().values()) { + String name = agg.getName(); + if (name != null && name.length() > 0) { + buf.append(name); + buf.append('\n'); + } + for (AggregationRecord rec : agg.asMap().values()) { + buf.append('\t'); + buf.append(rec.getTuple()); + buf.append(" "); + buf.append(rec.getValue()); + buf.append('\n'); + } + } + } + String msg = buf.toString(); + if (msg.length() > 0) { + send(new MessageCommand(msg)); + } + send(new DTraceStopCommand(ce)); + c.close(); + } + + @Override + public void dataReceived(DataEvent de) { + send(new DTraceDataCommand(de)); + } + + @Override + public void dataDropped(DropEvent de) { + send(new DTraceDropCommand(de)); + } + + @Override + public void errorEncountered(ErrorEvent ee) throws ConsumerException { + try { + super.errorEncountered(ee); + } catch (ConsumerException ce) { + send(new DTraceErrorCommand(ce, ee)); + throw ce; + } + } + }); + + // open DTrace Consumer + cons.open(); + + // unused macro arguments are fine + cons.setOption(Option.argref, ""); + // if no macro arg passed use "" or NULL + cons.setOption(Option.defaultargs, ""); + // allow empty D-scripts + cons.setOption(Option.empty, ""); + // be quiet! equivalent to DTrace's -q + cons.setOption(Option.quiet, ""); + // undefined user land symbols are fine + cons.setOption(Option.unodefs, ""); + // allow zero matching of probes (needed for late loading) + cons.setOption(Option.zdefs, ""); + if (args != null && args.length > 0) { + try { + int pid = Integer.parseInt(args[0]); + cons.grabProcess(pid); + } catch (NumberFormatException e) { + log.debug("First argument '{}' is not a valid PID, skipping process grab", args[0]); + } catch (Exception e) { + log.warn("Failed to grab process with PID '{}': {}", args[0], e.getMessage()); + } + } + return cons; + } + + private void send(Command cmd) { + ExtensionContext c = this.ctx; + if (c != null) { + c.send(cmd); + } + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceStartCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceStartCommand.java new file mode 100644 index 000000000..725db2e78 --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceStartCommand.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import org.opensolaris.os.dtrace.ConsumerEvent; + +/** + * Command to represent consumer start event from DTrace. + * + * @author A. Sundararajan + */ +public class DTraceStartCommand extends DTraceConsumerCommand { + public DTraceStartCommand(ConsumerEvent ce) { + super("dtrace-start", ce); + } +} diff --git a/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceStopCommand.java b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceStopCommand.java new file mode 100644 index 000000000..821991b65 --- /dev/null +++ b/btrace-dtrace/src/main/java/io/btrace/dtrace/DTraceStopCommand.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.dtrace; + +import org.opensolaris.os.dtrace.ConsumerEvent; + +/** + * Command to represent consumer start event from DTrace. + * + * @author A. Sundararajan + */ +public class DTraceStopCommand extends DTraceConsumerCommand { + public DTraceStopCommand(ConsumerEvent ce) { + super("dtrace-stop", ce); + } +} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTrace.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTrace.java deleted file mode 100644 index 950970cec..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTrace.java +++ /dev/null @@ -1,183 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import java.io.File; -import java.io.IOException; -import org.openjdk.btrace.core.comm.Command; -import org.openjdk.btrace.core.comm.CommandListener; -import org.openjdk.btrace.core.comm.ErrorCommand; -import org.openjdk.btrace.core.comm.MessageCommand; -import org.opensolaris.os.dtrace.*; - -/** - * Simple wrapper class around DTrace/Java API. This wrapper accepts a BTrace command listener, - * DTrace file or string and DTrace macro arguments. The events from DTrace are wrapped as BTrace - * command instances and given to the listener. - * - * @author A. Sundararajan - */ -@SuppressWarnings("RedundantThrows") -public class DTrace { - - /** - * Submits a D-script from given file and passes given argument array as DTrace macro arguments. - * The events from DTrace are wrapped as BTrace commands and listener given is notified. - * - * @param file D-script file to submit - * @param args DTrace macro arguments - * @param listener BTrace command listener that is notified - */ - public static void submit(File file, String[] args, CommandListener listener) - throws DTraceException, IOException { - Consumer cons = newConsumer(args, listener); - cons.compile(file, args); - start(cons, listener); - } - - /** - * Submits a D-script string and passes the given argument array as DTrace macro arguments. The - * events from DTrace are wrapped as BTrace commands and listener given is notified. - * - * @param program D-script as a string - * @param args DTrace macro arguments - * @param listener BTrace command listener that is notified - */ - public static void submit(String program, String[] args, CommandListener listener) - throws DTraceException { - Consumer cons = newConsumer(args, listener); - cons.compile(program, args); - start(cons, listener); - } - - private static void start(Consumer cons, CommandListener listener) throws DTraceException { - cons.enable(); - cons.go( - th -> { - try { - listener.onCommand(new ErrorCommand(th)); - } catch (IOException ioexp) { - ioexp.printStackTrace(); - } - }); - } - - private static Consumer newConsumer(String[] args, CommandListener listener) - throws DTraceException { - Consumer cons = new LocalConsumer(); - cons.addConsumerListener( - new ConsumerAdapter() { - private void notify(Command cmd) { - try { - listener.onCommand(cmd); - } catch (IOException ioexp) { - ioexp.printStackTrace(); - } - } - - @Override - public void consumerStarted(ConsumerEvent ce) { - notify(new DTraceStartCommand(ce)); - } - - @Override - public void consumerStopped(ConsumerEvent ce) { - Consumer cons = ce.getSource(); - Aggregate ag = null; - try { - ag = cons.getAggregate(); - } catch (DTraceException dexp) { - notify(new ErrorCommand(dexp)); - } - StringBuilder buf = new StringBuilder(); - if (ag != null) { - for (Aggregation agg : ag.asMap().values()) { - String name = agg.getName(); - if (name != null && name.length() > 0) { - buf.append(name); - buf.append('\n'); - } - for (AggregationRecord rec : agg.asMap().values()) { - buf.append('\t'); - buf.append(rec.getTuple()); - buf.append(" "); - buf.append(rec.getValue()); - buf.append('\n'); - } - } - } - String msg = buf.toString(); - if (msg.length() > 0) { - notify(new MessageCommand(msg)); - } - notify(new DTraceStopCommand(ce)); - cons.close(); - } - - @Override - public void dataReceived(DataEvent de) { - notify(new DTraceDataCommand(de)); - } - - @Override - public void dataDropped(DropEvent de) { - notify(new DTraceDropCommand(de)); - } - - @Override - public void errorEncountered(ErrorEvent ee) throws ConsumerException { - try { - super.errorEncountered(ee); - } catch (ConsumerException ce) { - notify(new DTraceErrorCommand(ce, ee)); - throw ce; - } - } - }); - - // open DTrace Consumer - cons.open(); - - // unused macro arguments are fine - cons.setOption(Option.argref, ""); - // if no macro arg passed use "" or NULL - cons.setOption(Option.defaultargs, ""); - // allow empty D-scripts - cons.setOption(Option.empty, ""); - // be quiet! equivalent to DTrace's -q - cons.setOption(Option.quiet, ""); - // undefined user land symbols are fine - cons.setOption(Option.unodefs, ""); - // allow zero matching of probes (needed for late loading) - cons.setOption(Option.zdefs, ""); - try { - int pid = Integer.parseInt(args[0]); - cons.grabProcess(pid); - } catch (Exception ignored) { - } - return cons; - } -} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceCommand.java deleted file mode 100644 index b245fe7ca..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceCommand.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -/** - * A marker interface to tell whether a given BTrace command is a wrapper of a DTrace event. - * - * @author A. Sundararajan - */ -public interface DTraceCommand {} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceConsumerCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceConsumerCommand.java deleted file mode 100644 index 9e441d203..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceConsumerCommand.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import org.openjdk.btrace.core.comm.EventCommand; -import org.opensolaris.os.dtrace.Consumer; -import org.opensolaris.os.dtrace.ConsumerEvent; - -/** - * Abstract command to represent consumer event from DTrace. - * - * @author A. Sundararajan - */ -public abstract class DTraceConsumerCommand extends EventCommand implements DTraceCommand { - private ConsumerEvent ce; - - public DTraceConsumerCommand(String type, ConsumerEvent ce) { - super(type); - this.ce = ce; - } - - /** Returns the underlying DTrace ConsumerEvent. */ - public ConsumerEvent getConsumerEvent() { - return ce; - } - - /** Returns the Consumer object. */ - public Consumer getConsumer() { - return ce.getSource(); - } - - public void write(ObjectOutput out) throws IOException { - out.writeObject(ce); - } - - public void read(ObjectInput in) throws ClassNotFoundException, IOException { - ce = (ConsumerEvent) in.readObject(); - } -} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceDataCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceDataCommand.java deleted file mode 100644 index a375393dc..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceDataCommand.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import java.util.List; -import org.openjdk.btrace.core.comm.MessageCommand; -import org.opensolaris.os.dtrace.DataEvent; -import org.opensolaris.os.dtrace.ProbeData; -import org.opensolaris.os.dtrace.Record; - -/** - * Command to represent data event from DTrace. - * - * @author A. Sundararajan - */ -public class DTraceDataCommand extends MessageCommand implements DTraceCommand { - private DataEvent de; - - public DTraceDataCommand(DataEvent de) { - super(asString(de), true); - this.de = de; - } - - /** Returns the underlying DTrace DataEvent. */ - public DataEvent getDataEvent() { - return de; - } - - public void write(ObjectOutput out) throws IOException { - super.write(out); - out.writeObject(de); - } - - public void read(ObjectInput in) throws ClassNotFoundException, IOException { - super.read(in); - de = (DataEvent) in.readObject(); - } - - private static String asString(DataEvent de) { - ProbeData pd = de.getProbeData(); - List records = pd.getRecords(); - StringBuilder buf = new StringBuilder(); - for (Record rec : records) { - buf.append(rec); - } - return buf.toString(); - } -} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceDropCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceDropCommand.java deleted file mode 100644 index 0134b6a42..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceDropCommand.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import org.openjdk.btrace.core.comm.MessageCommand; -import org.opensolaris.os.dtrace.DropEvent; - -/** - * Command class that represents DTrace drop event. - * - * @author A. Sundararajan - */ -public class DTraceDropCommand extends MessageCommand implements DTraceCommand { - private DropEvent de; - - public DTraceDropCommand(DropEvent de) { - super(asString(de), true); - this.de = de; - } - - /** Returns the underlying DTrace drop event */ - public DropEvent getDropEvent() { - return de; - } - - public void write(ObjectOutput out) throws IOException { - super.write(out); - out.writeObject(out); - } - - public void read(ObjectInput in) throws ClassNotFoundException, IOException { - super.read(in); - de = (DropEvent) in.readObject(); - } - - private static String asString(DropEvent de) { - return de.getDrop().getDefaultMessage(); - } -} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceErrorCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceErrorCommand.java deleted file mode 100644 index 43400920f..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceErrorCommand.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import org.openjdk.btrace.core.comm.ErrorCommand; -import org.opensolaris.os.dtrace.ErrorEvent; - -/** - * Command that represents error message from DTrace. - * - * @author A. Sundararajan - */ -public class DTraceErrorCommand extends ErrorCommand implements DTraceCommand { - private ErrorEvent ee; - - public DTraceErrorCommand(Exception exp, ErrorEvent ee) { - super(exp); - this.ee = ee; - } - - /** Returns the underlying DTrace error event. */ - public ErrorEvent getErrorEvent() { - return ee; - } - - public void write(ObjectOutput out) throws IOException { - super.write(out); - out.writeObject(ee); - } - - public void read(ObjectInput in) throws ClassNotFoundException, IOException { - super.read(in); - ee = (ErrorEvent) in.readObject(); - } -} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceStartCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceStartCommand.java deleted file mode 100644 index 9768abce5..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceStartCommand.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import org.opensolaris.os.dtrace.ConsumerEvent; - -/** - * Command to represent consumer start event from DTrace. - * - * @author A. Sundararajan - */ -public class DTraceStartCommand extends DTraceConsumerCommand { - public DTraceStartCommand(ConsumerEvent ce) { - super("dtrace-start", ce); - } -} diff --git a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceStopCommand.java b/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceStopCommand.java deleted file mode 100644 index 85d741237..000000000 --- a/btrace-dtrace/src/main/java/org/openjdk/btrace/dtrace/DTraceStopCommand.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the Classpath exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package org.openjdk.btrace.dtrace; - -import org.opensolaris.os.dtrace.ConsumerEvent; - -/** - * Command to represent consumer start event from DTrace. - * - * @author A. Sundararajan - */ -public class DTraceStopCommand extends DTraceConsumerCommand { - public DTraceStopCommand(ConsumerEvent ce) { - super("dtrace-stop", ce); - } -} diff --git a/btrace-dtrace/src/main/resources/META-INF/services/io.btrace.core.extensions.Extension b/btrace-dtrace/src/main/resources/META-INF/services/io.btrace.core.extensions.Extension new file mode 100644 index 000000000..da56e0eb6 --- /dev/null +++ b/btrace-dtrace/src/main/resources/META-INF/services/io.btrace.core.extensions.Extension @@ -0,0 +1 @@ +io.btrace.dtrace.DTraceExtension diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregate.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregate.java index 265ea13d4..a2ebd3ffd 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregate.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregate.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; import java.util.Map; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregation.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregation.java index 0f6366252..9383c8511 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregation.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Aggregation.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; import java.util.Map; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationRecord.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationRecord.java index b8b36356f..a6433e847 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationRecord.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationRecord.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; @SuppressWarnings("SameReturnValue") diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationValue.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationValue.java index 010ecb140..b504e7fcb 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationValue.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/AggregationValue.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class AggregationValue {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Consumer.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Consumer.java index b2ee126d9..1b489b121 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Consumer.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Consumer.java @@ -1,29 +1,18 @@ /* - * CDDL HEADER START + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License (the "License"). - * You may not use this file except in compliance with the License. + * 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 * - * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE - * or http://www.opensolaris.org/os/licensing. - * See the License for the specific language governing permissions - * and limitations under the License. + * https://www.apache.org/licenses/LICENSE-2.0 * - * When distributing Covered Code, include this CDDL HEADER in each - * file and include the License file at usr/src/OPENSOLARIS.LICENSE. - * If applicable, add the following below this CDDL HEADER, with the - * fields enclosed by brackets "[]" replaced with your own identifying - * information: Portions Copyright [yyyy] [name of copyright owner] - * - * CDDL HEADER END - */ - -/* - * Copyright 2006 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - * - * ident "%Z%%M% %I% %E% SMI" + * 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 org.opensolaris.os.dtrace; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerAdapter.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerAdapter.java index 15a73ed95..39c41792d 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerAdapter.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerAdapter.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public abstract class ConsumerAdapter implements ConsumerListener { diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerEvent.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerEvent.java index 561653d5c..ead5e13ef 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerEvent.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerEvent.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; @SuppressWarnings("SameReturnValue") diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerException.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerException.java index 53fff674b..c86e05419 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerException.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerException.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class ConsumerException extends Exception {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerListener.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerListener.java index e1a20baf9..2c8341882 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerListener.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ConsumerListener.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public interface ConsumerListener {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DTraceException.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DTraceException.java index 8c62bd6c3..5640cb3c4 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DTraceException.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DTraceException.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class DTraceException extends Exception { diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DataEvent.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DataEvent.java index 5e804582e..46a559be2 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DataEvent.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DataEvent.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; import java.util.EventObject; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Drop.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Drop.java index cfa4f7cd0..9412279b3 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Drop.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Drop.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; @SuppressWarnings("SameReturnValue") diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DropEvent.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DropEvent.java index 3db363d01..12c4c6e2e 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DropEvent.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/DropEvent.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; import java.util.EventObject; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ErrorEvent.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ErrorEvent.java index fa96b4bfe..9421e056b 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ErrorEvent.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ErrorEvent.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class ErrorEvent {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ExceptionHandler.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ExceptionHandler.java index 1bf5769e0..31f8df344 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ExceptionHandler.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ExceptionHandler.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public interface ExceptionHandler { diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/LocalConsumer.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/LocalConsumer.java index 4195c96d6..26685668a 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/LocalConsumer.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/LocalConsumer.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; import java.io.File; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Option.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Option.java index 0c14c8601..ca4a5a07a 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Option.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Option.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class Option { diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Probe.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Probe.java index 5a3216567..60d19cd91 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Probe.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Probe.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class Probe {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeData.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeData.java index 839b88923..b4590e838 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeData.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeData.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; import java.util.List; diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeDescription.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeDescription.java index 8337dc6cb..7927541e0 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeDescription.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/ProbeDescription.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class ProbeDescription {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Program.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Program.java index 17df57ee2..83dd29824 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Program.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Program.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class Program {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Record.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Record.java index cd1be9c40..ca0b95041 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Record.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Record.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class Record {} diff --git a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Tuple.java b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Tuple.java index 934593ffe..7ba717fbd 100644 --- a/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Tuple.java +++ b/btrace-dtrace/src/mock/java/org/opensolaris/os/dtrace/Tuple.java @@ -1,3 +1,19 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.opensolaris.os.dtrace; public class Tuple {} diff --git a/btrace-extensions/btrace-contracts/build.gradle b/btrace-extensions/btrace-contracts/build.gradle new file mode 100644 index 000000000..9ec12efda --- /dev/null +++ b/btrace-extensions/btrace-contracts/build.gradle @@ -0,0 +1,35 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-contracts' + name = 'BTrace Contracts' + description = 'Runtime behavioral contracts: latency budgets, call-rate limits, value assertions, and tagged code path profiling' + services = ['io.btrace.contracts.ContractService'] +} + +dependencies { + apiCompileOnly 'org.jetbrains:annotations:26.1.0' + apiCompileOnly project(':btrace-core') + implCompileOnly 'org.jetbrains:annotations:26.1.0' + implImplementation project(':btrace-core') + + testImplementation libs.junit.jupiter +} + +test { + useJUnitPlatform() +} diff --git a/btrace-extensions/btrace-contracts/src/main/java/io/btrace/contracts/ContractService.java b/btrace-extensions/btrace-contracts/src/main/java/io/btrace/contracts/ContractService.java new file mode 100644 index 000000000..3019e4ee4 --- /dev/null +++ b/btrace-extensions/btrace-contracts/src/main/java/io/btrace/contracts/ContractService.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.contracts; + +import io.btrace.core.extensions.ServiceDescriptor; +import org.jetbrains.annotations.Nullable; + +/** + * BTrace extension for enforcing runtime behavioral contracts. + * + *

Validates that methods respect declared invariants at runtime — latency budgets, call-rate + * limits, null-safety, and value ranges — without modifying the target code. Violations are counted + * and reported; the target application is never interrupted. + * + *

Optionally tracks call count and average latency per user-supplied tag, so you can compare any + * two code paths (e.g. cached vs uncached, v1 vs v2, impl A vs impl B) side by side. + * + *

Usage in a BTrace script: + * + *

+ * @Injected ContractService contracts;
+ *
+ * @OnMethod(clazz = "com.app.Service", method = "query",
+ *           location = @Location(Kind.RETURN))
+ * void onReturn(@Duration long dur) {
+ *     contracts.checkLatency("Service.query", dur, 200_000_000L); // 200ms budget
+ * }
+ *

+ */ +@ServiceDescriptor +public interface ContractService { + + // ==================== Contract checks ==================== + + /** + * Checks that a method's latency does not exceed the budget. Records a violation if {@code + * durationNanos > budgetNanos}. + */ + void checkLatency(String contract, long durationNanos, long budgetNanos); + + /** + * Checks that the call rate does not exceed the limit per second. Uses a sliding window to detect + * bursts. + */ + void checkCallRate(String contract, int maxPerSecond); + + /** Asserts a boolean condition. Records a violation if false. */ + void assertCondition(String contract, boolean condition, String message); + + /** Checks that a numeric value is within bounds (inclusive). Records a violation if not. */ + void checkRange(String contract, long value, long min, long max); + + /** Checks that a return value is not null. Records a violation if null. */ + void checkNotNull(String contract, Object value); + + // ==================== Tracking ==================== + + /** + * Records a call against the given tag for the contract. Call count and cumulative duration are + * accumulated per tag; {@link #getSummary()} renders all tags side by side. The tag is + * user-defined — common examples: {@code "cached"}/{@code "uncached"}, {@code "v1"}/{@code "v2"}, + * {@code "fast-path"}/{@code "slow-path"}. + */ + void trackCodePath(String contract, long durationNanos, String tag); + + // ==================== Reporting ==================== + + /** Returns a formatted summary of all contract checks, violations, and tracked paths. */ + @Nullable String getSummary(); + + /** Returns total number of contract violations across all contracts. */ + long getTotalViolations(); + + /** Returns number of violations for a specific contract. */ + long getViolations(String contract); + + /** Returns total number of contract checks performed. */ + long getTotalChecks(); + + /** Returns true if any contract has been violated. */ + boolean hasViolations(); + + /** Resets all metrics and violation history. */ + void reset(); +} diff --git a/btrace-extensions/btrace-contracts/src/main/java/io/btrace/contracts/ContractServiceImpl.java b/btrace-extensions/btrace-contracts/src/main/java/io/btrace/contracts/ContractServiceImpl.java new file mode 100644 index 000000000..c5d9392a6 --- /dev/null +++ b/btrace-extensions/btrace-contracts/src/main/java/io/btrace/contracts/ContractServiceImpl.java @@ -0,0 +1,343 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.contracts; + +import io.btrace.core.extensions.Extension; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +/** Thread-safe behavioral contract enforcement with lock-free statistics. */ +public final class ContractServiceImpl extends Extension implements ContractService { + + private final ConcurrentHashMap contracts = new ConcurrentHashMap<>(); + private final ConcurrentHashMap rateWindows = new ConcurrentHashMap<>(); + // contract -> tag -> stats + private final ConcurrentHashMap> taggedPaths = + new ConcurrentHashMap<>(); + + // ==================== Contract checks ==================== + + @Override + public void checkLatency(String contract, long durationNanos, long budgetNanos) { + ContractStats stats = getOrCreate(contract); + stats.checks.incrementAndGet(); + if (durationNanos > budgetNanos) { + stats.violations.incrementAndGet(); + stats.lastViolationMessage = + "Latency " + + (durationNanos / 1_000_000) + + "ms exceeded budget " + + (budgetNanos / 1_000_000) + + "ms"; + } + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + @Override + public void checkCallRate(String contract, int maxPerSecond) { + ContractStats stats = getOrCreate(contract); + stats.checks.incrementAndGet(); + + RateWindow window = rateWindows.computeIfAbsent(contract, k -> new RateWindow()); + long now = System.nanoTime(); + long count = window.recordAndCount(now); + if (count > maxPerSecond) { + stats.violations.incrementAndGet(); + stats.lastViolationMessage = "Rate " + count + "/sec exceeded limit " + maxPerSecond + "/sec"; + } + } + + @Override + public void assertCondition(String contract, boolean condition, String message) { + ContractStats stats = getOrCreate(contract); + stats.checks.incrementAndGet(); + if (!condition) { + stats.violations.incrementAndGet(); + stats.lastViolationMessage = message; + } + } + + @Override + public void checkRange(String contract, long value, long min, long max) { + ContractStats stats = getOrCreate(contract); + stats.checks.incrementAndGet(); + if (value < min || value > max) { + stats.violations.incrementAndGet(); + stats.lastViolationMessage = "Value " + value + " outside range [" + min + ", " + max + "]"; + } + } + + @Override + public void checkNotNull(String contract, Object value) { + ContractStats stats = getOrCreate(contract); + stats.checks.incrementAndGet(); + if (value == null) { + stats.violations.incrementAndGet(); + stats.lastViolationMessage = "Unexpected null return"; + } + } + + // ==================== Tracking ==================== + + @Override + public void trackCodePath(String contract, long durationNanos, String tag) { + ConcurrentHashMap byTag = + taggedPaths.computeIfAbsent(contract, k -> new ConcurrentHashMap<>()); + CodePathStats s = byTag.computeIfAbsent(tag, k -> new CodePathStats()); + s.calls.incrementAndGet(); + s.totalDurationNanos.addAndGet(durationNanos); + } + + // ==================== Reporting ==================== + + @Override + public String getSummary() { + if (contracts.isEmpty() && taggedPaths.isEmpty()) { + return "No contracts checked."; + } + + StringBuilder sb = new StringBuilder(); + sb.append("=== Contract Summary ===\n\n"); + + long totalChecks = 0; + long totalViolations = 0; + + for (Map.Entry entry : contracts.entrySet()) { + String name = entry.getKey(); + ContractStats s = entry.getValue(); + long checks = s.checks.get(); + long violations = s.violations.get(); + totalChecks += checks; + totalViolations += violations; + + sb.append("Contract: ").append(name).append("\n"); + sb.append(" Checks: ").append(checks); + if (violations > 0) { + sb.append(" | VIOLATIONS: ").append(violations); + sb.append(" (").append(violations * 100 / checks).append("%)"); + } else { + sb.append(" | OK"); + } + sb.append("\n"); + + long dur = s.totalDurationNanos.get(); + if (dur > 0 && checks > 0) { + long avgMs = (dur / checks) / 1_000_000; + long minMs = + s.minDurationNanos.get() == Long.MAX_VALUE ? 0 : s.minDurationNanos.get() / 1_000_000; + long maxMs = s.maxDurationNanos.get() / 1_000_000; + sb.append(" Latency: avg ").append(avgMs).append("ms"); + sb.append(", min ").append(minMs).append("ms"); + sb.append(", max ").append(maxMs).append("ms\n"); + } + + if (violations > 0 && s.lastViolationMessage != null) { + sb.append(" Last: ").append(s.lastViolationMessage).append("\n"); + } + sb.append("\n"); + } + + if (!taggedPaths.isEmpty()) { + sb.append("--- Tracked Code Paths ---\n"); + for (Map.Entry> e : taggedPaths.entrySet()) { + String contractName = e.getKey(); + Map byTag = e.getValue(); + + List tags = new ArrayList<>(byTag.keySet()); + Collections.sort(tags); + + sb.append(" ").append(contractName).append(":\n"); + for (String tag : tags) { + CodePathStats s = byTag.get(tag); + long calls = s.calls.get(); + long avgMs = calls > 0 ? (s.totalDurationNanos.get() / calls) / 1_000_000 : 0; + sb.append(" ") + .append(tag) + .append(": ") + .append(calls) + .append(" calls avg ") + .append(avgMs) + .append("ms\n"); + } + + // Cross-compare when exactly 2 tags + if (tags.size() == 2) { + CodePathStats s0 = byTag.get(tags.get(0)); + CodePathStats s1 = byTag.get(tags.get(1)); + long c0 = s0.calls.get(), c1 = s1.calls.get(); + if (c0 > 0 && c1 > 0) { + long avg0 = s0.totalDurationNanos.get() / c0; + long avg1 = s1.totalDurationNanos.get() / c1; + if (avg1 > 0) { + long pct = ((avg0 - avg1) * 100) / avg1; + if (pct > 0) { + sb.append(" [") + .append(tags.get(0)) + .append(' ') + .append(pct) + .append("% slower than ") + .append(tags.get(1)) + .append("]\n"); + } else if (pct < 0) { + sb.append(" [") + .append(tags.get(0)) + .append(' ') + .append(-pct) + .append("% faster than ") + .append(tags.get(1)) + .append("]\n"); + } + } + } + } + } + sb.append("\n"); + } + + sb.append("--- Totals ---\n"); + sb.append(" Checks: ").append(totalChecks).append("\n"); + sb.append(" Violations: ").append(totalViolations); + if (totalViolations == 0) { + sb.append(" (all contracts satisfied)"); + } + sb.append("\n"); + + return sb.toString(); + } + + @Override + public long getTotalViolations() { + long total = 0; + for (ContractStats s : contracts.values()) { + total += s.violations.get(); + } + return total; + } + + @Override + public long getViolations(String contract) { + ContractStats s = contracts.get(contract); + return s != null ? s.violations.get() : 0; + } + + @Override + public long getTotalChecks() { + long total = 0; + for (ContractStats s : contracts.values()) { + total += s.checks.get(); + } + return total; + } + + @Override + public boolean hasViolations() { + for (ContractStats s : contracts.values()) { + if (s.violations.get() > 0) return true; + } + return false; + } + + @Override + public void reset() { + contracts.clear(); + rateWindows.clear(); + taggedPaths.clear(); + } + + @Override + public void close() { + String summary = getSummary(); + if (!"No contracts checked.".equals(summary)) { + getContext().send(summary); + } + } + + // ==================== Internals ==================== + + private ContractStats getOrCreate(String contract) { + return contracts.computeIfAbsent(contract, k -> new ContractStats()); + } + + private static void updateMinMax(AtomicLong min, AtomicLong max, long value) { + long cur; + do { + cur = min.get(); + if (value >= cur) break; + } while (!min.compareAndSet(cur, value)); + do { + cur = max.get(); + if (value <= cur) break; + } while (!max.compareAndSet(cur, value)); + } + + static final class ContractStats { + final AtomicLong checks = new AtomicLong(); + final AtomicLong violations = new AtomicLong(); + final AtomicLong totalDurationNanos = new AtomicLong(); + final AtomicLong minDurationNanos = new AtomicLong(Long.MAX_VALUE); + final AtomicLong maxDurationNanos = new AtomicLong(0); + volatile String lastViolationMessage; + } + + static final class CodePathStats { + final AtomicLong calls = new AtomicLong(); + final AtomicLong totalDurationNanos = new AtomicLong(); + } + + /** + * Simple sliding-window rate counter. Tracks calls in the last second using a circular buffer of + * 10 x 100ms buckets. Lock-free via CAS. + */ + static final class RateWindow { + private static final int BUCKETS = 10; + private static final long BUCKET_NS = 100_000_000L; // 100ms + private final AtomicLong[] counts = new AtomicLong[BUCKETS]; + private final AtomicLong[] timestamps = new AtomicLong[BUCKETS]; + + RateWindow() { + for (int i = 0; i < BUCKETS; i++) { + counts[i] = new AtomicLong(); + timestamps[i] = new AtomicLong(); + } + } + + long recordAndCount(long nowNanos) { + int bucket = (int) ((nowNanos / BUCKET_NS) % BUCKETS); + long bucketTime = (nowNanos / BUCKET_NS) * BUCKET_NS; + + if (timestamps[bucket].get() != bucketTime) { + timestamps[bucket].set(bucketTime); + counts[bucket].set(0); + } + counts[bucket].incrementAndGet(); + + long total = 0; + long windowStart = nowNanos - (BUCKETS * BUCKET_NS); + for (int i = 0; i < BUCKETS; i++) { + if (timestamps[i].get() > windowStart) { + total += counts[i].get(); + } + } + return total; + } + } +} diff --git a/btrace-extensions/btrace-contracts/src/test/java/io/btrace/contracts/ContractServiceTest.java b/btrace-extensions/btrace-contracts/src/test/java/io/btrace/contracts/ContractServiceTest.java new file mode 100644 index 000000000..aa8a43488 --- /dev/null +++ b/btrace-extensions/btrace-contracts/src/test/java/io/btrace/contracts/ContractServiceTest.java @@ -0,0 +1,260 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.contracts; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.concurrent.CountDownLatch; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class ContractServiceTest { + + private ContractServiceImpl service; + + @BeforeEach + void setUp() { + service = new ContractServiceImpl(); + } + + // ==================== Latency checks ==================== + + @Test + void latencyWithinBudget() { + service.checkLatency("api.generate", 100_000_000L, 500_000_000L); + assertEquals(1, service.getTotalChecks()); + assertEquals(0, service.getTotalViolations()); + assertFalse(service.hasViolations()); + } + + @Test + void latencyExceedsBudget() { + service.checkLatency("api.generate", 600_000_000L, 500_000_000L); + assertEquals(1, service.getTotalViolations()); + assertTrue(service.hasViolations()); + String summary = service.getSummary(); + assertTrue(summary.contains("VIOLATIONS: 1")); + assertTrue(summary.contains("exceeded budget")); + } + + @Test + void latencyStatsTracked() { + service.checkLatency("api.call", 100_000_000L, 1_000_000_000L); + service.checkLatency("api.call", 200_000_000L, 1_000_000_000L); + service.checkLatency("api.call", 300_000_000L, 1_000_000_000L); + + assertEquals(3, service.getTotalChecks()); + String summary = service.getSummary(); + assertTrue(summary.contains("avg 200ms")); + assertTrue(summary.contains("min 100ms")); + assertTrue(summary.contains("max 300ms")); + } + + // ==================== Call rate checks ==================== + + @Test + void callRateWithinLimit() { + service.checkCallRate("api.query", 1000); + assertEquals(0, service.getTotalViolations()); + } + + @Test + void callRateExceedsLimit() { + for (int i = 0; i < 200; i++) { + service.checkCallRate("api.query", 10); + } + assertTrue(service.getTotalViolations() > 0); + } + + // ==================== Condition assertions ==================== + + @Test + void assertConditionTrue() { + service.assertCondition("positive-balance", true, "Balance must be positive"); + assertEquals(0, service.getTotalViolations()); + } + + @Test + void assertConditionFalse() { + service.assertCondition("positive-balance", false, "Balance must be positive"); + assertEquals(1, service.getTotalViolations()); + assertTrue(service.getSummary().contains("Balance must be positive")); + } + + // ==================== Range checks ==================== + + @Test + void rangeWithinBounds() { + service.checkRange("response-code", 200, 100, 599); + assertEquals(0, service.getTotalViolations()); + } + + @Test + void rangeBelowMin() { + service.checkRange("response-code", 50, 100, 599); + assertEquals(1, service.getTotalViolations()); + assertTrue(service.getSummary().contains("outside range")); + } + + @Test + void rangeAboveMax() { + service.checkRange("response-code", 700, 100, 599); + assertEquals(1, service.getTotalViolations()); + } + + @Test + void rangeAtBoundaries() { + service.checkRange("val", 100, 100, 200); + service.checkRange("val", 200, 100, 200); + assertEquals(0, service.getTotalViolations()); + } + + // ==================== Null checks ==================== + + @Test + void checkNotNullWithValue() { + service.checkNotNull("api.result", "hello"); + assertEquals(0, service.getTotalViolations()); + } + + @Test + void checkNotNullWithNull() { + service.checkNotNull("api.result", null); + assertEquals(1, service.getTotalViolations()); + assertTrue(service.getSummary().contains("Unexpected null")); + } + + // ==================== Code path tracking ==================== + + @Test + void twoTagComparison() { + service.trackCodePath("Parser.parse", 50_000_000L, "v2"); + service.trackCodePath("Parser.parse", 60_000_000L, "v2"); + service.trackCodePath("Parser.parse", 30_000_000L, "v1"); + service.trackCodePath("Parser.parse", 40_000_000L, "v1"); + + String summary = service.getSummary(); + assertTrue(summary.contains("Tracked Code Paths")); + assertTrue(summary.contains("v1")); + assertTrue(summary.contains("v2")); + assertTrue(summary.contains("2 calls")); + // v2 avg 55ms, v1 avg 35ms -> v2 ~57% slower than v1 (alphabetical: v1 first, v2 second) + assertTrue(summary.contains("slower") || summary.contains("faster")); + } + + @Test + void singleTagTracking() { + service.trackCodePath("Renderer.render", 100_000_000L, "cached"); + String summary = service.getSummary(); + assertTrue(summary.contains("Tracked Code Paths")); + assertTrue(summary.contains("cached")); + assertTrue(summary.contains("1 calls")); + } + + @Test + void multipleTagsNoComparison() { + service.trackCodePath("Op.run", 10_000_000L, "a"); + service.trackCodePath("Op.run", 20_000_000L, "b"); + service.trackCodePath("Op.run", 30_000_000L, "c"); + + String summary = service.getSummary(); + assertTrue(summary.contains("a")); + assertTrue(summary.contains("b")); + assertTrue(summary.contains("c")); + // More than 2 tags: no slower/faster comparison + assertFalse( + summary.contains("slower") || summary.contains("faster"), + "Cross-comparison should only appear for exactly 2 tags"); + } + + // ==================== Reporting ==================== + + @Test + void noDataSummary() { + assertEquals("No contracts checked.", service.getSummary()); + } + + @Test + void getViolationsPerContract() { + service.assertCondition("a", false, "fail"); + service.assertCondition("a", false, "fail"); + service.assertCondition("b", false, "fail"); + + assertEquals(2, service.getViolations("a")); + assertEquals(1, service.getViolations("b")); + assertEquals(0, service.getViolations("c")); + } + + @Test + void multipleContractsInSummary() { + service.checkLatency("fast-api", 10_000_000L, 100_000_000L); + service.checkLatency("slow-api", 500_000_000L, 100_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("fast-api")); + assertTrue(summary.contains("slow-api")); + assertTrue(summary.contains("Checks: 2")); + assertTrue(summary.contains("Violations: 1")); + } + + @Test + void allContractsSatisfied() { + service.checkLatency("api", 10_000_000L, 100_000_000L); + service.assertCondition("invariant", true, "ok"); + service.checkRange("val", 50, 0, 100); + + String summary = service.getSummary(); + assertTrue(summary.contains("all contracts satisfied")); + } + + @Test + void reset() { + service.assertCondition("a", false, "fail"); + service.trackCodePath("b", 100L, "tag"); + service.reset(); + + assertEquals(0, service.getTotalChecks()); + assertEquals(0, service.getTotalViolations()); + assertFalse(service.hasViolations()); + assertEquals("No contracts checked.", service.getSummary()); + } + + @Test + void concurrentChecks() throws Exception { + int threads = 8; + int checksPerThread = 1000; + CountDownLatch latch = new CountDownLatch(threads); + + for (int t = 0; t < threads; t++) { + new Thread( + () -> { + try { + for (int i = 0; i < checksPerThread; i++) { + service.checkLatency("concurrent-api", 50_000_000L, 100_000_000L); + } + } finally { + latch.countDown(); + } + }) + .start(); + } + latch.await(); + + assertEquals(threads * checksPerThread, service.getTotalChecks()); + assertEquals(0, service.getTotalViolations()); + } +} diff --git a/btrace-extensions/btrace-ext-test/build.gradle b/btrace-extensions/btrace-ext-test/build.gradle new file mode 100644 index 000000000..d78405729 --- /dev/null +++ b/btrace-extensions/btrace-ext-test/build.gradle @@ -0,0 +1,27 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-ext-test' + name = 'BTrace External-Type Integration Test Extension' + description = 'Minimal extension used solely by integration tests to verify @ExternalType end-to-end' + services = ['io.btrace.test.ext.ExternalTypeTestService'] +} + +dependencies { + apiCompileOnly project(':btrace-core') + implCompileOnly project(':btrace-core') +} diff --git a/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalDataType.java b/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalDataType.java new file mode 100644 index 000000000..441db9a75 --- /dev/null +++ b/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalDataType.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.test.ext; + +import io.btrace.core.extensions.ExternalType; + +/** + * {@linkplain ExternalType} contract for resources.ExternalData — a class that exists only in the + * target application's classloader and is never on the extension's compile classpath. + */ +@ExternalType("resources.ExternalData") +public interface ExternalDataType { + /** Maps to ExternalData.value() — virtual dispatch. */ + int value(); + + /** Maps to ExternalData.tag() — static dispatch via TCCL. */ + @ExternalType.Static + String tag(); +} diff --git a/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalTypeTestService.java b/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalTypeTestService.java new file mode 100644 index 000000000..909e38071 --- /dev/null +++ b/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalTypeTestService.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.test.ext; + +/** + * Integration-test service: exercises @ExternalType adapters against a class + * (resources.ExternalData) that lives only in the target application's classloader. + */ +public interface ExternalTypeTestService { + /** Returns the static tag from resources.ExternalData via its @ExternalType adapter. */ + String tag(); + + /** + * Returns the instance value from an resources.ExternalData object via its @ExternalType adapter. + */ + int value(Object externalData); +} diff --git a/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalTypeTestServiceImpl.java b/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalTypeTestServiceImpl.java new file mode 100644 index 000000000..73651ab8a --- /dev/null +++ b/btrace-extensions/btrace-ext-test/src/main/java/io/btrace/test/ext/ExternalTypeTestServiceImpl.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.test.ext; + +import io.btrace.core.extensions.Extension; + +public final class ExternalTypeTestServiceImpl extends Extension + implements ExternalTypeTestService { + @Override + public String tag() { + return ExternalDataType$Ext.tag(); + } + + @Override + public int value(Object externalData) { + return ExternalDataType$Ext.value(externalData); + } +} diff --git a/btrace-extensions/btrace-gpu-bridge/build.gradle b/btrace-extensions/btrace-gpu-bridge/build.gradle new file mode 100644 index 000000000..254087a79 --- /dev/null +++ b/btrace-extensions/btrace-gpu-bridge/build.gradle @@ -0,0 +1,35 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-gpu-bridge' + name = 'BTrace GPU Bridge' + description = 'GPU and model inference observability: ONNX Runtime, DJL, TensorFlow Java, and Panama FFM compute tracing' + services = ['io.btrace.gpu.GpuBridgeService'] +} + +dependencies { + apiCompileOnly 'org.jetbrains:annotations:26.1.0' + apiCompileOnly project(':btrace-core') + implCompileOnly 'org.jetbrains:annotations:26.1.0' + implImplementation project(':btrace-core') + + testImplementation libs.junit.jupiter +} + +test { + useJUnitPlatform() +} diff --git a/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/GpuBridgeService.java b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/GpuBridgeService.java new file mode 100644 index 000000000..44c101a55 --- /dev/null +++ b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/GpuBridgeService.java @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.gpu; + +import io.btrace.core.extensions.ServiceDescriptor; +import org.jetbrains.annotations.Nullable; + +/** + * BTrace extension for GPU compute and model inference observability. + * + *

Traces Java-to-GPU boundaries: ONNX Runtime inference sessions, DJL (Deep Java Library) + * predictions, TensorFlow Java operations, and Panama FFM native calls to CUDA/ROCm libraries. Zero + * external dependencies — instruments existing client classes. + * + *

Usage in a BTrace script: + * + *

+ * @Injected GpuBridgeService gpu;
+ *
+ * @OnMethod(clazz = "ai.onnxruntime.OrtSession", method = "run")
+ * void onInference(@Duration long dur) {
+ *     gpu.recordInference("onnx", "resnet50", dur);
+ * }
+ *

+ */ +@ServiceDescriptor +public interface GpuBridgeService { + + // ==================== Inference recording ==================== + + /** + * Records a model inference call with duration only. + * + * @param runtime runtime name (e.g. "onnx", "djl", "tensorflow") + * @param modelName model identifier + * @param durationNanos inference duration in nanoseconds + */ + void recordInference(String runtime, String modelName, long durationNanos); + + /** + * Records a model inference with batch size and tensor dimensions. + * + * @param runtime runtime name + * @param modelName model identifier + * @param batchSize batch size of the inference request + * @param durationNanos inference duration + */ + void recordInference(String runtime, String modelName, int batchSize, long durationNanos); + + /** + * Starts a detailed inference record builder. Allocation-free (ThreadLocal-pooled). + * + *

+   * gpu.inference("onnx", "bert-base")
+   *     .batchSize(32)
+   *     .inputElements(512 * 768)
+   *     .outputElements(512 * 2)
+   *     .deviceType("cuda")
+   *     .deviceId(0)
+   *     .duration(durationNanos)
+   *     .record();
+   *

+ * + * @param runtime runtime name + * @param modelName model identifier + * @return an inference record builder (thread-local, do not store) + */ + @Nullable InferenceRecord inference(String runtime, String modelName); + + // ==================== Memory tracking ==================== + + /** + * Records GPU memory allocation. + * + * @param deviceType device type ("cuda", "rocm", "cpu") + * @param deviceId device index + * @param bytes allocated bytes + */ + void recordMemoryAlloc(String deviceType, int deviceId, long bytes); + + /** + * Records GPU memory deallocation. + * + * @param deviceType device type + * @param deviceId device index + * @param bytes freed bytes + */ + void recordMemoryFree(String deviceType, int deviceId, long bytes); + + // ==================== Native call tracking ==================== + + /** + * Records a native/FFM call to a GPU library (e.g. cuBLAS, cuDNN). + * + * @param library library name + * @param function function name + * @param durationNanos call duration + */ + void recordNativeCall(String library, String function, long durationNanos); + + // ==================== Model lifecycle ==================== + + /** + * Records model load/initialization time. + * + * @param runtime runtime name + * @param modelName model identifier + * @param durationNanos load duration + */ + void recordModelLoad(String runtime, String modelName, long durationNanos); + + // ==================== Reporting ==================== + + /** Returns a formatted summary of all GPU/inference metrics. */ + @Nullable String getSummary(); + + /** Returns summary for a specific model. */ + @Nullable String getModelSummary(String modelName); + + /** Total number of inference calls across all models. */ + long getTotalInferences(); + + /** Returns estimated GPU memory currently allocated (bytes), or -1 if not tracked. */ + long getCurrentGpuMemoryBytes(); + + /** Returns peak GPU memory seen (bytes), or -1 if not tracked. */ + long getPeakGpuMemoryBytes(); + + /** Returns total number of native/FFM calls recorded. */ + long getTotalNativeCalls(); + + /** Resets all collected metrics. */ + void reset(); +} diff --git a/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/GpuBridgeServiceImpl.java b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/GpuBridgeServiceImpl.java new file mode 100644 index 000000000..1eaee7337 --- /dev/null +++ b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/GpuBridgeServiceImpl.java @@ -0,0 +1,360 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.gpu; + +import io.btrace.core.extensions.Extension; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +/** Thread-safe GPU compute and inference tracking with lock-free statistics. */ +public final class GpuBridgeServiceImpl extends Extension implements GpuBridgeService { + + private final Map modelStats = new ConcurrentHashMap<>(); + private final Map deviceMemory = new ConcurrentHashMap<>(); + private final Map nativeStats = new ConcurrentHashMap<>(); + + private final ThreadLocal inferenceRecordPool = + ThreadLocal.withInitial(InferenceRecordImpl::new); + + // ==================== Inference recording ==================== + + @Override + public void recordInference(String runtime, String modelName, long durationNanos) { + ModelStats stats = getOrCreateModel(runtime, modelName); + stats.inferences.incrementAndGet(); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + @Override + public void recordInference(String runtime, String modelName, int batchSize, long durationNanos) { + ModelStats stats = getOrCreateModel(runtime, modelName); + stats.inferences.incrementAndGet(); + stats.totalBatchSize.addAndGet(batchSize); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + @Override + public InferenceRecord inference(String runtime, String modelName) { + return inferenceRecordPool.get().reset(this, runtime, modelName); + } + + void commitInferenceRecord(InferenceRecordImpl rec) { + ModelStats stats = getOrCreateModel(rec.runtime, rec.modelName); + stats.inferences.incrementAndGet(); + stats.totalBatchSize.addAndGet(rec.batchSizeVal); + stats.totalInputElements.addAndGet(rec.inputElem); + stats.totalOutputElements.addAndGet(rec.outputElem); + stats.totalDurationNanos.addAndGet(rec.durationVal); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, rec.durationVal); + if (rec.deviceTypeVal != null) { + stats.lastDeviceType = rec.deviceTypeVal; + stats.lastDeviceId = rec.deviceIdVal; + } + } + + // ==================== Memory tracking ==================== + + @Override + public void recordMemoryAlloc(String deviceType, int deviceId, long bytes) { + DeviceMemory dm = getOrCreateDevice(deviceType, deviceId); + dm.currentBytes.addAndGet(bytes); + dm.totalAllocated.addAndGet(bytes); + dm.allocCount.incrementAndGet(); + // Update peak + long cur; + long newVal = dm.currentBytes.get(); + do { + cur = dm.peakBytes.get(); + if (newVal <= cur) break; + } while (!dm.peakBytes.compareAndSet(cur, newVal)); + } + + @Override + public void recordMemoryFree(String deviceType, int deviceId, long bytes) { + DeviceMemory dm = getOrCreateDevice(deviceType, deviceId); + dm.currentBytes.addAndGet(-bytes); + dm.freeCount.incrementAndGet(); + } + + // ==================== Native call tracking ==================== + + @Override + public void recordNativeCall(String library, String function, long durationNanos) { + String key = library + "::" + function; + NativeCallStats stats = nativeStats.computeIfAbsent(key, k -> new NativeCallStats()); + stats.calls.incrementAndGet(); + stats.totalDurationNanos.addAndGet(durationNanos); + } + + // ==================== Model lifecycle ==================== + + @Override + public void recordModelLoad(String runtime, String modelName, long durationNanos) { + ModelStats stats = getOrCreateModel(runtime, modelName); + stats.loadCount.incrementAndGet(); + stats.totalLoadDurationNanos.addAndGet(durationNanos); + } + + // ==================== Reporting ==================== + + @Override + public String getSummary() { + if (modelStats.isEmpty() && deviceMemory.isEmpty() && nativeStats.isEmpty()) { + return "No GPU/inference activity recorded."; + } + + StringBuilder sb = new StringBuilder(); + sb.append("=== GPU Bridge Summary ===\n\n"); + + long totalInf = 0; + + for (Map.Entry entry : modelStats.entrySet()) { + ModelStats s = entry.getValue(); + long inf = s.inferences.get(); + totalInf += inf; + + sb.append("Model: ").append(entry.getKey()); + if (s.lastDeviceType != null) { + sb.append(" [").append(s.lastDeviceType).append(":").append(s.lastDeviceId).append("]"); + } + sb.append("\n"); + + // Inference stats + sb.append(" Inferences: ").append(inf); + long loads = s.loadCount.get(); + if (loads > 0) { + long avgLoadMs = (s.totalLoadDurationNanos.get() / loads) / 1_000_000; + sb.append(" (loaded ").append(loads).append("x, avg ").append(avgLoadMs).append("ms)"); + } + sb.append("\n"); + + // Latency + if (inf > 0) { + long avgMs = (s.totalDurationNanos.get() / inf) / 1_000_000; + long minMs = s.minDurationNanos.get() / 1_000_000; + long maxMs = s.maxDurationNanos.get() / 1_000_000; + sb.append(" Latency: avg ").append(avgMs).append("ms"); + sb.append(", min ").append(minMs).append("ms"); + sb.append(", max ").append(maxMs).append("ms\n"); + } + + // Batch size + long totalBatch = s.totalBatchSize.get(); + if (totalBatch > 0 && inf > 0) { + sb.append(" Batch size: avg ").append(totalBatch / inf).append("\n"); + } + + // Throughput (items/sec) + long totalDur = s.totalDurationNanos.get(); + if (totalBatch > 0 && totalDur > 0) { + double itemsPerSec = (totalBatch * 1_000_000_000.0) / totalDur; + sb.append(" Throughput: ") + .append(String.format("%.1f", itemsPerSec)) + .append(" items/sec\n"); + } + + // Tensor elements + long inEl = s.totalInputElements.get(); + long outEl = s.totalOutputElements.get(); + if (inEl > 0 || outEl > 0) { + sb.append(" Tensors: ") + .append(formatElements(inEl)) + .append(" in / ") + .append(formatElements(outEl)) + .append(" out\n"); + } + + sb.append("\n"); + } + + // Device memory + if (!deviceMemory.isEmpty()) { + sb.append("--- Device Memory ---\n"); + for (Map.Entry entry : deviceMemory.entrySet()) { + DeviceMemory dm = entry.getValue(); + sb.append(" ").append(entry.getKey()).append(": "); + sb.append("current ").append(formatBytes(dm.currentBytes.get())); + sb.append(", peak ").append(formatBytes(dm.peakBytes.get())); + sb.append(" (") + .append(dm.allocCount.get()) + .append(" allocs, ") + .append(dm.freeCount.get()) + .append(" frees)\n"); + } + sb.append("\n"); + } + + // Native calls + if (!nativeStats.isEmpty()) { + sb.append("--- Native Calls ---\n"); + for (Map.Entry entry : nativeStats.entrySet()) { + NativeCallStats ns = entry.getValue(); + long calls = ns.calls.get(); + long avgUs = calls > 0 ? (ns.totalDurationNanos.get() / calls) / 1000 : 0; + sb.append(" ") + .append(entry.getKey()) + .append(": ") + .append(calls) + .append(" calls, avg ") + .append(avgUs) + .append("us\n"); + } + sb.append("\n"); + } + + sb.append("--- Totals ---\n"); + sb.append(" Inferences: ").append(totalInf).append("\n"); + + return sb.toString(); + } + + @Override + public String getModelSummary(String modelName) { + // Search by model name suffix + for (Map.Entry entry : modelStats.entrySet()) { + if (entry.getKey().endsWith(modelName) || entry.getKey().equals(modelName)) { + ModelStats s = entry.getValue(); + long inf = s.inferences.get(); + long avgMs = inf > 0 ? (s.totalDurationNanos.get() / inf) / 1_000_000 : 0; + return entry.getKey() + ": " + inf + " inferences, avg " + avgMs + "ms"; + } + } + return "No data for model: " + modelName; + } + + @Override + public long getTotalInferences() { + long total = 0; + for (ModelStats s : modelStats.values()) { + total += s.inferences.get(); + } + return total; + } + + @Override + public long getCurrentGpuMemoryBytes() { + if (deviceMemory.isEmpty()) return -1; + long total = 0; + for (DeviceMemory dm : deviceMemory.values()) { + total += dm.currentBytes.get(); + } + return total; + } + + @Override + public long getPeakGpuMemoryBytes() { + if (deviceMemory.isEmpty()) return -1; + long peak = 0; + for (DeviceMemory dm : deviceMemory.values()) { + peak = Math.max(peak, dm.peakBytes.get()); + } + return peak; + } + + @Override + public long getTotalNativeCalls() { + long total = 0; + for (NativeCallStats ns : nativeStats.values()) { + total += ns.calls.get(); + } + return total; + } + + @Override + public void reset() { + modelStats.clear(); + deviceMemory.clear(); + nativeStats.clear(); + } + + @Override + public void close() { + String summary = getSummary(); + if (!"No GPU/inference activity recorded.".equals(summary)) { + getContext().send(summary); + } + } + + // ==================== Internals ==================== + + private ModelStats getOrCreateModel(String runtime, String modelName) { + String key = runtime + "/" + modelName; + return modelStats.computeIfAbsent(key, k -> new ModelStats()); + } + + private DeviceMemory getOrCreateDevice(String deviceType, int deviceId) { + String key = deviceType + ":" + deviceId; + return deviceMemory.computeIfAbsent(key, k -> new DeviceMemory()); + } + + private static void updateMinMax(AtomicLong min, AtomicLong max, long value) { + long cur; + do { + cur = min.get(); + if (value >= cur) break; + } while (!min.compareAndSet(cur, value)); + do { + cur = max.get(); + if (value <= cur) break; + } while (!max.compareAndSet(cur, value)); + } + + static String formatBytes(long bytes) { + if (bytes < 0) return "-" + formatBytes(-bytes); + if (bytes < 1024) return bytes + "B"; + if (bytes < 1024 * 1024) return (bytes / 1024) + "KB"; + if (bytes < 1024L * 1024 * 1024) return (bytes / (1024 * 1024)) + "MB"; + return String.format("%.1fGB", bytes / (1024.0 * 1024 * 1024)); + } + + static String formatElements(long elements) { + if (elements < 1000) return elements + ""; + if (elements < 1_000_000) return String.format("%.1fK", elements / 1000.0); + if (elements < 1_000_000_000) return String.format("%.1fM", elements / 1_000_000.0); + return String.format("%.1fB", elements / 1_000_000_000.0); + } + + static final class ModelStats { + final AtomicLong inferences = new AtomicLong(); + final AtomicLong totalBatchSize = new AtomicLong(); + final AtomicLong totalInputElements = new AtomicLong(); + final AtomicLong totalOutputElements = new AtomicLong(); + final AtomicLong totalDurationNanos = new AtomicLong(); + final AtomicLong minDurationNanos = new AtomicLong(Long.MAX_VALUE); + final AtomicLong maxDurationNanos = new AtomicLong(0); + final AtomicLong loadCount = new AtomicLong(); + final AtomicLong totalLoadDurationNanos = new AtomicLong(); + volatile String lastDeviceType; + volatile int lastDeviceId; + } + + static final class DeviceMemory { + final AtomicLong currentBytes = new AtomicLong(); + final AtomicLong peakBytes = new AtomicLong(); + final AtomicLong totalAllocated = new AtomicLong(); + final AtomicLong allocCount = new AtomicLong(); + final AtomicLong freeCount = new AtomicLong(); + } + + static final class NativeCallStats { + final AtomicLong calls = new AtomicLong(); + final AtomicLong totalDurationNanos = new AtomicLong(); + } +} diff --git a/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/InferenceRecord.java b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/InferenceRecord.java new file mode 100644 index 000000000..ca848f35d --- /dev/null +++ b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/InferenceRecord.java @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.gpu; + +/** + * Fluent builder for recording a model inference with detailed metrics. + * + *

Obtain via {@link GpuBridgeService#inference(String, String)}. Allocation-free + * (ThreadLocal-pooled). Do not store the returned reference. + * + *

+ * gpu.inference("onnx", "bert-base")
+ *     .batchSize(32)
+ *     .inputElements(512 * 768)
+ *     .outputElements(512 * 2)
+ *     .deviceType("cuda")
+ *     .deviceId(0)
+ *     .duration(durationNanos)
+ *     .record();
+ *

+ */ +public interface InferenceRecord { + + /** Batch size for this inference. */ + InferenceRecord batchSize(int size); + + /** Total number of input tensor elements. */ + InferenceRecord inputElements(long elements); + + /** Total number of output tensor elements. */ + InferenceRecord outputElements(long elements); + + /** Device type: "cuda", "rocm", "cpu", "mps", etc. */ + InferenceRecord deviceType(String type); + + /** Device index (for multi-GPU). */ + InferenceRecord deviceId(int id); + + /** Inference duration in nanoseconds. */ + InferenceRecord duration(long nanos); + + /** Commits this inference record. */ + void record(); +} diff --git a/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/InferenceRecordImpl.java b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/InferenceRecordImpl.java new file mode 100644 index 000000000..834621cac --- /dev/null +++ b/btrace-extensions/btrace-gpu-bridge/src/main/java/io/btrace/gpu/InferenceRecordImpl.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.gpu; + +/** ThreadLocal-pooled builder for {@link InferenceRecord}. Zero allocation. */ +final class InferenceRecordImpl implements InferenceRecord { + + String runtime; + String modelName; + int batchSizeVal; + long inputElem; + long outputElem; + String deviceTypeVal; + int deviceIdVal; + long durationVal; + + private GpuBridgeServiceImpl service; + + InferenceRecordImpl() {} + + InferenceRecordImpl reset(GpuBridgeServiceImpl service, String runtime, String modelName) { + this.service = service; + this.runtime = runtime; + this.modelName = modelName; + this.batchSizeVal = 1; + this.inputElem = 0; + this.outputElem = 0; + this.deviceTypeVal = null; + this.deviceIdVal = 0; + this.durationVal = 0; + return this; + } + + @Override + public InferenceRecord batchSize(int size) { + this.batchSizeVal = size; + return this; + } + + @Override + public InferenceRecord inputElements(long elements) { + this.inputElem = elements; + return this; + } + + @Override + public InferenceRecord outputElements(long elements) { + this.outputElem = elements; + return this; + } + + @Override + public InferenceRecord deviceType(String type) { + this.deviceTypeVal = type; + return this; + } + + @Override + public InferenceRecord deviceId(int id) { + this.deviceIdVal = id; + return this; + } + + @Override + public InferenceRecord duration(long nanos) { + this.durationVal = nanos; + return this; + } + + @Override + public void record() { + service.commitInferenceRecord(this); + } +} diff --git a/btrace-extensions/btrace-gpu-bridge/src/test/java/io/btrace/gpu/GpuBridgeServiceTest.java b/btrace-extensions/btrace-gpu-bridge/src/test/java/io/btrace/gpu/GpuBridgeServiceTest.java new file mode 100644 index 000000000..63f493115 --- /dev/null +++ b/btrace-extensions/btrace-gpu-bridge/src/test/java/io/btrace/gpu/GpuBridgeServiceTest.java @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.gpu; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.concurrent.CountDownLatch; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class GpuBridgeServiceTest { + + private GpuBridgeServiceImpl service; + + @BeforeEach + void setUp() { + service = new GpuBridgeServiceImpl(); + } + + // ==================== Inference recording ==================== + + @Test + void durationOnlyInference() { + service.recordInference("onnx", "resnet50", 10_000_000L); + assertEquals(1, service.getTotalInferences()); + assertTrue(service.getSummary().contains("onnx/resnet50")); + } + + @Test + void inferenceWithBatchSize() { + service.recordInference("djl", "bert", 32, 50_000_000L); + assertEquals(1, service.getTotalInferences()); + assertTrue(service.getSummary().contains("avg 32")); + } + + @Test + void fluentBuilder() { + service + .inference("onnx", "yolo-v8") + .batchSize(16) + .inputElements(640L * 640 * 3) + .outputElements(8400L * 84) + .deviceType("cuda") + .deviceId(0) + .duration(25_000_000L) + .record(); + + assertEquals(1, service.getTotalInferences()); + String summary = service.getSummary(); + assertTrue(summary.contains("cuda:0")); + assertTrue(summary.contains("items/sec")); + } + + @Test + void fluentBuilderMinimal() { + service.inference("tensorflow", "mobilenet").duration(5_000_000L).record(); + + assertEquals(1, service.getTotalInferences()); + } + + @Test + void multipleModelsTrackedSeparately() { + service.recordInference("onnx", "resnet50", 10_000_000L); + service.recordInference("onnx", "bert", 20_000_000L); + service.recordInference("onnx", "resnet50", 12_000_000L); + + assertEquals(3, service.getTotalInferences()); + assertTrue(service.getModelSummary("resnet50").contains("2 inferences")); + assertTrue(service.getModelSummary("bert").contains("1 inferences")); + } + + @Test + void latencyMinMax() { + service.recordInference("onnx", "model", 5_000_000L); + service.recordInference("onnx", "model", 50_000_000L); + service.recordInference("onnx", "model", 10_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("min 5ms")); + assertTrue(summary.contains("max 50ms")); + } + + // ==================== Memory tracking ==================== + + @Test + void memoryAllocAndFree() { + service.recordMemoryAlloc("cuda", 0, 1024 * 1024 * 100); // 100MB + assertEquals(100 * 1024 * 1024L, service.getCurrentGpuMemoryBytes()); + assertEquals(100 * 1024 * 1024L, service.getPeakGpuMemoryBytes()); + + service.recordMemoryFree("cuda", 0, 1024 * 1024 * 50); // free 50MB + assertEquals(50 * 1024 * 1024L, service.getCurrentGpuMemoryBytes()); + assertEquals(100 * 1024 * 1024L, service.getPeakGpuMemoryBytes()); // peak unchanged + } + + @Test + void noMemoryTracked() { + assertEquals(-1, service.getCurrentGpuMemoryBytes()); + assertEquals(-1, service.getPeakGpuMemoryBytes()); + } + + @Test + void memorySummary() { + service.recordMemoryAlloc("cuda", 0, 500 * 1024 * 1024L); + String summary = service.getSummary(); + assertTrue(summary.contains("Device Memory")); + assertTrue(summary.contains("500MB")); + } + + // ==================== Native call tracking ==================== + + @Test + void nativeCalls() { + service.recordNativeCall("cublas", "sgemm", 500_000L); + service.recordNativeCall("cublas", "sgemm", 600_000L); + service.recordNativeCall("cudnn", "conv_forward", 1_000_000L); + + assertEquals(3, service.getTotalNativeCalls()); + String summary = service.getSummary(); + assertTrue(summary.contains("cublas::sgemm")); + assertTrue(summary.contains("2 calls")); + } + + // ==================== Model lifecycle ==================== + + @Test + void modelLoad() { + service.recordModelLoad("onnx", "bert", 2_000_000_000L); // 2 seconds + service.recordInference("onnx", "bert", 10_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("loaded 1x")); + assertTrue(summary.contains("2000ms")); + } + + // ==================== Reporting ==================== + + @Test + void noDataSummary() { + assertEquals("No GPU/inference activity recorded.", service.getSummary()); + } + + @Test + void unknownModelSummary() { + assertEquals("No data for model: unknown", service.getModelSummary("unknown")); + } + + @Test + void formatBytes() { + assertEquals("100B", GpuBridgeServiceImpl.formatBytes(100)); + assertEquals("10KB", GpuBridgeServiceImpl.formatBytes(10 * 1024)); + assertEquals("256MB", GpuBridgeServiceImpl.formatBytes(256 * 1024 * 1024)); + assertEquals("1.5GB", GpuBridgeServiceImpl.formatBytes((long) (1.5 * 1024 * 1024 * 1024))); + } + + @Test + void formatElements() { + assertEquals("500", GpuBridgeServiceImpl.formatElements(500)); + assertEquals("1.5K", GpuBridgeServiceImpl.formatElements(1500)); + assertEquals("2.0M", GpuBridgeServiceImpl.formatElements(2_000_000)); + assertEquals("1.0B", GpuBridgeServiceImpl.formatElements(1_000_000_000)); + } + + @Test + void reset() { + service.recordInference("onnx", "model", 1L); + service.recordMemoryAlloc("cuda", 0, 1024); + service.recordNativeCall("cublas", "fn", 1L); + service.reset(); + + assertEquals(0, service.getTotalInferences()); + assertEquals(-1, service.getCurrentGpuMemoryBytes()); + assertEquals(0, service.getTotalNativeCalls()); + assertEquals("No GPU/inference activity recorded.", service.getSummary()); + } + + @Test + void concurrentInference() throws Exception { + int threads = 8; + int infsPerThread = 1000; + CountDownLatch latch = new CountDownLatch(threads); + + for (int t = 0; t < threads; t++) { + new Thread( + () -> { + try { + for (int i = 0; i < infsPerThread; i++) { + service.recordInference("onnx", "model", 32, 1_000_000L); + } + } finally { + latch.countDown(); + } + }) + .start(); + } + latch.await(); + + assertEquals(threads * infsPerThread, service.getTotalInferences()); + } + + @Test + void concurrentBuilderInference() throws Exception { + int threads = 8; + int infsPerThread = 500; + CountDownLatch latch = new CountDownLatch(threads); + + for (int t = 0; t < threads; t++) { + new Thread( + () -> { + try { + for (int i = 0; i < infsPerThread; i++) { + service.inference("djl", "bert").batchSize(16).duration(2_000_000L).record(); + } + } finally { + latch.countDown(); + } + }) + .start(); + } + latch.await(); + + assertEquals(threads * infsPerThread, service.getTotalInferences()); + } +} diff --git a/btrace-extensions/btrace-llm-trace/build.gradle b/btrace-extensions/btrace-llm-trace/build.gradle new file mode 100644 index 000000000..a761069ff --- /dev/null +++ b/btrace-extensions/btrace-llm-trace/build.gradle @@ -0,0 +1,35 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-llm-trace' + name = 'BTrace LLM Tracing' + description = 'LLM inference observability: token counts, latency, cost tracking for Java LLM SDKs' + services = ['io.btrace.llm.LlmTraceService'] +} + +dependencies { + apiCompileOnly 'org.jetbrains:annotations:26.1.0' + apiCompileOnly project(':btrace-core') + implCompileOnly 'org.jetbrains:annotations:26.1.0' + implImplementation project(':btrace-core') + + testImplementation libs.junit.jupiter +} + +test { + useJUnitPlatform() +} diff --git a/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/CallRecord.java b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/CallRecord.java new file mode 100644 index 000000000..07089e7be --- /dev/null +++ b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/CallRecord.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.llm; + +/** + * Fluent builder for recording an LLM API call. + * + *

Obtain via {@link LlmTraceService#call(String)}. All setters are optional except {@link + * #duration(long)} — if omitted, duration defaults to 0. + * + *

Call {@link #record()} to commit the metrics. + * + *

Allocation-free: Instances are pooled per-thread internally, so calling + * {@code call()} does not allocate on the heap. Safe for hot-path instrumentation. However, the + * returned reference must not be stored or shared across threads — use it inline and call {@link + * #record()} immediately. + * + *

+ * llm.call("claude-sonnet-4-20250514")
+ *     .provider("anthropic")
+ *     .inputTokens(1500)
+ *     .outputTokens(300)
+ *     .cacheReadTokens(800)
+ *     .duration(durationNanos)
+ *     .record();
+ *

+ */ +public interface CallRecord { + + /** Sets the provider name (e.g. "openai", "anthropic", "google"). */ + CallRecord provider(String provider); + + /** Sets the number of input/prompt tokens. */ + CallRecord inputTokens(int tokens); + + /** Sets the number of output/completion tokens. */ + CallRecord outputTokens(int tokens); + + /** + * Sets the number of cache-read input tokens (prompt caching). Anthropic: {@code + * usage.cache_read_input_tokens}. OpenAI: {@code usage.prompt_tokens_details.cached_tokens}. + */ + CallRecord cacheReadTokens(int tokens); + + /** + * Sets the number of cache-creation input tokens. Anthropic: {@code + * usage.cache_creation_input_tokens}. + */ + CallRecord cacheCreationTokens(int tokens); + + /** Marks this call as a streaming response. */ + CallRecord streaming(); + + /** + * Sets the time-to-first-token for streaming calls. Only meaningful when {@link #streaming()} is + * set. + * + * @param nanos time from request start to first token, in nanoseconds + */ + CallRecord timeToFirstToken(long nanos); + + /** + * Sets the total call duration. + * + * @param nanos duration in nanoseconds (typically from {@code @Duration}) + */ + CallRecord duration(long nanos); + + /** + * Commits this call record to the trace service. Must be called exactly once to record the + * metrics. + */ + void record(); +} diff --git a/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/CallRecordImpl.java b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/CallRecordImpl.java new file mode 100644 index 000000000..8906b8b0c --- /dev/null +++ b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/CallRecordImpl.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.llm; + +/** + * Mutable builder implementing the {@link CallRecord} fluent API. + * + *

Instances are pooled per-thread via {@link ThreadLocal} to avoid heap allocation on every + * {@code call()} invocation. This makes the builder safe for hot-path instrumentation — no garbage + * is produced. + * + *

Not thread-safe — intended to be created, configured, and recorded within a single BTrace + * handler method invocation on the same thread. + */ +final class CallRecordImpl implements CallRecord { + + String model; + String providerVal; + int inputTok; + int outputTok; + int cacheReadTok; + int cacheCreateTok; + boolean isStreaming; + long ttftVal; + long durationVal; + + private LlmTraceServiceImpl service; + + CallRecordImpl() { + // Created once per thread via ThreadLocal + } + + /** Resets all fields and binds this record to a new call. */ + CallRecordImpl reset(LlmTraceServiceImpl service, String model) { + this.service = service; + this.model = model; + this.providerVal = null; + this.inputTok = 0; + this.outputTok = 0; + this.cacheReadTok = 0; + this.cacheCreateTok = 0; + this.isStreaming = false; + this.ttftVal = 0; + this.durationVal = 0; + return this; + } + + @Override + public CallRecord provider(String provider) { + this.providerVal = provider; + return this; + } + + @Override + public CallRecord inputTokens(int tokens) { + this.inputTok = tokens; + return this; + } + + @Override + public CallRecord outputTokens(int tokens) { + this.outputTok = tokens; + return this; + } + + @Override + public CallRecord cacheReadTokens(int tokens) { + this.cacheReadTok = tokens; + return this; + } + + @Override + public CallRecord cacheCreationTokens(int tokens) { + this.cacheCreateTok = tokens; + return this; + } + + @Override + public CallRecord streaming() { + this.isStreaming = true; + return this; + } + + @Override + public CallRecord timeToFirstToken(long nanos) { + this.ttftVal = nanos; + return this; + } + + @Override + public CallRecord duration(long nanos) { + this.durationVal = nanos; + return this; + } + + @Override + public void record() { + service.commitCallRecord(this); + } +} diff --git a/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/LlmTraceService.java b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/LlmTraceService.java new file mode 100644 index 000000000..3e8b20f3a --- /dev/null +++ b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/LlmTraceService.java @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.llm; + +import io.btrace.core.extensions.ServiceDescriptor; +import org.jetbrains.annotations.Nullable; + +/** + * LLM inference observability service for BTrace scripts. + * + *

Records LLM API call metrics — token counts, latencies, costs — and provides aggregated + * statistics. Scripts use {@code @OnMethod} to intercept LLM SDK calls and feed data into this + * service. + * + *

Thread-safe. All methods can be called concurrently from instrumented threads. + * + *

Quick start — latency only (works with any SDK)

+ * + *

+ * @Injected private static LlmTraceService llm;
+ *
+ * @OnMethod(clazz = "+dev.langchain4j.model.chat.ChatLanguageModel",
+ *           method = "generate", location = @Location(Kind.RETURN))
+ * public static void onChat(@ProbeClassName String cls, @Duration long dur) {
+ *     llm.recordCall(cls, dur);
+ * }
+ *

+ * + *

Full metrics with fluent builder

+ * + *

+ * llm.call("claude-sonnet-4-20250514")
+ *     .provider("anthropic")
+ *     .inputTokens(1500)
+ *     .outputTokens(300)
+ *     .cacheReadTokens(800)
+ *     .duration(durationNanos)
+ *     .record();
+ *

+ */ +@ServiceDescriptor +public interface LlmTraceService { + + // ==================== Simple recording ==================== + + /** + * Records an LLM call with only latency (no token info). Use this when token counts aren't easily + * extractable. + * + * @param model model identifier or class name + * @param durationNanos call duration in nanoseconds + */ + void recordCall(String model, long durationNanos); + + /** + * Records an LLM call with token counts. + * + * @param model model identifier (e.g. "gpt-4o", "claude-sonnet-4-20250514") + * @param inputTokens number of input/prompt tokens + * @param outputTokens number of output/completion tokens + * @param durationNanos call duration in nanoseconds + */ + void recordCall(String model, int inputTokens, int outputTokens, long durationNanos); + + // ==================== Fluent builder ==================== + + /** + * Starts a fluent call record for the given model. + * + *

The returned builder is allocation-free (ThreadLocal-pooled). It is safe to use on hot + * paths. The builder must be used inline on the calling thread and {@link CallRecord#record()} + * must be called before the next {@code call()}. + * + *

+   * llm.call("claude-sonnet-4-20250514")
+   *     .provider("anthropic")
+   *     .inputTokens(1500)
+   *     .outputTokens(300)
+   *     .cacheReadTokens(800)
+   *     .streaming()
+   *     .timeToFirstToken(200_000_000L)
+   *     .duration(durationNanos)
+   *     .record();
+   *

+ * + * @param model model identifier + * @return a call record builder (thread-local, do not store) + */ + @Nullable CallRecord call(String model); + + // ==================== Specialized recording ==================== + + /** + * Records an embedding API call. + * + * @param model embedding model identifier (e.g. "text-embedding-3-small") + * @param tokenCount number of tokens embedded + * @param durationNanos call duration in nanoseconds + */ + void recordEmbedding(String model, int tokenCount, long durationNanos); + + /** + * Records a tool/function call invocation by the LLM. + * + * @param model model that made the tool call + * @param toolName name of the tool/function called + */ + void recordToolUse(String model, String toolName); + + /** + * Records a failed LLM API call. + * + * @param model model identifier + * @param errorType error class name or HTTP status code + * @param durationNanos call duration before failure + */ + void recordError(String model, String errorType, long durationNanos); + + // ==================== Reporting ==================== + + /** + * Returns a formatted summary of all recorded metrics. Includes per-model token counts, latency + * stats, cost estimates, cache hit rates, tool use, and error breakdown. + * + * @return multi-line summary string + */ + @Nullable String getSummary(); + + /** + * Returns a one-line summary for a specific model. + * + * @param model model identifier + * @return summary string, or "No data" if none recorded + */ + @Nullable String getModelSummary(String model); + + /** + * Returns total estimated cost across all models in USD. Uses built-in pricing table. Returns -1 + * if all models are unknown. + * + * @return estimated cost in USD, or -1 if pricing unknown + */ + double getEstimatedCostUsd(); + + /** Returns total number of chat completion calls recorded. */ + long getTotalCalls(); + + /** Returns total input tokens across all calls. */ + long getTotalInputTokens(); + + /** Returns total output tokens across all calls. */ + long getTotalOutputTokens(); + + /** Returns total number of embedding calls recorded. */ + long getTotalEmbeddingCalls(); + + /** Resets all collected metrics. */ + void reset(); +} diff --git a/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/LlmTraceServiceImpl.java b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/LlmTraceServiceImpl.java new file mode 100644 index 000000000..3c9ed33ec --- /dev/null +++ b/btrace-extensions/btrace-llm-trace/src/main/java/io/btrace/llm/LlmTraceServiceImpl.java @@ -0,0 +1,487 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.llm; + +import io.btrace.core.extensions.Extension; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +/** Thread-safe LLM call tracing with lock-free per-model statistics. Zero external dependencies. */ +public final class LlmTraceServiceImpl extends Extension implements LlmTraceService { + + private final Map modelStats = new ConcurrentHashMap<>(); + private final Map embeddingStats = new ConcurrentHashMap<>(); + private final Map toolUseCounts = new ConcurrentHashMap<>(); + private final Map errorCounts = new ConcurrentHashMap<>(); + + // ==================== Simple recording ==================== + + @Override + public void recordCall(String model, long durationNanos) { + ModelStats stats = getOrCreate(modelStats, model); + stats.calls.incrementAndGet(); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + @Override + public void recordCall(String model, int inputTokens, int outputTokens, long durationNanos) { + ModelStats stats = getOrCreate(modelStats, model); + stats.calls.incrementAndGet(); + stats.inputTokens.addAndGet(inputTokens); + stats.outputTokens.addAndGet(outputTokens); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + // ==================== Fluent builder ==================== + + /** + * ThreadLocal-pooled builder — one CallRecordImpl per thread, reused across calls. Eliminates + * per-call heap allocation, making the builder safe for hot paths. + */ + private final ThreadLocal callRecordPool = + ThreadLocal.withInitial(CallRecordImpl::new); + + @Override + public CallRecord call(String model) { + return callRecordPool.get().reset(this, model); + } + + void commitCallRecord(CallRecordImpl rec) { + ModelStats stats = getOrCreate(modelStats, rec.model); + if (rec.providerVal != null) { + stats.provider = rec.providerVal; + } + stats.calls.incrementAndGet(); + stats.inputTokens.addAndGet(rec.inputTok); + stats.outputTokens.addAndGet(rec.outputTok); + stats.cacheReadTokens.addAndGet(rec.cacheReadTok); + stats.cacheCreationTokens.addAndGet(rec.cacheCreateTok); + stats.totalDurationNanos.addAndGet(rec.durationVal); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, rec.durationVal); + if (rec.isStreaming) { + stats.streamingCalls.incrementAndGet(); + stats.totalTimeToFirstToken.addAndGet(rec.ttftVal); + } + } + + // ==================== Specialized recording ==================== + + @Override + public void recordEmbedding(String model, int tokenCount, long durationNanos) { + ModelStats stats = getOrCreate(embeddingStats, model); + stats.calls.incrementAndGet(); + stats.inputTokens.addAndGet(tokenCount); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + @Override + public void recordToolUse(String model, String toolName) { + String key = model + "::" + toolName; + toolUseCounts.computeIfAbsent(key, k -> new AtomicLong()).incrementAndGet(); + getOrCreate(modelStats, model).toolCalls.incrementAndGet(); + } + + @Override + public void recordError(String model, String errorType, long durationNanos) { + String key = model + "::" + errorType; + errorCounts.computeIfAbsent(key, k -> new AtomicLong()).incrementAndGet(); + getOrCreate(modelStats, model).errors.incrementAndGet(); + } + + // ==================== Reporting ==================== + + @Override + public String getSummary() { + if (modelStats.isEmpty() && embeddingStats.isEmpty()) { + return "No LLM calls recorded."; + } + + StringBuilder sb = new StringBuilder(); + sb.append("=== LLM Trace Summary ===\n\n"); + + long totalCalls = 0; + long totalIn = 0; + long totalOut = 0; + double totalCost = 0; + + // Chat completions + for (Map.Entry entry : modelStats.entrySet()) { + String model = entry.getKey(); + ModelStats s = entry.getValue(); + long calls = s.calls.get(); + long inTok = s.inputTokens.get(); + long outTok = s.outputTokens.get(); + long cacheRead = s.cacheReadTokens.get(); + long cacheCreate = s.cacheCreationTokens.get(); + + totalCalls += calls; + totalIn += inTok; + totalOut += outTok; + + sb.append("Model: ").append(model); + if (!"unknown".equals(s.provider)) { + sb.append(" (").append(s.provider).append(")"); + } + sb.append("\n"); + + // Calls + sb.append(" Calls: ").append(calls); + long streaming = s.streamingCalls.get(); + if (streaming > 0) { + sb.append(" (").append(streaming).append(" streaming)"); + } + sb.append("\n"); + + // Tokens + if (inTok > 0 || outTok > 0) { + sb.append(" Tokens: ").append(inTok).append(" in / ").append(outTok).append(" out"); + if (calls > 0) { + sb.append(" (avg ").append(inTok / calls).append("/").append(outTok / calls).append(")"); + } + sb.append("\n"); + } + + // Cache + if (cacheRead > 0 || cacheCreate > 0) { + sb.append(" Cache: "); + if (cacheRead > 0) { + sb.append(cacheRead).append(" read"); + // Show cache hit rate relative to total input + if (inTok > 0) { + long hitPct = (cacheRead * 100) / inTok; + sb.append(" (").append(hitPct).append("% hit)"); + } + } + if (cacheCreate > 0) { + if (cacheRead > 0) sb.append(", "); + sb.append(cacheCreate).append(" created"); + } + sb.append("\n"); + } + + // Latency + if (calls > 0) { + long avgMs = (s.totalDurationNanos.get() / calls) / 1_000_000; + long minMs = s.minDurationNanos.get() / 1_000_000; + long maxMs = s.maxDurationNanos.get() / 1_000_000; + sb.append(" Latency: avg ").append(avgMs).append("ms"); + sb.append(", min ").append(minMs).append("ms"); + sb.append(", max ").append(maxMs).append("ms\n"); + } + + // TTFT + if (streaming > 0) { + long avgTtft = (s.totalTimeToFirstToken.get() / streaming) / 1_000_000; + sb.append(" TTFT (avg): ").append(avgTtft).append("ms\n"); + } + + // Tool calls + long tc = s.toolCalls.get(); + if (tc > 0) { + sb.append(" Tool calls: ").append(tc).append("\n"); + } + + // Errors + long errs = s.errors.get(); + if (errs > 0) { + sb.append(" Errors: ").append(errs).append("\n"); + } + + // Cost + double cost = estimateCost(model, inTok, outTok, cacheRead); + if (cost >= 0) { + totalCost += cost; + sb.append(" Est. cost: $").append(formatCost(cost)); + if (cacheRead > 0) { + double uncachedCost = estimateCost(model, inTok + cacheRead, outTok, 0); + if (uncachedCost > cost) { + sb.append(" (saved $").append(formatCost(uncachedCost - cost)).append(" via cache)"); + } + } + sb.append("\n"); + } + sb.append("\n"); + } + + // Embeddings + if (!embeddingStats.isEmpty()) { + sb.append("--- Embeddings ---\n"); + for (Map.Entry entry : embeddingStats.entrySet()) { + ModelStats s = entry.getValue(); + long calls = s.calls.get(); + long tokens = s.inputTokens.get(); + long avgMs = calls > 0 ? (s.totalDurationNanos.get() / calls) / 1_000_000 : 0; + sb.append(" ") + .append(entry.getKey()) + .append(": ") + .append(calls) + .append(" calls, ") + .append(tokens) + .append(" tokens, avg ") + .append(avgMs) + .append("ms\n"); + } + sb.append("\n"); + } + + // Tool use breakdown + if (!toolUseCounts.isEmpty()) { + sb.append("--- Tool Use ---\n"); + for (Map.Entry entry : toolUseCounts.entrySet()) { + sb.append(" ") + .append(entry.getKey()) + .append(": ") + .append(entry.getValue().get()) + .append("\n"); + } + sb.append("\n"); + } + + // Error breakdown + if (!errorCounts.isEmpty()) { + sb.append("--- Errors ---\n"); + for (Map.Entry entry : errorCounts.entrySet()) { + sb.append(" ") + .append(entry.getKey()) + .append(": ") + .append(entry.getValue().get()) + .append("\n"); + } + sb.append("\n"); + } + + sb.append("--- Totals ---\n"); + sb.append(" Calls: ").append(totalCalls).append("\n"); + if (totalIn > 0 || totalOut > 0) { + sb.append(" Tokens: ").append(totalIn).append(" in / ").append(totalOut).append(" out\n"); + } + if (totalCost > 0) { + sb.append(" Est. total cost: $").append(formatCost(totalCost)).append("\n"); + } + + return sb.toString(); + } + + @Override + public String getModelSummary(String model) { + ModelStats s = modelStats.get(model); + if (s == null) { + return "No data for model: " + model; + } + long calls = s.calls.get(); + long inTok = s.inputTokens.get(); + long outTok = s.outputTokens.get(); + long avgMs = calls > 0 ? (s.totalDurationNanos.get() / calls) / 1_000_000 : 0; + + StringBuilder sb = new StringBuilder(); + sb.append(model).append(": ").append(calls).append(" calls"); + if (inTok > 0 || outTok > 0) { + sb.append(", ").append(inTok).append("/").append(outTok).append(" tokens (in/out)"); + } + sb.append(", avg ").append(avgMs).append("ms"); + return sb.toString(); + } + + @Override + public double getEstimatedCostUsd() { + double total = 0; + boolean anyKnown = false; + for (Map.Entry entry : modelStats.entrySet()) { + ModelStats s = entry.getValue(); + double cost = + estimateCost( + entry.getKey(), s.inputTokens.get(), s.outputTokens.get(), s.cacheReadTokens.get()); + if (cost >= 0) { + total += cost; + anyKnown = true; + } + } + return anyKnown ? total : -1; + } + + @Override + public long getTotalCalls() { + long total = 0; + for (ModelStats s : modelStats.values()) { + total += s.calls.get(); + } + return total; + } + + @Override + public long getTotalInputTokens() { + long total = 0; + for (ModelStats s : modelStats.values()) { + total += s.inputTokens.get(); + } + return total; + } + + @Override + public long getTotalOutputTokens() { + long total = 0; + for (ModelStats s : modelStats.values()) { + total += s.outputTokens.get(); + } + return total; + } + + @Override + public long getTotalEmbeddingCalls() { + long total = 0; + for (ModelStats s : embeddingStats.values()) { + total += s.calls.get(); + } + return total; + } + + @Override + public void reset() { + modelStats.clear(); + embeddingStats.clear(); + toolUseCounts.clear(); + errorCounts.clear(); + } + + @Override + public void close() { + String summary = getSummary(); + if (!"No LLM calls recorded.".equals(summary)) { + getContext().send(summary); + } + } + + // ==================== Internals ==================== + + private static ModelStats getOrCreate(Map map, String key) { + return map.computeIfAbsent(key, k -> new ModelStats()); + } + + private static void updateMinMax(AtomicLong min, AtomicLong max, long value) { + long cur; + do { + cur = min.get(); + if (value >= cur) break; + } while (!min.compareAndSet(cur, value)); + do { + cur = max.get(); + if (value <= cur) break; + } while (!max.compareAndSet(cur, value)); + } + + /** + * Estimates cost in USD. Cache-read tokens are priced at ~10% of input rate for models that + * support caching. + */ + static double estimateCost( + String model, long inputTokens, long outputTokens, long cacheReadTokens) { + double inputPer1M = -1; + double outputPer1M = -1; + double cacheReadPer1M = -1; + + String m = model.toLowerCase(); + + // Anthropic Claude + if (m.contains("claude") && m.contains("opus")) { + inputPer1M = 15.0; + outputPer1M = 75.0; + cacheReadPer1M = 1.50; + } else if (m.contains("claude") && m.contains("sonnet")) { + inputPer1M = 3.0; + outputPer1M = 15.0; + cacheReadPer1M = 0.30; + } else if (m.contains("claude") && m.contains("haiku")) { + inputPer1M = 0.80; + outputPer1M = 4.0; + cacheReadPer1M = 0.08; + } + // OpenAI GPT + else if (m.contains("gpt-4o-mini")) { + inputPer1M = 0.15; + outputPer1M = 0.60; + cacheReadPer1M = 0.075; + } else if (m.contains("gpt-4o")) { + inputPer1M = 2.50; + outputPer1M = 10.0; + cacheReadPer1M = 1.25; + } else if (m.contains("gpt-4") && m.contains("turbo")) { + inputPer1M = 10.0; + outputPer1M = 30.0; + } else if (m.contains("gpt-4")) { + inputPer1M = 30.0; + outputPer1M = 60.0; + } else if (m.contains("gpt-3.5")) { + inputPer1M = 0.50; + outputPer1M = 1.50; + } else if (m.contains("o1-mini")) { + inputPer1M = 3.0; + outputPer1M = 12.0; + cacheReadPer1M = 1.50; + } else if (m.contains("o1")) { + inputPer1M = 15.0; + outputPer1M = 60.0; + cacheReadPer1M = 7.50; + } + // Google Gemini + else if (m.contains("gemini") && m.contains("pro")) { + inputPer1M = 1.25; + outputPer1M = 5.0; + } else if (m.contains("gemini") && m.contains("flash")) { + inputPer1M = 0.075; + outputPer1M = 0.30; + } + + if (inputPer1M < 0) { + return -1; + } + + double cost = + (inputTokens * inputPer1M / 1_000_000.0) + (outputTokens * outputPer1M / 1_000_000.0); + if (cacheReadTokens > 0 && cacheReadPer1M > 0) { + cost += (cacheReadTokens * cacheReadPer1M / 1_000_000.0); + } + return cost; + } + + static String formatCost(double cost) { + if (cost < 0.01) { + return String.format("%.4f", cost); + } + return String.format("%.2f", cost); + } + + /** Lock-free per-model statistics. */ + static final class ModelStats { + volatile String provider = "unknown"; + final AtomicLong calls = new AtomicLong(); + final AtomicLong streamingCalls = new AtomicLong(); + final AtomicLong inputTokens = new AtomicLong(); + final AtomicLong outputTokens = new AtomicLong(); + final AtomicLong cacheReadTokens = new AtomicLong(); + final AtomicLong cacheCreationTokens = new AtomicLong(); + final AtomicLong totalDurationNanos = new AtomicLong(); + final AtomicLong minDurationNanos = new AtomicLong(Long.MAX_VALUE); + final AtomicLong maxDurationNanos = new AtomicLong(0); + final AtomicLong totalTimeToFirstToken = new AtomicLong(); + final AtomicLong toolCalls = new AtomicLong(); + final AtomicLong errors = new AtomicLong(); + } +} diff --git a/btrace-extensions/btrace-llm-trace/src/test/java/io/btrace/llm/LlmTraceServiceTest.java b/btrace-extensions/btrace-llm-trace/src/test/java/io/btrace/llm/LlmTraceServiceTest.java new file mode 100644 index 000000000..81eff612b --- /dev/null +++ b/btrace-extensions/btrace-llm-trace/src/test/java/io/btrace/llm/LlmTraceServiceTest.java @@ -0,0 +1,356 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.llm; + +import static org.junit.jupiter.api.Assertions.*; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class LlmTraceServiceTest { + + private LlmTraceServiceImpl service; + + @BeforeEach + void setUp() { + service = new LlmTraceServiceImpl(); + } + + // ==================== Simple recording ==================== + + @Test + void recordCallDurationOnly() { + service.recordCall("gpt-4o", 500_000_000L); + service.recordCall("gpt-4o", 300_000_000L); + + assertEquals(2, service.getTotalCalls()); + assertEquals(0, service.getTotalInputTokens(), "No tokens recorded"); + String summary = service.getModelSummary("gpt-4o"); + assertTrue(summary.contains("2 calls")); + assertTrue(summary.contains("400ms"), "avg of 500ms and 300ms"); + } + + @Test + void recordCallWithTokens() { + service.recordCall("claude-sonnet-4-20250514", 1000, 200, 500_000_000L); + service.recordCall("claude-sonnet-4-20250514", 800, 300, 400_000_000L); + + assertEquals(2, service.getTotalCalls()); + assertEquals(1800, service.getTotalInputTokens()); + assertEquals(500, service.getTotalOutputTokens()); + } + + // ==================== Fluent builder ==================== + + @Test + void fluentBuilderBasic() { + service.call("gpt-4o").inputTokens(1000).outputTokens(200).duration(500_000_000L).record(); + + assertEquals(1, service.getTotalCalls()); + assertEquals(1000, service.getTotalInputTokens()); + assertEquals(200, service.getTotalOutputTokens()); + } + + @Test + void fluentBuilderWithProvider() { + service + .call("claude-sonnet-4-20250514") + .provider("anthropic") + .inputTokens(1500) + .outputTokens(300) + .duration(800_000_000L) + .record(); + + String summary = service.getSummary(); + assertTrue(summary.contains("anthropic")); + assertTrue(summary.contains("claude-sonnet")); + } + + @Test + void fluentBuilderWithCache() { + service + .call("claude-sonnet-4-20250514") + .inputTokens(500) + .outputTokens(200) + .cacheReadTokens(1000) + .cacheCreationTokens(200) + .duration(300_000_000L) + .record(); + + String summary = service.getSummary(); + assertTrue(summary.contains("Cache:"), "Should show cache section"); + assertTrue(summary.contains("1000 read"), "Should show cache read tokens"); + assertTrue(summary.contains("200 created"), "Should show cache creation tokens"); + assertTrue(summary.contains("saved $"), "Should show cache savings"); + } + + @Test + void fluentBuilderStreaming() { + service + .call("gpt-4o") + .inputTokens(2000) + .outputTokens(500) + .streaming() + .timeToFirstToken(200_000_000L) + .duration(3_000_000_000L) + .record(); + + String summary = service.getSummary(); + assertTrue(summary.contains("streaming")); + assertTrue(summary.contains("TTFT")); + } + + @Test + void fluentBuilderDurationOnly() { + // Minimal usage — just model + duration + service.call("some-model").duration(100_000_000L).record(); + + assertEquals(1, service.getTotalCalls()); + } + + // ==================== Embeddings ==================== + + @Test + void recordEmbedding() { + service.recordEmbedding("text-embedding-3-small", 500, 50_000_000L); + service.recordEmbedding("text-embedding-3-small", 300, 30_000_000L); + + assertEquals(2, service.getTotalEmbeddingCalls()); + assertEquals(0, service.getTotalCalls(), "Embeddings don't count as chat calls"); + + String summary = service.getSummary(); + assertTrue(summary.contains("Embeddings")); + assertTrue(summary.contains("text-embedding-3-small")); + assertTrue(summary.contains("2 calls")); + assertTrue(summary.contains("800 tokens")); + } + + // ==================== Tool use ==================== + + @Test + void recordToolUse() { + service.recordCall("claude-sonnet-4-20250514", 1000, 200, 500_000_000L); + service.recordToolUse("claude-sonnet-4-20250514", "search_web"); + service.recordToolUse("claude-sonnet-4-20250514", "search_web"); + service.recordToolUse("claude-sonnet-4-20250514", "run_code"); + + String summary = service.getSummary(); + assertTrue(summary.contains("Tool calls: 3")); + assertTrue(summary.contains("Tool Use")); + assertTrue(summary.contains("search_web")); + } + + // ==================== Errors ==================== + + @Test + void recordError() { + service.recordCall("gpt-4o", 1000, 0, 100_000_000L); + service.recordError("gpt-4o", "RateLimitException", 50_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("Errors: 1")); + assertTrue(summary.contains("RateLimitException")); + } + + // ==================== Model summary ==================== + + @Test + void getModelSummaryUnknown() { + assertTrue(service.getModelSummary("nonexistent").contains("No data")); + } + + @Test + void getModelSummaryDurationOnly() { + service.recordCall("my-model", 500_000_000L); + String result = service.getModelSummary("my-model"); + assertTrue(result.contains("1 calls")); + assertTrue(result.contains("500ms")); + // Should NOT show "0/0 tokens" + assertFalse(result.contains("0/0")); + } + + @Test + void getModelSummaryWithTokens() { + service.recordCall("gpt-4o", 1000, 200, 500_000_000L); + String result = service.getModelSummary("gpt-4o"); + assertTrue(result.contains("1000/200 tokens")); + } + + // ==================== Cost estimation ==================== + + @Test + void estimateCostClaudeSonnet() { + // Sonnet: $3/1M input, $15/1M output + double cost = + LlmTraceServiceImpl.estimateCost("claude-sonnet-4-20250514", 1_000_000, 100_000, 0); + assertEquals(3.0 + 1.5, cost, 0.01); + } + + @Test + void estimateCostWithCacheRead() { + // Sonnet: $3/1M input, $15/1M output, $0.30/1M cache-read + double cost = + LlmTraceServiceImpl.estimateCost("claude-sonnet-4-20250514", 500_000, 100_000, 500_000); + double expected = (500_000 * 3.0 / 1e6) + (100_000 * 15.0 / 1e6) + (500_000 * 0.30 / 1e6); + assertEquals(expected, cost, 0.001); + } + + @Test + void estimateCostGpt4o() { + double cost = LlmTraceServiceImpl.estimateCost("gpt-4o", 1_000_000, 1_000_000, 0); + assertEquals(2.50 + 10.0, cost, 0.01); + } + + @Test + void estimateCostUnknownModel() { + assertEquals(-1, LlmTraceServiceImpl.estimateCost("my-custom-model", 1000, 1000, 0)); + } + + @Test + void estimatedCostUsdAcrossModels() { + service.recordCall("claude-sonnet-4-20250514", 1_000_000, 0, 1_000_000_000L); + service.recordCall("gpt-4o", 1_000_000, 0, 1_000_000_000L); + + double cost = service.getEstimatedCostUsd(); + assertEquals(5.50, cost, 0.01); + } + + @Test + void estimatedCostUsdUnknownModels() { + service.recordCall("my-custom-model", 1000, 500, 100_000_000L); + assertEquals(-1, service.getEstimatedCostUsd()); + } + + // ==================== Latency tracking ==================== + + @Test + void latencyMinMax() { + service.recordCall("gpt-4o", 100, 50, 100_000_000L); + service.recordCall("gpt-4o", 100, 50, 500_000_000L); + service.recordCall("gpt-4o", 100, 50, 200_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("min 100ms")); + assertTrue(summary.contains("max 500ms")); + } + + // ==================== Reset ==================== + + @Test + void resetClearsEverything() { + service.recordCall("gpt-4o", 1000, 200, 500_000_000L); + service.recordEmbedding("text-embedding-3-small", 100, 10_000_000L); + service.recordToolUse("gpt-4o", "search"); + service.recordError("gpt-4o", "Timeout", 100_000_000L); + + service.reset(); + + assertEquals(0, service.getTotalCalls()); + assertEquals(0, service.getTotalInputTokens()); + assertEquals(0, service.getTotalOutputTokens()); + assertEquals(0, service.getTotalEmbeddingCalls()); + assertEquals("No LLM calls recorded.", service.getSummary()); + } + + // ==================== Edge cases ==================== + + @Test + void summaryEmptyWhenNoCalls() { + assertEquals("No LLM calls recorded.", service.getSummary()); + } + + @Test + void summaryOmitsTokenLineWhenNoTokens() { + service.recordCall("my-model", 500_000_000L); + String summary = service.getSummary(); + // Should show the model and latency but not "0 in / 0 out" + assertTrue(summary.contains("my-model")); + assertFalse(summary.contains("0 in / 0 out")); + } + + @Test + void cacheHitRateCalculation() { + service + .call("claude-sonnet-4-20250514") + .inputTokens(200) + .outputTokens(100) + .cacheReadTokens(800) + .duration(100_000_000L) + .record(); + + String summary = service.getSummary(); + // 800 cache reads out of 200 input = 400% is wrong semantically, + // so check that the cache section exists + assertTrue(summary.contains("Cache:")); + assertTrue(summary.contains("800 read")); + } + + // ==================== Concurrency ==================== + + @Test + void concurrentRecording() throws InterruptedException { + int threads = 8; + int callsPerThread = 1000; + Thread[] workers = new Thread[threads]; + + for (int t = 0; t < threads; t++) { + workers[t] = + new Thread( + () -> { + for (int i = 0; i < callsPerThread; i++) { + service.recordCall("gpt-4o", 100, 50, 10_000_000L); + } + }); + workers[t].start(); + } + for (Thread w : workers) { + w.join(); + } + + assertEquals(threads * callsPerThread, service.getTotalCalls()); + assertEquals(threads * callsPerThread * 100L, service.getTotalInputTokens()); + } + + @Test + void concurrentBuilderRecording() throws InterruptedException { + int threads = 4; + int callsPerThread = 500; + Thread[] workers = new Thread[threads]; + + for (int t = 0; t < threads; t++) { + workers[t] = + new Thread( + () -> { + for (int i = 0; i < callsPerThread; i++) { + service + .call("claude-sonnet-4-20250514") + .provider("anthropic") + .inputTokens(100) + .outputTokens(50) + .duration(10_000_000L) + .record(); + } + }); + workers[t].start(); + } + for (Thread w : workers) { + w.join(); + } + + assertEquals(threads * callsPerThread, service.getTotalCalls()); + } +} diff --git a/btrace-extensions/btrace-metrics/build.gradle b/btrace-extensions/btrace-metrics/build.gradle new file mode 100644 index 000000000..d92f2b7b1 --- /dev/null +++ b/btrace-extensions/btrace-metrics/build.gradle @@ -0,0 +1,46 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-metrics' + name = 'BTrace HDR Histogram' + description = 'High-performance metrics using HdrHistogram for accurate percentile tracking' + services = ['io.btrace.metrics.MetricsService'] + shadedPackages = [ + 'org.HdrHistogram': 'io.btrace.metrics.shaded.hdrhistogram', + 'com.clearspring.analytics': 'io.btrace.metrics.shaded.clearspring' + ] + // Strict lint is enabled by default; API exposes builders instead of public constructors +} + +dependencies { + // API dependencies (no legacy services API) + apiCompileOnly 'org.jetbrains:annotations:26.1.0' + apiCompileOnly project(':btrace-core') + implCompileOnly 'org.jetbrains:annotations:26.1.0' + + // Implementation dependencies (will be shaded) + implImplementation project(':btrace-core') + implImplementation libs.hdrhistogram + implImplementation libs.stream.lib + + testImplementation libs.junit.jupiter + testImplementation libs.hdrhistogram +} + +test { + useJUnitPlatform() +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/Metric.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/Metric.java new file mode 100644 index 000000000..cecb5b2dc --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/Metric.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics; + +import org.jetbrains.annotations.NotNull; + +/** Base interface for all metrics. */ +public interface Metric { + /** + * Get the metric name. + * + * @return metric name + */ + @NotNull String getName(); + + /** Reset the metric to initial state. */ + void reset(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/MetricsService.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/MetricsService.java new file mode 100644 index 000000000..67f9f0b74 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/MetricsService.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics; + +import io.btrace.core.extensions.Permission; +import io.btrace.core.extensions.ServiceDescriptor; +import io.btrace.metrics.histogram.HistogramConfig; +import io.btrace.metrics.histogram.HistogramConfigBuilder; +import io.btrace.metrics.histogram.HistogramMetric; +import io.btrace.metrics.stats.StatsMetric; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** High-performance metrics service API. */ +@ServiceDescriptor(permissions = {Permission.THREADS}) +public interface MetricsService { + @Nullable HistogramConfigBuilder newHistogramConfig(); + + @Nullable HistogramMetric histogram(@NotNull String name); + + @Nullable HistogramMetric histogram(@NotNull String name, @NotNull HistogramConfig config); + + @Nullable HistogramMetric histogram(@NotNull String name, @NotNull String key); + + @Nullable HistogramMetric histogram( + @NotNull String name, @NotNull String key, @NotNull HistogramConfig config); + + // Convenience creators for common units (matches prior constants): + @Nullable HistogramMetric histogramMicros(@NotNull String name); + + @Nullable HistogramMetric histogramMicros(@NotNull String name, @NotNull String key); + + @Nullable HistogramMetric histogramMillis(@NotNull String name); + + @Nullable HistogramMetric histogramMillis(@NotNull String name, @NotNull String key); + + @Nullable StatsMetric stats(@NotNull String name); + + @Nullable StatsMetric stats(@NotNull String name, @NotNull String key); + + void reset(); + + void clear(); + + int size(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/MetricsServiceImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/MetricsServiceImpl.java new file mode 100644 index 000000000..de5c4f3ea --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/MetricsServiceImpl.java @@ -0,0 +1,173 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics; + +import io.btrace.core.extensions.Extension; +import io.btrace.metrics.histogram.HistogramConfig; +import io.btrace.metrics.histogram.HistogramConfigBuilder; +import io.btrace.metrics.histogram.HistogramConfigBuilderImpl; +import io.btrace.metrics.histogram.HistogramConfigImpl; +import io.btrace.metrics.histogram.HistogramMetric; +import io.btrace.metrics.histogram.HistogramMetricImpl; +import io.btrace.metrics.registry.MetricRegistry; +import io.btrace.metrics.stats.StatsMetric; +import io.btrace.metrics.stats.StatsMetricImpl; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * High-performance metrics service built on HdrHistogram. + * + *

Provides: - Histograms with accurate percentile queries (p50, p95, p99, etc.) - Basic + * statistics (count, sum, min, max, avg, stddev) + * + *

Thread-safe and designed for low-latency hot paths. + */ +public final class MetricsServiceImpl extends Extension implements MetricsService { + + private final MetricRegistry registry = new MetricRegistry(); + + public MetricsServiceImpl() {} + + // ========== Histogram Creation ========== + + @Override + public HistogramConfigBuilder newHistogramConfig() { + return new HistogramConfigBuilderImpl(); + } + + /** + * Create histogram with default configuration. + * + * @param name metric name + * @return histogram metric + */ + @Nullable public HistogramMetric histogram(@NotNull String name) { + // Default: 1ns .. 1h, 3 significant digits + return histogram(name, new HistogramConfigImpl(1L, 3_600_000_000_000L, 3)); + } + + /** + * Create histogram with custom configuration. + * + * @param name metric name + * @param config histogram configuration + * @return histogram metric + */ + @Nullable public HistogramMetric histogram(@NotNull String name, @NotNull HistogramConfig config) { + return registry.getOrCreate(name, null, () -> new HistogramMetricImpl(name, config)); + } + + /** + * Create grouped histogram. + * + * @param name metric name + * @param key grouping key + * @return histogram metric + */ + @Nullable public HistogramMetric histogram(@NotNull String name, @NotNull String key) { + return registry.getOrCreate( + name, + key, + () -> + new HistogramMetricImpl( + name, + new io.btrace.metrics.histogram.HistogramConfigImpl(1L, 3_600_000_000_000L, 3))); + } + + // Convenience creators for micros/millis ranges (match prior constants) + @Override + @Nullable public HistogramMetric histogramMicros(@NotNull String name) { + return histogram(name, new HistogramConfigImpl(1L, 60_000_000L, 3)); + } + + @Override + @Nullable public HistogramMetric histogramMicros(@NotNull String name, @NotNull String key) { + return registry.getOrCreate( + name, + key, + () -> new HistogramMetricImpl(name, new HistogramConfigImpl(1L, 60_000_000L, 3))); + } + + @Override + @Nullable public HistogramMetric histogramMillis(@NotNull String name) { + return histogram(name, new HistogramConfigImpl(1L, 600_000L, 3)); + } + + @Override + @Nullable public HistogramMetric histogramMillis(@NotNull String name, @NotNull String key) { + return registry.getOrCreate( + name, key, () -> new HistogramMetricImpl(name, new HistogramConfigImpl(1L, 600_000L, 3))); + } + + /** + * Create grouped histogram with custom configuration. + * + * @param name metric name + * @param key grouping key + * @param config histogram configuration + * @return histogram metric + */ + @Nullable public HistogramMetric histogram( + @NotNull String name, @NotNull String key, @NotNull HistogramConfig config) { + return registry.getOrCreate(name, key, () -> new HistogramMetricImpl(name, config)); + } + + // ========== Statistics Creation ========== + + /** + * Create statistics metric (count/sum/min/max/avg/stddev). + * + * @param name metric name + * @return statistics metric + */ + @Nullable public StatsMetric stats(@NotNull String name) { + return registry.getOrCreate(name, null, () -> new StatsMetricImpl(name)); + } + + /** + * Create grouped statistics metric. + * + * @param name metric name + * @param key grouping key + * @return statistics metric + */ + @Nullable public StatsMetric stats(@NotNull String name, @NotNull String key) { + return registry.getOrCreate(name, key, () -> new io.btrace.metrics.stats.StatsMetricImpl(name)); + } + + // ========== Query Operations ========== + + /** Reset all metrics. */ + public void reset() { + registry.reset(); + } + + /** Clear all metrics. */ + public void clear() { + registry.clear(); + } + + /** + * Get number of registered metrics. + * + * @return metric count + */ + public int size() { + return registry.size(); + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfig.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfig.java new file mode 100644 index 000000000..c4961b502 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfig.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +/** + * Configuration for HdrHistogram. + * + *

Defines the range and precision of histogram measurements. Probes do not instantiate configs + * directly; obtain a builder from the injected service and pass the built config handle back to the + * service. + */ +public interface HistogramConfig { + long getLowestDiscernibleValue(); + + long getHighestTrackableValue(); + + int getNumberOfSignificantValueDigits(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigBuilder.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigBuilder.java new file mode 100644 index 000000000..f24df3c4e --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigBuilder.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +/** Builder for {@link HistogramConfig}. Obtain from the injected service. */ +public interface HistogramConfigBuilder { + HistogramConfigBuilder lowestDiscernibleValue(long value); + + HistogramConfigBuilder highestTrackableValue(long value); + + HistogramConfigBuilder significantDigits(int digits); + + HistogramConfig build(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigBuilderImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigBuilderImpl.java new file mode 100644 index 000000000..5a6e94446 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigBuilderImpl.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +public final class HistogramConfigBuilderImpl implements HistogramConfigBuilder { + private long lowest = 1L; + private long highest = 3_600_000_000_000L; // 1 hour in nanos by default + private int digits = 3; + + @Override + public HistogramConfigBuilder lowestDiscernibleValue(long value) { + this.lowest = value; + return this; + } + + @Override + public HistogramConfigBuilder highestTrackableValue(long value) { + this.highest = value; + return this; + } + + @Override + public HistogramConfigBuilder significantDigits(int digits) { + this.digits = digits; + return this; + } + + @Override + public HistogramConfig build() { + return new HistogramConfigImpl(lowest, highest, digits); + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigImpl.java new file mode 100644 index 000000000..9b202d328 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramConfigImpl.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +public final class HistogramConfigImpl implements HistogramConfig { + private final long lowestDiscernibleValue; + private final long highestTrackableValue; + private final int numberOfSignificantValueDigits; + + public HistogramConfigImpl(long lowest, long highest, int digits) { + this.lowestDiscernibleValue = lowest; + this.highestTrackableValue = highest; + this.numberOfSignificantValueDigits = digits; + } + + @Override + public long getLowestDiscernibleValue() { + return lowestDiscernibleValue; + } + + @Override + public long getHighestTrackableValue() { + return highestTrackableValue; + } + + @Override + public int getNumberOfSignificantValueDigits() { + return numberOfSignificantValueDigits; + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramMetric.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramMetric.java new file mode 100644 index 000000000..6d0c777d0 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramMetric.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +import org.jetbrains.annotations.Nullable; + +public interface HistogramMetric { + void record(long value); + + void recordValueWithCount(long value, long count); + + @Nullable HistogramSnapshot snapshot(); + + void reset(); + + @Nullable String getName(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramMetricImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramMetricImpl.java new file mode 100644 index 000000000..9a3683056 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramMetricImpl.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +import io.btrace.metrics.Metric; +import org.HdrHistogram.Histogram; +import org.HdrHistogram.Recorder; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Histogram metric using HdrHistogram for accurate percentiles. + * + *

Uses Recorder pattern for lock-free writes in hot path. + */ +public final class HistogramMetricImpl implements HistogramMetric, Metric { + + private final String name; + private final Recorder recorder; + private final HistogramConfig config; + + public HistogramMetricImpl(String name, HistogramConfig config) { + this.name = name; + this.config = config; + this.recorder = + new Recorder( + config.getLowestDiscernibleValue(), + config.getHighestTrackableValue(), + config.getNumberOfSignificantValueDigits()); + } + + /** + * Record value - ZERO ALLOCATION in hot path. + * + * @param value value to record + */ + public void record(long value) { + recorder.recordValue(value); + } + + /** + * Record value with count - ZERO ALLOCATION. + * + * @param value value to record + * @param count number of times to record + */ + public void recordValueWithCount(long value, long count) { + recorder.recordValueWithCount(value, count); + } + + /** + * Get snapshot for querying percentiles. + * + *

This allocates a new Histogram via getIntervalHistogram(). Call infrequently (e.g., on + * OnEvent). + * + * @return immutable snapshot + */ + @Nullable public HistogramSnapshot snapshot() { + Histogram histogram = recorder.getIntervalHistogram(); + return new HistogramSnapshotImpl(name, histogram); + } + + @Override + public void reset() { + recorder.reset(); + } + + @Override + @NotNull public String getName() { + return name; + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramSnapshot.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramSnapshot.java new file mode 100644 index 000000000..7ce5ba500 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramSnapshot.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +import org.jetbrains.annotations.Nullable; + +public interface HistogramSnapshot { + @Nullable String getName(); + + long p50(); + + long p75(); + + long p90(); + + long p95(); + + long p99(); + + long p999(); + + long p9999(); + + long percentile(double percentile); + + long count(); + + long min(); + + long max(); + + double mean(); + + double stddev(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramSnapshotImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramSnapshotImpl.java new file mode 100644 index 000000000..a58ffcb4e --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/histogram/HistogramSnapshotImpl.java @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.histogram; + +import org.HdrHistogram.Histogram; +import org.jetbrains.annotations.NotNull; + +/** Immutable snapshot of histogram for percentile queries. */ +public final class HistogramSnapshotImpl implements HistogramSnapshot { + + private final String name; + private final Histogram histogram; + + HistogramSnapshotImpl(String name, Histogram histogram) { + this.name = name; + this.histogram = histogram; + } + + @NotNull public String getName() { + return name; + } + + // ========== Percentiles ========== + + public long p50() { + return histogram.getValueAtPercentile(50.0); + } + + public long p75() { + return histogram.getValueAtPercentile(75.0); + } + + public long p90() { + return histogram.getValueAtPercentile(90.0); + } + + public long p95() { + return histogram.getValueAtPercentile(95.0); + } + + public long p99() { + return histogram.getValueAtPercentile(99.0); + } + + public long p999() { + return histogram.getValueAtPercentile(99.9); + } + + public long p9999() { + return histogram.getValueAtPercentile(99.99); + } + + public long percentile(double percentile) { + return histogram.getValueAtPercentile(percentile); + } + + // ========== Statistics ========== + + public long count() { + return histogram.getTotalCount(); + } + + public long min() { + return histogram.getMinValue(); + } + + public long max() { + return histogram.getMaxValue(); + } + + public double mean() { + return histogram.getMean(); + } + + public double stddev() { + return histogram.getStdDeviation(); + } + + // ========== Access to raw histogram ========== + + public Histogram getHistogram() { + return histogram; + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/package-info.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/package-info.java new file mode 100644 index 000000000..ee01b8f1f --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/package-info.java @@ -0,0 +1,9 @@ +@ExtensionDescriptor( + name = "btrace-metrics", + version = "1.0", + description = "High-performance metrics APIs", + permissions = {Permission.THREADS}) +package io.btrace.metrics; + +import io.btrace.core.extensions.ExtensionDescriptor; +import io.btrace.core.extensions.Permission; diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/registry/MetricRegistry.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/registry/MetricRegistry.java new file mode 100644 index 000000000..8a11e0701 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/registry/MetricRegistry.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.registry; + +import io.btrace.metrics.Metric; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +/** + * Thread-safe registry for storing metrics. + * + *

Supports grouping via String keys. + */ +public final class MetricRegistry { + + private final ConcurrentHashMap metrics = new ConcurrentHashMap<>(); + + /** + * Get or create a metric. + * + * @param name metric name + * @param key grouping key (null for ungrouped) + * @param factory factory to create metric if not present + * @param metric type + * @return metric instance + */ + @SuppressWarnings("unchecked") + public T getOrCreate(String name, String key, Supplier factory) { + String fullName = makeFullName(name, key); + return (T) metrics.computeIfAbsent(fullName, k -> factory.get()); + } + + /** Reset all metrics. */ + public void reset() { + for (Metric metric : metrics.values()) { + metric.reset(); + } + } + + /** + * Get number of registered metrics. + * + * @return metric count + */ + public int size() { + return metrics.size(); + } + + /** Clear all metrics. */ + public void clear() { + metrics.clear(); + } + + private String makeFullName(String name, String key) { + if (key == null || key.isEmpty()) { + return name; + } + return name + ":" + key; + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsMetric.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsMetric.java new file mode 100644 index 000000000..f0dbcfb9b --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsMetric.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.stats; + +import org.jetbrains.annotations.Nullable; + +public interface StatsMetric { + void record(long value); + + @Nullable StatsSnapshot snapshot(); + + void reset(); + + @Nullable String getName(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsMetricImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsMetricImpl.java new file mode 100644 index 000000000..e9a6ecec6 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsMetricImpl.java @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.stats; + +import io.btrace.metrics.Metric; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.LongAdder; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * Statistics metric using lock-free atomics. + * + *

Provides: count, sum, min, max, average, stddev + * + *

Uses LongAdder for count/sum (better than AtomicLong under contention). Uses AtomicLong for + * min/max with CAS loop. + */ +public final class StatsMetricImpl implements StatsMetric, Metric { + + private final String name; + private final LongAdder count = new LongAdder(); + private final LongAdder sum = new LongAdder(); + private final LongAdder sumOfSquares = new LongAdder(); + private final AtomicLong min = new AtomicLong(Long.MAX_VALUE); + private final AtomicLong max = new AtomicLong(Long.MIN_VALUE); + + public StatsMetricImpl(String name) { + this.name = name; + } + + /** + * Record value - lock-free. + * + * @param value value to record + */ + public void record(long value) { + count.increment(); + sum.add(value); + sumOfSquares.add(value * value); + + // Update min (CAS loop) + long currentMin; + do { + currentMin = min.get(); + if (value >= currentMin) { + break; + } + } while (!min.compareAndSet(currentMin, value)); + + // Update max (CAS loop) + long currentMax; + do { + currentMax = max.get(); + if (value <= currentMax) { + break; + } + } while (!max.compareAndSet(currentMax, value)); + } + + /** + * Get immutable snapshot. + * + * @return snapshot + */ + @Nullable public StatsSnapshot snapshot() { + long cnt = count.sum(); + long sm = sum.sum(); + long sumSq = sumOfSquares.sum(); + long mn = min.get(); + long mx = max.get(); + + if (cnt == 0) { + return new StatsSnapshotImpl(name, 0, 0, 0, 0, 0, 0); + } + + double avg = (double) sm / cnt; + + // Variance = E[X^2] - E[X]^2 + double variance = ((double) sumSq / cnt) - (avg * avg); + double stddev = Math.sqrt(Math.max(0, variance)); + + return new StatsSnapshotImpl(name, cnt, sm, mn, mx, avg, stddev); + } + + @Override + public void reset() { + count.reset(); + sum.reset(); + sumOfSquares.reset(); + min.set(Long.MAX_VALUE); + max.set(Long.MIN_VALUE); + } + + @Override + @NotNull public String getName() { + return name; + } +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsSnapshot.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsSnapshot.java new file mode 100644 index 000000000..774a16e79 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsSnapshot.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.stats; + +import org.jetbrains.annotations.Nullable; + +public interface StatsSnapshot { + @Nullable String getName(); + + long count(); + + long sum(); + + long min(); + + long max(); + + double mean(); + + double stddev(); +} diff --git a/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsSnapshotImpl.java b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsSnapshotImpl.java new file mode 100644 index 000000000..733c855cc --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/main/java/io/btrace/metrics/stats/StatsSnapshotImpl.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics.stats; + +import org.jetbrains.annotations.NotNull; + +/** Immutable snapshot of statistics. */ +public final class StatsSnapshotImpl implements StatsSnapshot { + + private final String name; + private final long count; + private final long sum; + private final long min; + private final long max; + private final double mean; + private final double stddev; + + public StatsSnapshotImpl( + String name, long count, long sum, long min, long max, double mean, double stddev) { + this.name = name; + this.count = count; + this.sum = sum; + this.min = min; + this.max = max; + this.mean = mean; + this.stddev = stddev; + } + + @NotNull public String getName() { + return name; + } + + public long count() { + return count; + } + + public long sum() { + return sum; + } + + public long min() { + return min; + } + + public long max() { + return max; + } + + public double mean() { + return mean; + } + + public double stddev() { + return stddev; + } +} diff --git a/btrace-extensions/btrace-metrics/src/test/java/io/btrace/metrics/HistogramMetricTest.java b/btrace-extensions/btrace-metrics/src/test/java/io/btrace/metrics/HistogramMetricTest.java new file mode 100644 index 000000000..3100f0cb6 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/test/java/io/btrace/metrics/HistogramMetricTest.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import io.btrace.metrics.histogram.HistogramConfigImpl; +import io.btrace.metrics.histogram.HistogramMetric; +import io.btrace.metrics.histogram.HistogramMetricImpl; +import io.btrace.metrics.histogram.HistogramSnapshot; +import org.junit.jupiter.api.Test; + +class HistogramMetricTest { + @Test + void recordsAndSnapshots() { + HistogramMetric m = new HistogramMetricImpl("h", new HistogramConfigImpl(1L, 600_000L, 3)); + m.record(10); + m.record(20); + HistogramSnapshot snap = m.snapshot(); + assertEquals("h", snap.getName()); + assertTrue(snap.count() >= 2); + assertTrue(snap.max() >= 20); + } +} diff --git a/btrace-extensions/btrace-metrics/src/test/java/io/btrace/metrics/StatsMetricTest.java b/btrace-extensions/btrace-metrics/src/test/java/io/btrace/metrics/StatsMetricTest.java new file mode 100644 index 000000000..0aede7382 --- /dev/null +++ b/btrace-extensions/btrace-metrics/src/test/java/io/btrace/metrics/StatsMetricTest.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.metrics; + +import static org.junit.jupiter.api.Assertions.*; + +import io.btrace.metrics.stats.StatsMetric; +import io.btrace.metrics.stats.StatsSnapshot; +import org.junit.jupiter.api.Test; + +class StatsMetricTest { + @Test + void accumulatesAndSnapshots() { + StatsMetric m = new io.btrace.metrics.stats.StatsMetricImpl("s"); + m.record(1); + m.record(3); + StatsSnapshot snap = m.snapshot(); + assertEquals("s", snap.getName()); + assertEquals(2, snap.count()); + assertEquals(4, snap.sum()); + assertEquals(1, snap.min()); + assertEquals(3, snap.max()); + } +} diff --git a/btrace-extensions/btrace-rag-quality/build.gradle b/btrace-extensions/btrace-rag-quality/build.gradle new file mode 100644 index 000000000..5f632dad2 --- /dev/null +++ b/btrace-extensions/btrace-rag-quality/build.gradle @@ -0,0 +1,35 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-rag-quality' + name = 'BTrace RAG Quality' + description = 'RAG pipeline observability: retrieval latency, similarity scores, chunk quality for vector DB clients' + services = ['io.btrace.rag.RagQualityService'] +} + +dependencies { + apiCompileOnly 'org.jetbrains:annotations:26.1.0' + apiCompileOnly project(':btrace-core') + implCompileOnly 'org.jetbrains:annotations:26.1.0' + implImplementation project(':btrace-core') + + testImplementation libs.junit.jupiter +} + +test { + useJUnitPlatform() +} diff --git a/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/QueryRecord.java b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/QueryRecord.java new file mode 100644 index 000000000..045eec86e --- /dev/null +++ b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/QueryRecord.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.rag; + +/** + * Fluent builder for recording a vector DB query with detailed metrics. + * + *

Obtain via {@link RagQualityService#query(String)}. All setters are optional. Call {@link + * #record()} to commit the metrics. + * + *

Allocation-free: Instances are pooled per-thread internally. The returned + * reference must not be stored or shared across threads. + * + *

+ * rag.query("pinecone")
+ *     .resultCount(5)
+ *     .topScore(0.92f)
+ *     .lowScore(0.71f)
+ *     .embeddingDimension(1536)
+ *     .duration(durationNanos)
+ *     .record();
+ *

+ */ +public interface QueryRecord { + + /** Number of results/chunks returned by the query. */ + QueryRecord resultCount(int count); + + /** Highest similarity score in the result set (0.0 to 1.0). */ + QueryRecord topScore(float score); + + /** Lowest similarity score in the result set (0.0 to 1.0). */ + QueryRecord lowScore(float score); + + /** Embedding dimension used for the query vector. */ + QueryRecord embeddingDimension(int dimension); + + /** Total tokens across all returned chunks. */ + QueryRecord totalChunkTokens(int tokens); + + /** Query duration in nanoseconds. */ + QueryRecord duration(long nanos); + + /** Commits this query record to the service. */ + void record(); +} diff --git a/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/QueryRecordImpl.java b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/QueryRecordImpl.java new file mode 100644 index 000000000..4f86752f9 --- /dev/null +++ b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/QueryRecordImpl.java @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.rag; + +/** + * ThreadLocal-pooled builder implementing the {@link QueryRecord} fluent API. One instance per + * thread, reused across calls — zero heap allocation. + */ +final class QueryRecordImpl implements QueryRecord { + + String source; + int resultCountVal; + float topScoreVal; + float lowScoreVal; + int embDimension; + int chunkTokensVal; + long durationVal; + + private RagQualityServiceImpl service; + + QueryRecordImpl() {} + + QueryRecordImpl reset(RagQualityServiceImpl service, String source) { + this.service = service; + this.source = source; + this.resultCountVal = 0; + this.topScoreVal = -1f; + this.lowScoreVal = -1f; + this.embDimension = 0; + this.chunkTokensVal = 0; + this.durationVal = 0; + return this; + } + + @Override + public QueryRecord resultCount(int count) { + this.resultCountVal = count; + return this; + } + + @Override + public QueryRecord topScore(float score) { + this.topScoreVal = score; + return this; + } + + @Override + public QueryRecord lowScore(float score) { + this.lowScoreVal = score; + return this; + } + + @Override + public QueryRecord embeddingDimension(int dimension) { + this.embDimension = dimension; + return this; + } + + @Override + public QueryRecord totalChunkTokens(int tokens) { + this.chunkTokensVal = tokens; + return this; + } + + @Override + public QueryRecord duration(long nanos) { + this.durationVal = nanos; + return this; + } + + @Override + public void record() { + service.commitQueryRecord(this); + } +} diff --git a/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/RagQualityService.java b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/RagQualityService.java new file mode 100644 index 000000000..a056fb65a --- /dev/null +++ b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/RagQualityService.java @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.rag; + +import io.btrace.core.extensions.ServiceDescriptor; +import org.jetbrains.annotations.Nullable; + +/** + * BTrace extension service for RAG (Retrieval-Augmented Generation) pipeline observability. + * + *

Tracks vector database query performance, retrieval quality metrics, and end-to-end RAG + * pipeline latency. Works with any vector DB client (Pinecone, Milvus, Weaviate, Chroma, pgvector, + * Qdrant). + * + *

Usage in a BTrace script: + * + *

+ * @Injected RagQualityService rag;
+ *
+ * @OnMethod(clazz = "io.pinecone.PineconeClient", method = "query")
+ * void onQuery(@Duration long dur) {
+ *     rag.recordQuery("pinecone", 10, dur);
+ * }
+ *

+ */ +@ServiceDescriptor +public interface RagQualityService { + + // ==================== Query recording ==================== + + /** + * Records a vector DB query with duration only. + * + * @param source vector DB or index name (e.g. "pinecone", "milvus-products") + * @param durationNanos query duration in nanoseconds + */ + void recordQuery(String source, long durationNanos); + + /** + * Records a vector DB query with result count and duration. + * + * @param source vector DB or index name + * @param resultCount number of results/chunks returned (top-K) + * @param durationNanos query duration in nanoseconds + */ + void recordQuery(String source, int resultCount, long durationNanos); + + /** + * Starts a detailed query record builder. Allocation-free (ThreadLocal-pooled). + * + *

Use inline on the calling thread and call {@link QueryRecord#record()} before the next + * {@code query()} call. Do not store the returned reference. + * + *

+   * rag.query("pinecone")
+   *     .resultCount(5)
+   *     .topScore(0.92f)
+   *     .lowScore(0.71f)
+   *     .embeddingDimension(1536)
+   *     .duration(durationNanos)
+   *     .record();
+   *

+ * + * @param source vector DB or index name + * @return a query record builder (thread-local, do not store) + */ + @Nullable QueryRecord query(String source); + + // ==================== Pipeline recording ==================== + + /** + * Records an end-to-end RAG pipeline invocation (retrieve + generate). + * + * @param pipelineName pipeline identifier + * @param retrievalNanos time spent in retrieval phase + * @param generationNanos time spent in generation phase + */ + void recordPipeline(String pipelineName, long retrievalNanos, long generationNanos); + + /** + * Records a chunk that was retrieved and used in context. Useful for tracking context window + * utilization. + * + * @param source vector DB or index name + * @param chunkTokens approximate token count of the chunk + */ + void recordChunk(String source, int chunkTokens); + + /** + * Records a retrieval that returned no results (empty context). + * + * @param source vector DB or index name + */ + void recordEmptyRetrieval(String source); + + // ==================== Reporting ==================== + + /** Returns a formatted summary of all RAG quality metrics. */ + @Nullable String getSummary(); + + /** Returns summary for a specific source/index. */ + @Nullable String getSourceSummary(String source); + + /** Returns total number of queries recorded across all sources. */ + long getTotalQueries(); + + /** Returns total number of empty retrievals. */ + long getTotalEmptyRetrievals(); + + /** Returns average similarity score across all queries that reported scores. */ + float getAverageTopScore(); + + /** Resets all collected metrics. */ + void reset(); +} diff --git a/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/RagQualityServiceImpl.java b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/RagQualityServiceImpl.java new file mode 100644 index 000000000..1f2970185 --- /dev/null +++ b/btrace-extensions/btrace-rag-quality/src/main/java/io/btrace/rag/RagQualityServiceImpl.java @@ -0,0 +1,349 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.rag; + +import io.btrace.core.extensions.Extension; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; + +/** Thread-safe RAG quality tracking with lock-free per-source statistics. */ +public final class RagQualityServiceImpl extends Extension implements RagQualityService { + + private final Map sourceStats = new ConcurrentHashMap<>(); + private final Map pipelineStats = new ConcurrentHashMap<>(); + + private final ThreadLocal queryRecordPool = + ThreadLocal.withInitial(QueryRecordImpl::new); + + // ==================== Simple recording ==================== + + @Override + public void recordQuery(String source, long durationNanos) { + SourceStats stats = getOrCreate(source); + stats.queries.incrementAndGet(); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + } + + @Override + public void recordQuery(String source, int resultCount, long durationNanos) { + SourceStats stats = getOrCreate(source); + stats.queries.incrementAndGet(); + stats.totalResults.addAndGet(resultCount); + stats.totalDurationNanos.addAndGet(durationNanos); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, durationNanos); + if (resultCount == 0) { + stats.emptyRetrievals.incrementAndGet(); + } + } + + // ==================== Fluent builder ==================== + + @Override + public QueryRecord query(String source) { + return queryRecordPool.get().reset(this, source); + } + + void commitQueryRecord(QueryRecordImpl rec) { + SourceStats stats = getOrCreate(rec.source); + stats.queries.incrementAndGet(); + stats.totalResults.addAndGet(rec.resultCountVal); + stats.totalDurationNanos.addAndGet(rec.durationVal); + updateMinMax(stats.minDurationNanos, stats.maxDurationNanos, rec.durationVal); + + if (rec.resultCountVal == 0) { + stats.emptyRetrievals.incrementAndGet(); + } + + if (rec.topScoreVal >= 0) { + stats.scoredQueries.incrementAndGet(); + // Accumulate scores as fixed-point (multiply by 10000) to avoid floating point atomics + stats.totalTopScore.addAndGet((long) (rec.topScoreVal * 10000)); + updateMin(stats.minTopScore, (long) (rec.topScoreVal * 10000)); + updateMax(stats.maxTopScore, (long) (rec.topScoreVal * 10000)); + } + if (rec.lowScoreVal >= 0) { + stats.totalLowScore.addAndGet((long) (rec.lowScoreVal * 10000)); + } + if (rec.chunkTokensVal > 0) { + stats.totalChunkTokens.addAndGet(rec.chunkTokensVal); + } + if (rec.embDimension > 0) { + stats.lastEmbeddingDimension = rec.embDimension; + } + } + + // ==================== Pipeline recording ==================== + + @Override + public void recordPipeline(String pipelineName, long retrievalNanos, long generationNanos) { + PipelineStats ps = pipelineStats.computeIfAbsent(pipelineName, k -> new PipelineStats()); + ps.invocations.incrementAndGet(); + ps.totalRetrievalNanos.addAndGet(retrievalNanos); + ps.totalGenerationNanos.addAndGet(generationNanos); + } + + @Override + public void recordChunk(String source, int chunkTokens) { + SourceStats stats = getOrCreate(source); + stats.totalChunkTokens.addAndGet(chunkTokens); + stats.chunkCount.incrementAndGet(); + } + + @Override + public void recordEmptyRetrieval(String source) { + getOrCreate(source).emptyRetrievals.incrementAndGet(); + } + + // ==================== Reporting ==================== + + @Override + public String getSummary() { + if (sourceStats.isEmpty() && pipelineStats.isEmpty()) { + return "No RAG queries recorded."; + } + + StringBuilder sb = new StringBuilder(); + sb.append("=== RAG Quality Summary ===\n\n"); + + long totalQueries = 0; + long totalEmpty = 0; + + for (Map.Entry entry : sourceStats.entrySet()) { + String source = entry.getKey(); + SourceStats s = entry.getValue(); + long queries = s.queries.get(); + totalQueries += queries; + long empty = s.emptyRetrievals.get(); + totalEmpty += empty; + + sb.append("Source: ").append(source).append("\n"); + sb.append(" Queries: ").append(queries); + if (empty > 0) { + sb.append(" (").append(empty).append(" empty, ").append(empty * 100 / queries).append("%)"); + } + sb.append("\n"); + + // Results + long totalRes = s.totalResults.get(); + if (totalRes > 0 && queries > 0) { + sb.append(" Results: ") + .append(totalRes) + .append(" total (avg ") + .append(totalRes / queries) + .append("/query)\n"); + } + + // Similarity scores + long scored = s.scoredQueries.get(); + if (scored > 0) { + float avgTop = (s.totalTopScore.get() / (float) scored) / 10000f; + float minTop = s.minTopScore.get() / 10000f; + float maxTop = s.maxTopScore.get() / 10000f; + sb.append(" Similarity (top): avg ").append(String.format("%.3f", avgTop)); + sb.append(", min ").append(String.format("%.3f", minTop)); + sb.append(", max ").append(String.format("%.3f", maxTop)); + sb.append("\n"); + + long totalLow = s.totalLowScore.get(); + if (totalLow > 0) { + float avgLow = (totalLow / (float) scored) / 10000f; + float spread = avgTop - avgLow; + sb.append(" Similarity (low): avg ").append(String.format("%.3f", avgLow)); + sb.append(" (spread ").append(String.format("%.3f", spread)).append(")\n"); + } + } + + // Latency + if (queries > 0) { + long avgMs = (s.totalDurationNanos.get() / queries) / 1_000_000; + long minMs = s.minDurationNanos.get() / 1_000_000; + long maxMs = s.maxDurationNanos.get() / 1_000_000; + sb.append(" Latency: avg ").append(avgMs).append("ms"); + sb.append(", min ").append(minMs).append("ms"); + sb.append(", max ").append(maxMs).append("ms\n"); + } + + // Chunks + long chunks = s.chunkCount.get(); + long chunkTokens = s.totalChunkTokens.get(); + if (chunkTokens > 0) { + sb.append(" Context: ").append(chunkTokens).append(" tokens"); + if (chunks > 0) { + sb.append(" (") + .append(chunks) + .append(" chunks, avg ") + .append(chunkTokens / chunks) + .append(" tok/chunk)"); + } + sb.append("\n"); + } + + sb.append("\n"); + } + + // Pipelines + if (!pipelineStats.isEmpty()) { + sb.append("--- Pipelines ---\n"); + for (Map.Entry entry : pipelineStats.entrySet()) { + PipelineStats ps = entry.getValue(); + long inv = ps.invocations.get(); + long avgRetMs = inv > 0 ? (ps.totalRetrievalNanos.get() / inv) / 1_000_000 : 0; + long avgGenMs = inv > 0 ? (ps.totalGenerationNanos.get() / inv) / 1_000_000 : 0; + sb.append(" ") + .append(entry.getKey()) + .append(": ") + .append(inv) + .append(" invocations, avg retrieval ") + .append(avgRetMs) + .append("ms, avg generation ") + .append(avgGenMs) + .append("ms\n"); + } + sb.append("\n"); + } + + sb.append("--- Totals ---\n"); + sb.append(" Queries: ").append(totalQueries).append("\n"); + if (totalEmpty > 0) { + sb.append(" Empty retrievals: ").append(totalEmpty); + if (totalQueries > 0) { + sb.append(" (").append(totalEmpty * 100 / totalQueries).append("%)"); + } + sb.append("\n"); + } + + return sb.toString(); + } + + @Override + public String getSourceSummary(String source) { + SourceStats s = sourceStats.get(source); + if (s == null) { + return "No data for source: " + source; + } + long queries = s.queries.get(); + long avgMs = queries > 0 ? (s.totalDurationNanos.get() / queries) / 1_000_000 : 0; + long empty = s.emptyRetrievals.get(); + StringBuilder sb = new StringBuilder(); + sb.append(source) + .append(": ") + .append(queries) + .append(" queries, avg ") + .append(avgMs) + .append("ms"); + if (empty > 0) { + sb.append(", ").append(empty).append(" empty"); + } + return sb.toString(); + } + + @Override + public long getTotalQueries() { + long total = 0; + for (SourceStats s : sourceStats.values()) { + total += s.queries.get(); + } + return total; + } + + @Override + public long getTotalEmptyRetrievals() { + long total = 0; + for (SourceStats s : sourceStats.values()) { + total += s.emptyRetrievals.get(); + } + return total; + } + + @Override + public float getAverageTopScore() { + long totalScored = 0; + long totalScore = 0; + for (SourceStats s : sourceStats.values()) { + totalScored += s.scoredQueries.get(); + totalScore += s.totalTopScore.get(); + } + if (totalScored == 0) return -1f; + return (totalScore / (float) totalScored) / 10000f; + } + + @Override + public void reset() { + sourceStats.clear(); + pipelineStats.clear(); + } + + @Override + public void close() { + String summary = getSummary(); + if (!"No RAG queries recorded.".equals(summary)) { + getContext().send(summary); + } + } + + // ==================== Internals ==================== + + private SourceStats getOrCreate(String source) { + return sourceStats.computeIfAbsent(source, k -> new SourceStats()); + } + + private static void updateMinMax(AtomicLong min, AtomicLong max, long value) { + updateMin(min, value); + updateMax(max, value); + } + + private static void updateMin(AtomicLong min, long value) { + long cur; + do { + cur = min.get(); + if (value >= cur) break; + } while (!min.compareAndSet(cur, value)); + } + + private static void updateMax(AtomicLong max, long value) { + long cur; + do { + cur = max.get(); + if (value <= cur) break; + } while (!max.compareAndSet(cur, value)); + } + + static final class SourceStats { + final AtomicLong queries = new AtomicLong(); + final AtomicLong totalResults = new AtomicLong(); + final AtomicLong emptyRetrievals = new AtomicLong(); + final AtomicLong scoredQueries = new AtomicLong(); + final AtomicLong totalTopScore = new AtomicLong(); // fixed-point * 10000 + final AtomicLong minTopScore = new AtomicLong(Long.MAX_VALUE); + final AtomicLong maxTopScore = new AtomicLong(0); + final AtomicLong totalLowScore = new AtomicLong(); // fixed-point * 10000 + final AtomicLong totalDurationNanos = new AtomicLong(); + final AtomicLong minDurationNanos = new AtomicLong(Long.MAX_VALUE); + final AtomicLong maxDurationNanos = new AtomicLong(0); + final AtomicLong totalChunkTokens = new AtomicLong(); + final AtomicLong chunkCount = new AtomicLong(); + volatile int lastEmbeddingDimension; + } + + static final class PipelineStats { + final AtomicLong invocations = new AtomicLong(); + final AtomicLong totalRetrievalNanos = new AtomicLong(); + final AtomicLong totalGenerationNanos = new AtomicLong(); + } +} diff --git a/btrace-extensions/btrace-rag-quality/src/test/java/io/btrace/rag/RagQualityServiceTest.java b/btrace-extensions/btrace-rag-quality/src/test/java/io/btrace/rag/RagQualityServiceTest.java new file mode 100644 index 000000000..6a28bd60a --- /dev/null +++ b/btrace-extensions/btrace-rag-quality/src/test/java/io/btrace/rag/RagQualityServiceTest.java @@ -0,0 +1,226 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.rag; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.concurrent.CountDownLatch; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class RagQualityServiceTest { + + private RagQualityServiceImpl service; + + @BeforeEach + void setUp() { + service = new RagQualityServiceImpl(); + } + + @Test + void durationOnlyQuery() { + service.recordQuery("pinecone", 5_000_000L); + assertEquals(1, service.getTotalQueries()); + String summary = service.getSummary(); + assertTrue(summary.contains("pinecone")); + assertTrue(summary.contains("1")); + } + + @Test + void queryWithResultCount() { + service.recordQuery("milvus", 10, 8_000_000L); + assertEquals(1, service.getTotalQueries()); + assertEquals(0, service.getTotalEmptyRetrievals()); + assertTrue(service.getSummary().contains("10 total")); + } + + @Test + void emptyRetrieval() { + service.recordQuery("weaviate", 0, 2_000_000L); + assertEquals(1, service.getTotalEmptyRetrievals()); + assertTrue(service.getSummary().contains("1 empty")); + } + + @Test + void explicitEmptyRetrieval() { + service.recordEmptyRetrieval("chroma"); + assertEquals(1, service.getTotalEmptyRetrievals()); + } + + @Test + void fluentBuilder() { + service + .query("pinecone") + .resultCount(5) + .topScore(0.92f) + .lowScore(0.71f) + .embeddingDimension(1536) + .totalChunkTokens(3000) + .duration(10_000_000L) + .record(); + + assertEquals(1, service.getTotalQueries()); + float avgScore = service.getAverageTopScore(); + assertTrue(avgScore > 0.91f && avgScore < 0.93f, "avgScore=" + avgScore); + String summary = service.getSummary(); + assertTrue(summary.contains("0.920")); + assertTrue(summary.contains("3000 tokens")); + } + + @Test + void fluentBuilderMinimal() { + service.query("qdrant").duration(1_000_000L).record(); + + assertEquals(1, service.getTotalQueries()); + assertEquals(-1f, service.getAverageTopScore()); + } + + @Test + void fluentBuilderEmptyResult() { + service.query("pgvector").resultCount(0).duration(500_000L).record(); + + assertEquals(1, service.getTotalEmptyRetrievals()); + } + + @Test + void multipleSourcesTrackedSeparately() { + service.recordQuery("pinecone", 5, 10_000_000L); + service.recordQuery("milvus", 3, 8_000_000L); + service.recordQuery("pinecone", 7, 12_000_000L); + + assertEquals(3, service.getTotalQueries()); + assertTrue(service.getSourceSummary("pinecone").contains("2 queries")); + assertTrue(service.getSourceSummary("milvus").contains("1 queries")); + } + + @Test + void pipelineRecording() { + service.recordPipeline("qa-bot", 5_000_000L, 50_000_000L); + service.recordPipeline("qa-bot", 3_000_000L, 45_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("qa-bot")); + assertTrue(summary.contains("2 invocations")); + } + + @Test + void chunkRecording() { + service.recordChunk("pinecone", 500); + service.recordChunk("pinecone", 750); + + String summary = service.getSourceSummary("pinecone"); + // Chunks don't count as queries + assertTrue(summary.contains("0 queries")); + } + + @Test + void similarityScoreAggregation() { + service.query("pinecone").topScore(0.90f).duration(1_000_000L).record(); + service.query("pinecone").topScore(0.80f).duration(1_000_000L).record(); + service.query("milvus").topScore(0.70f).duration(1_000_000L).record(); + + float avg = service.getAverageTopScore(); + // (0.90 + 0.80 + 0.70) / 3 = 0.8 + assertTrue(avg > 0.79f && avg < 0.81f, "avg=" + avg); + } + + @Test + void latencyMinMax() { + service.recordQuery("pinecone", 10_000_000L); + service.recordQuery("pinecone", 2_000_000L); + service.recordQuery("pinecone", 50_000_000L); + + String summary = service.getSummary(); + assertTrue(summary.contains("min 2ms")); + assertTrue(summary.contains("max 50ms")); + } + + @Test + void noDataSummary() { + assertEquals("No RAG queries recorded.", service.getSummary()); + } + + @Test + void unknownSourceSummary() { + assertEquals("No data for source: unknown", service.getSourceSummary("unknown")); + } + + @Test + void reset() { + service.recordQuery("pinecone", 5_000_000L); + service.recordEmptyRetrieval("milvus"); + service.recordPipeline("qa", 1L, 1L); + service.reset(); + + assertEquals(0, service.getTotalQueries()); + assertEquals(0, service.getTotalEmptyRetrievals()); + assertEquals("No RAG queries recorded.", service.getSummary()); + } + + @Test + void concurrentRecording() throws Exception { + int threads = 8; + int queriesPerThread = 1000; + CountDownLatch latch = new CountDownLatch(threads); + + for (int t = 0; t < threads; t++) { + new Thread( + () -> { + try { + for (int i = 0; i < queriesPerThread; i++) { + service.recordQuery("pinecone", 5, 1_000_000L); + } + } finally { + latch.countDown(); + } + }) + .start(); + } + latch.await(); + + assertEquals(threads * queriesPerThread, service.getTotalQueries()); + } + + @Test + void concurrentBuilderRecording() throws Exception { + int threads = 8; + int queriesPerThread = 500; + CountDownLatch latch = new CountDownLatch(threads); + + for (int t = 0; t < threads; t++) { + new Thread( + () -> { + try { + for (int i = 0; i < queriesPerThread; i++) { + service + .query("milvus") + .resultCount(3) + .topScore(0.85f) + .duration(2_000_000L) + .record(); + } + } finally { + latch.countDown(); + } + }) + .start(); + } + latch.await(); + + assertEquals(threads * queriesPerThread, service.getTotalQueries()); + } +} diff --git a/btrace-extensions/btrace-statsd/build.gradle b/btrace-extensions/btrace-statsd/build.gradle new file mode 100644 index 000000000..44766c256 --- /dev/null +++ b/btrace-extensions/btrace-statsd/build.gradle @@ -0,0 +1,28 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-statsd' + name = 'BTrace StatsD' + description = 'StatsD metrics client for BTrace' + services = ['io.btrace.statsd.Statsd'] +} + +dependencies { + apiCompileOnly project(':btrace-core') + implImplementation project(':btrace-core') + implementation libs.slf4j +} diff --git a/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/Statsd.java b/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/Statsd.java new file mode 100644 index 000000000..3cc6b060d --- /dev/null +++ b/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/Statsd.java @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.statsd; + +import io.btrace.core.extensions.Permission; +import io.btrace.core.extensions.ServiceDescriptor; + +/** API for StatsD metrics client. */ +@ServiceDescriptor(permissions = {Permission.NETWORK}) +public interface Statsd { + void increment(String name); + + void increment(String name, String tags); +} diff --git a/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/StatsdImpl.java b/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/StatsdImpl.java new file mode 100644 index 000000000..ac6cf1281 --- /dev/null +++ b/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/StatsdImpl.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.statsd; + +import io.btrace.core.SharedSettings; +import io.btrace.core.extensions.Extension; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetAddress; +import java.nio.charset.StandardCharsets; + +public final class StatsdImpl extends Extension implements Statsd { + @Override + public void increment(String name) { + increment(name, null); + } + + @Override + public void increment(String name, String tags) { + try { + StringBuilder sb = new StringBuilder(); + sb.append(name).append(":1|c"); + if (tags != null && !tags.isEmpty()) { + sb.append("|#").append(tags); + } + byte[] data = sb.toString().getBytes(StandardCharsets.US_ASCII); + DatagramPacket pkt = new DatagramPacket(data, data.length); + pkt.setAddress(InetAddress.getByName(SharedSettings.GLOBAL.getStatsdHost())); + pkt.setPort(SharedSettings.GLOBAL.getStatsdPort()); + try (DatagramSocket socket = new DatagramSocket()) { + socket.send(pkt); + } + } catch (Throwable ignore) { + // Best-effort, ignore errors in script path + } + } +} diff --git a/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/package-info.java b/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/package-info.java new file mode 100644 index 000000000..d2860af9d --- /dev/null +++ b/btrace-extensions/btrace-statsd/src/main/java/io/btrace/statsd/package-info.java @@ -0,0 +1,9 @@ +@ExtensionDescriptor( + name = "btrace-statsd", + version = "1.0", + description = "StatsD metrics APIs", + permissions = {Permission.NETWORK}) +package io.btrace.statsd; + +import io.btrace.core.extensions.ExtensionDescriptor; +import io.btrace.core.extensions.Permission; diff --git a/btrace-extensions/btrace-utils/build.gradle b/btrace-extensions/btrace-utils/build.gradle new file mode 100644 index 000000000..72b589175 --- /dev/null +++ b/btrace-extensions/btrace-utils/build.gradle @@ -0,0 +1,28 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-utils' + name = 'BTrace Utilities' + description = 'Utility services for BTrace scripts (eg. printer)' + services = ['io.btrace.utils.PrinterService'] +} + +dependencies { + // API dependencies (minimal) - no legacy services API + apiCompileOnly project(':btrace-core') + implImplementation project(':btrace-core') +} diff --git a/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/PrinterService.java b/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/PrinterService.java new file mode 100644 index 000000000..6e7178da3 --- /dev/null +++ b/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/PrinterService.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.utils; + +import io.btrace.core.extensions.ServiceDescriptor; + +/** Simple printer service API for BTrace scripts. */ +@ServiceDescriptor +public interface PrinterService { + void print(String s); + + void println(String s); + + void println(); +} diff --git a/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/PrinterServiceImpl.java b/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/PrinterServiceImpl.java new file mode 100644 index 000000000..36c15451a --- /dev/null +++ b/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/PrinterServiceImpl.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 io.btrace.utils; + +import io.btrace.core.extensions.Extension; + +public final class PrinterServiceImpl extends Extension implements PrinterService { + private static final String NL = System.getProperty("line.separator"); + + @Override + public void print(String s) { + if (s != null) { + getContext().send(s); + } + } + + @Override + public void println(String s) { + print(s + NL); + } + + @Override + public void println() { + print(NL); + } + + @Override + public void close() { + if (getContext().getArgs().containsKey("extensionCloseTest")) { + getContext().send("extension close: btrace-utils"); + } + } +} diff --git a/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/package-info.java b/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/package-info.java new file mode 100644 index 000000000..a74c880e6 --- /dev/null +++ b/btrace-extensions/btrace-utils/src/main/java/io/btrace/utils/package-info.java @@ -0,0 +1,7 @@ +@ExtensionDescriptor( + name = "btrace-utils", + version = "1.0", + description = "Utility helper APIs for BTrace scripts") +package io.btrace.utils; + +import io.btrace.core.extensions.ExtensionDescriptor; diff --git a/btrace-extensions/examples/btrace-hadoop/README.md b/btrace-extensions/examples/btrace-hadoop/README.md new file mode 100644 index 000000000..91540283a --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/README.md @@ -0,0 +1,69 @@ +# BTrace Hadoop Example (Provided-Style Extension) + +This example demonstrates a provided-style BTrace extension for Apache Hadoop that: +- Exposes a minimal API on bootstrap (`org.example.btrace.hadoop.api.HadoopApi`). +- Loads implementation in an isolated classloader (no system/boot CL injection). +- Resolves Hadoop classes at runtime using object hand-off and the application’s defining class loader. +- Caches reflective MethodHandles for performance. + +## Build + +``` +./gradlew :btrace-extensions:examples:btrace-hadoop:build +``` + +The BTrace extension plugin will produce API/impl artifacts. Use with a BTrace distribution that supports extensions. + +## Configuration (`extensions.conf`) + +``` +# Enable the example +btrace-hadoop-example.enabled=true + +# Optional: if your application does not ship Hadoop libs +# btrace-hadoop-example.classpath=/opt/hadoop/share/hadoop/common +``` + +## Permissions + +This example uses reflection. Ensure your policy grants the permission: + +``` +# permissions.properties (see PermissionPolicy docs) +grant=REFLECTION,SYSTEM_PROPS +``` + +Avoid `CLASSLOADER` unless you explicitly create child loaders from configured paths. + +## Usage Notes + +- Provided-style: no bootstrap/system classpath mutation; probe code imports only the API. +- Object hand-off: pass Hadoop objects (`Object`) to API methods; the impl resolves types at runtime. +- Class loading: the impl runs resolution under the defining loader of the handed-off object. +- MethodHandle cache: repeated reflective calls are cached for speed. + +If you absolutely must expose a jar on the system classpath temporarily: +- Use the escape hatch (discouraged): `-Dbtrace.system.appendJar=/abs/path/lib.jar -Dbtrace.trusted=true`. +- Prefer fixing packaging or using an extension-local child loader instead. + +## Probe Integration (Conceptual) + +- Probes can call the API directly (API is on bootstrap). Keep probe signatures generic (`Object` argument types). +- Example (pseudo): + +```java +import org.example.btrace.hadoop.api.HadoopApi; +import io.btrace.core.annotations.*; + +@BTrace +class HadoopProbe { + // Using HadoopApi statically via extension linkage (no manual wiring needed) + @OnMethod(clazz="org.apache.hadoop.fs.FileSystem", method="open") + public static void onOpen(@Self Object fs, Object path) { + // HadoopApi.onOpen(fs, path); // conceptual example + } +} +``` + +Note: The example is not maintained as part of core BTrace; adapt for your environment. + diff --git a/btrace-extensions/examples/btrace-hadoop/build.gradle b/btrace-extensions/examples/btrace-hadoop/build.gradle new file mode 100644 index 000000000..25d76830b --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/build.gradle @@ -0,0 +1,27 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-hadoop-example' + name = 'BTrace Hadoop Example' + description = 'Example provided-style extension for Apache Hadoop' + services = ['org.example.btrace.hadoop.api.HadoopApi'] +} + +dependencies { + apiCompileOnly project(':btrace-core') + implCompileOnly project(':btrace-core') +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/api/java/org/example/btrace/hadoop/api/HadoopApi.java b/btrace-extensions/examples/btrace-hadoop/src/api/java/org/example/btrace/hadoop/api/HadoopApi.java new file mode 100644 index 000000000..7be26f1b3 --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/api/java/org/example/btrace/hadoop/api/HadoopApi.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.hadoop.api; + +/** + * Hadoop example API exposed to BTrace probes. Uses Object hand-off to avoid bootstrap coupling to + * application types. + */ +public interface HadoopApi { + void onOpen(Object fileSystem, Object path); + + void onCreate(Object fileSystem, Object path); +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/impl/java/org/example/btrace/hadoop/impl/HadoopApiImpl.java b/btrace-extensions/examples/btrace-hadoop/src/impl/java/org/example/btrace/hadoop/impl/HadoopApiImpl.java new file mode 100644 index 000000000..c5d1b2afc --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/impl/java/org/example/btrace/hadoop/impl/HadoopApiImpl.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.hadoop.impl; + +import io.btrace.core.extensions.Extension; +import io.btrace.extension.util.ClassLoadingUtil; +import io.btrace.extension.util.MethodHandleCache; +import java.lang.invoke.MethodHandle; +import java.net.URI; +import org.example.btrace.hadoop.api.HadoopApi; + +/** Example implementation demonstrating provided-style integration with Hadoop. */ +public final class HadoopApiImpl extends Extension implements HadoopApi { + private final MethodHandleCache mh = new MethodHandleCache(); + + @Override + public void onOpen(Object fileSystem, Object path) { + handleFsOp(fileSystem, path, "open"); + } + + @Override + public void onCreate(Object fileSystem, Object path) { + handleFsOp(fileSystem, path, "create"); + } + + private void handleFsOp(Object fs, Object path, String op) { + if (path == null) return; + ClassLoadingUtil.withDefiningLoader( + path, + () -> { + try { + // Resolve Hadoop Path and FileSystem types reflectively + Class pathCls = ClassLoadingUtil.loadFromContext("org.apache.hadoop.fs.Path", path); + // Use toString on Path via MH + MethodHandle toStringMH = mh.findVirtual(pathCls, "toString", String.class); + String p = (String) toStringMH.invoke(path); + + if (fs != null) { + try { + Class fsCls = + ClassLoadingUtil.loadFromContext("org.apache.hadoop.fs.FileSystem", fs); + // getUri() -> URI + MethodHandle getUri = mh.findVirtual(fsCls, "getUri", URI.class); + Object uri = getUri.invoke(fs); + // Example: println(op+" "+p+" on "+uri) + } catch (Throwable ignored) { + // Optional if FileSystem not present + } + } + } catch (Throwable ignored) { + } + return null; + }); + } +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/main/java/org/example/btrace/hadoop/api/HadoopApi.java b/btrace-extensions/examples/btrace-hadoop/src/main/java/org/example/btrace/hadoop/api/HadoopApi.java new file mode 100644 index 000000000..7be26f1b3 --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/main/java/org/example/btrace/hadoop/api/HadoopApi.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.hadoop.api; + +/** + * Hadoop example API exposed to BTrace probes. Uses Object hand-off to avoid bootstrap coupling to + * application types. + */ +public interface HadoopApi { + void onOpen(Object fileSystem, Object path); + + void onCreate(Object fileSystem, Object path); +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/main/java/org/example/btrace/hadoop/impl/HadoopApiImpl.java b/btrace-extensions/examples/btrace-hadoop/src/main/java/org/example/btrace/hadoop/impl/HadoopApiImpl.java new file mode 100644 index 000000000..c5d1b2afc --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/main/java/org/example/btrace/hadoop/impl/HadoopApiImpl.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.hadoop.impl; + +import io.btrace.core.extensions.Extension; +import io.btrace.extension.util.ClassLoadingUtil; +import io.btrace.extension.util.MethodHandleCache; +import java.lang.invoke.MethodHandle; +import java.net.URI; +import org.example.btrace.hadoop.api.HadoopApi; + +/** Example implementation demonstrating provided-style integration with Hadoop. */ +public final class HadoopApiImpl extends Extension implements HadoopApi { + private final MethodHandleCache mh = new MethodHandleCache(); + + @Override + public void onOpen(Object fileSystem, Object path) { + handleFsOp(fileSystem, path, "open"); + } + + @Override + public void onCreate(Object fileSystem, Object path) { + handleFsOp(fileSystem, path, "create"); + } + + private void handleFsOp(Object fs, Object path, String op) { + if (path == null) return; + ClassLoadingUtil.withDefiningLoader( + path, + () -> { + try { + // Resolve Hadoop Path and FileSystem types reflectively + Class pathCls = ClassLoadingUtil.loadFromContext("org.apache.hadoop.fs.Path", path); + // Use toString on Path via MH + MethodHandle toStringMH = mh.findVirtual(pathCls, "toString", String.class); + String p = (String) toStringMH.invoke(path); + + if (fs != null) { + try { + Class fsCls = + ClassLoadingUtil.loadFromContext("org.apache.hadoop.fs.FileSystem", fs); + // getUri() -> URI + MethodHandle getUri = mh.findVirtual(fsCls, "getUri", URI.class); + Object uri = getUri.invoke(fs); + // Example: println(op+" "+p+" on "+uri) + } catch (Throwable ignored) { + // Optional if FileSystem not present + } + } + } catch (Throwable ignored) { + } + return null; + }); + } +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/test/java/org/apache/hadoop/fs/FileSystem.java b/btrace-extensions/examples/btrace-hadoop/src/test/java/org/apache/hadoop/fs/FileSystem.java new file mode 100644 index 000000000..22d76275d --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/test/java/org/apache/hadoop/fs/FileSystem.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.apache.hadoop.fs; + +import java.net.URI; + +public final class FileSystem { + public static boolean getUriCalled; + + private final URI uri; + + public FileSystem(URI uri) { + this.uri = uri; + } + + public URI getUri() { + getUriCalled = true; + return uri; + } + + public static void reset() { + getUriCalled = false; + } +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/test/java/org/apache/hadoop/fs/Path.java b/btrace-extensions/examples/btrace-hadoop/src/test/java/org/apache/hadoop/fs/Path.java new file mode 100644 index 000000000..a006186ba --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/test/java/org/apache/hadoop/fs/Path.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.apache.hadoop.fs; + +public final class Path { + public static boolean toStringCalled; + + private final String value; + + public Path(String value) { + this.value = value; + } + + @Override + public String toString() { + toStringCalled = true; + return value; + } + + public static void reset() { + toStringCalled = false; + } +} diff --git a/btrace-extensions/examples/btrace-hadoop/src/test/java/org/example/btrace/hadoop/HadoopApiImplTest.java b/btrace-extensions/examples/btrace-hadoop/src/test/java/org/example/btrace/hadoop/HadoopApiImplTest.java new file mode 100644 index 000000000..4ef43bed9 --- /dev/null +++ b/btrace-extensions/examples/btrace-hadoop/src/test/java/org/example/btrace/hadoop/HadoopApiImplTest.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.hadoop; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.net.URI; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.example.btrace.hadoop.impl.HadoopApiImpl; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class HadoopApiImplTest { + @BeforeEach + void reset() { + Path.reset(); + FileSystem.reset(); + } + + @Test + void openUsesReflectivePathAndFileSystemMethods() { + HadoopApiImpl api = new HadoopApiImpl(); + + api.onOpen(new FileSystem(URI.create("hdfs://cluster-a")), new Path("/tmp/input")); + + assertTrue(Path.toStringCalled, "Expected Path.toString() to be invoked"); + assertTrue(FileSystem.getUriCalled, "Expected FileSystem.getUri() to be invoked"); + } + + @Test + void createUsesReflectivePathAndFileSystemMethods() { + HadoopApiImpl api = new HadoopApiImpl(); + + api.onCreate(new FileSystem(URI.create("hdfs://cluster-b")), new Path("/tmp/output")); + + assertTrue(Path.toStringCalled, "Expected Path.toString() to be invoked"); + assertTrue(FileSystem.getUriCalled, "Expected FileSystem.getUri() to be invoked"); + } +} diff --git a/btrace-extensions/examples/btrace-spark/README.md b/btrace-extensions/examples/btrace-spark/README.md new file mode 100644 index 000000000..bb79bf6a2 --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/README.md @@ -0,0 +1,73 @@ +# BTrace Spark Example (Provided-Style Extension) + +This example demonstrates a provided-style BTrace extension for Apache Spark that: +- Exposes a minimal API on bootstrap (`org.example.btrace.spark.api.SparkApi`). +- Loads implementation in an isolated classloader (no system/boot CL injection). +- Resolves Spark classes at runtime using object hand-off and the application’s defining class loader. +- Caches reflective MethodHandles for performance. + +## Build + +``` +./gradlew :btrace-extensions:examples:btrace-spark:build +``` + +The BTrace extension plugin will produce API/impl artifacts. Use with a BTrace distribution that supports extensions. + +## Configuration (`extensions.conf`) + +``` +# Enable the example +btrace-spark-example.enabled=true + +# Role detection: auto|driver|executor (example only; implement as needed) +btrace-spark-example.role=auto + +# Optional: if your application does not ship Spark libs and you must point +# the extension at an external classpath for reflective linking. Prefer not needed. +# btrace-spark-example.classpath=/opt/spark/jars +``` + +## Permissions + +This example uses reflection. Ensure your policy grants the permission: + +``` +# permissions.properties (see PermissionPolicy docs) +grant=REFLECTION,SYSTEM_PROPS +``` + +Avoid `CLASSLOADER` unless you explicitly create child loaders from configured paths. + +## Usage Notes + +- Provided-style: no bootstrap/system classpath mutation; probe code imports only the API. +- Object hand-off: pass Spark event objects (`Object`) to API methods; the impl resolves types at runtime. +- Class loading: the impl runs resolution under the defining loader of the handed-off object. +- MethodHandle cache: repeated reflective calls are cached for speed. + +If you absolutely must expose a jar on the system classpath temporarily: +- Use the escape hatch (discouraged): `-Dbtrace.system.appendJar=/abs/path/lib.jar -Dbtrace.trusted=true`. +- Prefer fixing packaging or using an extension-local child loader instead. + +## Probe Integration (Conceptual) + +- Probes can call the API directly (API is on bootstrap). Keep probe signatures generic (`Object` argument types). +- Example (pseudo): + +```java +import org.example.btrace.spark.api.SparkApi; +import io.btrace.core.annotations.*; + +@BTrace +class SparkProbe { + // Using SparkApi statically via extension linkage (no manual wiring needed) + @OnMethod(clazz="org.apache.spark.scheduler.DAGScheduler", method="handleJobStart") + public static void onJobStart(@Self Object self, Object jobStart) { + // SparkApi.onJobStart(jobStart); // conceptual example + } +} +``` + +Note: The example is not maintained as part of core BTrace; adapt for your environment. + diff --git a/btrace-extensions/examples/btrace-spark/build.gradle b/btrace-extensions/examples/btrace-spark/build.gradle new file mode 100644 index 000000000..0049910ce --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/build.gradle @@ -0,0 +1,27 @@ +plugins { + id 'io.btrace.extension' + alias(libs.plugins.shadow) +} + +java { + sourceCompatibility = 8 + targetCompatibility = 8 +} + +compileJava { + javaCompiler = javaToolchains.compilerFor { + languageVersion.set(JavaLanguageVersion.of(11)) + } +} + +btraceExtension { + id = 'btrace-spark-example' + name = 'BTrace Spark Example' + description = 'Example provided-style extension for Apache Spark (driver/executor)' + services = ['org.example.btrace.spark.api.SparkApi'] +} + +dependencies { + apiCompileOnly project(':btrace-core') + implCompileOnly project(':btrace-core') +} diff --git a/btrace-extensions/examples/btrace-spark/src/api/java/org/example/btrace/spark/api/SparkApi.java b/btrace-extensions/examples/btrace-spark/src/api/java/org/example/btrace/spark/api/SparkApi.java new file mode 100644 index 000000000..04acd201a --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/api/java/org/example/btrace/spark/api/SparkApi.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.spark.api; + +/** + * Spark example API exposed to BTrace probes. Uses only simple types and Object hand-off to avoid + * coupling to application classes on bootstrap. + */ +public interface SparkApi { + void onJobStart(Object jobStartEvent); + + void onStageCompleted(Object stageInfo); +} diff --git a/btrace-extensions/examples/btrace-spark/src/impl/java/org/example/btrace/spark/impl/SparkApiImpl.java b/btrace-extensions/examples/btrace-spark/src/impl/java/org/example/btrace/spark/impl/SparkApiImpl.java new file mode 100644 index 000000000..98d644745 --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/impl/java/org/example/btrace/spark/impl/SparkApiImpl.java @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.spark.impl; + +import io.btrace.core.extensions.Extension; +import io.btrace.extension.util.ClassLoadingUtil; +import io.btrace.extension.util.MethodHandleCache; +import java.lang.invoke.MethodHandle; +import org.example.btrace.spark.api.SparkApi; + +/** Example implementation demonstrating provided-style linking via TCCL/defining loader. */ +public final class SparkApiImpl extends Extension implements SparkApi { + private final MethodHandleCache mh = new MethodHandleCache(); + + @Override + public void onJobStart(Object jobStartEvent) { + if (jobStartEvent == null) return; + ClassLoadingUtil.withDefiningLoader( + jobStartEvent, + () -> { + try { + Class evtCls = + ClassLoadingUtil.loadFromContext( + "org.apache.spark.scheduler.SparkListenerJobStart", jobStartEvent); + MethodHandle getJobId = mh.findVirtual(evtCls, "jobId", int.class); + int jobId = (int) getJobId.invoke(jobStartEvent); + // Demonstrate multiple cached lookups (if method exists) + // For illustration purposes; real implementations should catch Lookup errors + // and log a single warning rather than per-event. + try { + MethodHandle submissionTime = mh.findVirtual(evtCls, "time", long.class); + long ts = (long) submissionTime.invoke(jobStartEvent); + // Example: println("Spark job "+jobId+" at "+ts) + } catch (MethodHandleCache.LookupRuntimeException ignored) { + // optional method; ignore if absent + } + // TODO: emit to BTrace runtime (left minimal for example) + } catch (Throwable ignored) { + // example: swallow; real impl should log via BTrace runtime logger + } + return null; + }); + } + + @Override + public void onStageCompleted(Object stageInfo) { + if (stageInfo == null) return; + ClassLoadingUtil.withDefiningLoader( + stageInfo, + () -> { + try { + Class cls = + ClassLoadingUtil.loadFromContext("org.apache.spark.scheduler.StageInfo", stageInfo); + // Example: read simple properties via cached MethodHandles + try { + MethodHandle nameMH = mh.findVirtual(cls, "name", String.class); + String name = (String) nameMH.invoke(stageInfo); + // println("Stage completed: "+name) + } catch (MethodHandleCache.LookupRuntimeException ignored) { + } + try { + MethodHandle tasksMH = mh.findVirtual(cls, "numTasks", int.class); + int tasks = (int) tasksMH.invoke(stageInfo); + // println("Tasks: "+tasks) + } catch (MethodHandleCache.LookupRuntimeException ignored) { + } + } catch (Throwable ignored) { + } + return null; + }); + } +} diff --git a/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/api/SparkApi.java b/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/api/SparkApi.java new file mode 100644 index 000000000..04acd201a --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/api/SparkApi.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.spark.api; + +/** + * Spark example API exposed to BTrace probes. Uses only simple types and Object hand-off to avoid + * coupling to application classes on bootstrap. + */ +public interface SparkApi { + void onJobStart(Object jobStartEvent); + + void onStageCompleted(Object stageInfo); +} diff --git a/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/api/SparkListenerJobStartType.java b/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/api/SparkListenerJobStartType.java new file mode 100644 index 000000000..e117dd8db --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/api/SparkListenerJobStartType.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.spark.api; + +import io.btrace.core.extensions.ExternalType; + +/** + * Build-time contract for {@code org.apache.spark.scheduler.SparkListenerJobStart}. + * + *

The annotation processor generates {@code SparkListenerJobStartType$Ext} in this same package + * with lazy-resolving static dispatchers for each declared method. + */ +@ExternalType("org.apache.spark.scheduler.SparkListenerJobStart") +public interface SparkListenerJobStartType { + int jobId(); + + long time(); +} diff --git a/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/impl/SparkApiImpl.java b/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/impl/SparkApiImpl.java new file mode 100644 index 000000000..f1a7303b1 --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/main/java/org/example/btrace/spark/impl/SparkApiImpl.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.spark.impl; + +import io.btrace.core.extensions.Extension; +import io.btrace.extension.util.ClassLoadingUtil; +import io.btrace.extension.util.MethodHandleCache; +import java.lang.invoke.MethodHandle; +import org.example.btrace.spark.api.SparkApi; +import org.example.btrace.spark.api.SparkListenerJobStartType$Ext; + +/** Example implementation demonstrating provided-style linking via TCCL/defining loader. */ +public final class SparkApiImpl extends Extension implements SparkApi { + private final MethodHandleCache mh = new MethodHandleCache(); + + @Override + public void onJobStart(Object jobStartEvent) { + if (jobStartEvent == null) return; + try { + int jobId = SparkListenerJobStartType$Ext.jobId(jobStartEvent); + long ts = SparkListenerJobStartType$Ext.time(jobStartEvent); + // Example: println("Spark job "+jobId+" at "+ts) + } catch (Throwable ignored) { + // example: swallow; real impl should log via BTrace runtime logger + } + } + + @Override + public void onStageCompleted(Object stageInfo) { + if (stageInfo == null) return; + ClassLoadingUtil.withDefiningLoader( + stageInfo, + () -> { + try { + Class cls = + ClassLoadingUtil.loadFromContext("org.apache.spark.scheduler.StageInfo", stageInfo); + // Example: read simple properties via cached MethodHandles + try { + MethodHandle nameMH = mh.findVirtual(cls, "name", String.class); + String name = (String) nameMH.invoke(stageInfo); + // println("Stage completed: "+name) + } catch (MethodHandleCache.LookupRuntimeException ignored) { + } + try { + MethodHandle tasksMH = mh.findVirtual(cls, "numTasks", int.class); + int tasks = (int) tasksMH.invoke(stageInfo); + // println("Tasks: "+tasks) + } catch (MethodHandleCache.LookupRuntimeException ignored) { + } + } catch (Throwable ignored) { + // example: swallow; real impl should log via BTrace runtime logger + } + return null; + }); + } +} diff --git a/btrace-extensions/examples/btrace-spark/src/test/java/org/apache/spark/scheduler/SparkListenerJobStart.java b/btrace-extensions/examples/btrace-spark/src/test/java/org/apache/spark/scheduler/SparkListenerJobStart.java new file mode 100644 index 000000000..071c9cf99 --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/test/java/org/apache/spark/scheduler/SparkListenerJobStart.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.apache.spark.scheduler; + +public final class SparkListenerJobStart { + private final int jobId; + private final long time; + + public SparkListenerJobStart(int jobId, long time) { + this.jobId = jobId; + this.time = time; + } + + public int jobId() { + return jobId; + } + + public long time() { + return time; + } +} diff --git a/btrace-extensions/examples/btrace-spark/src/test/java/org/apache/spark/scheduler/StageInfo.java b/btrace-extensions/examples/btrace-spark/src/test/java/org/apache/spark/scheduler/StageInfo.java new file mode 100644 index 000000000..ed40d3633 --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/test/java/org/apache/spark/scheduler/StageInfo.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.apache.spark.scheduler; + +public final class StageInfo { + public static boolean nameCalled; + public static boolean numTasksCalled; + + private final String name; + private final int numTasks; + + public StageInfo(String name, int numTasks) { + this.name = name; + this.numTasks = numTasks; + } + + public String name() { + nameCalled = true; + return name; + } + + public int numTasks() { + numTasksCalled = true; + return numTasks; + } + + public static void reset() { + nameCalled = false; + numTasksCalled = false; + } +} diff --git a/btrace-extensions/examples/btrace-spark/src/test/java/org/example/btrace/spark/SparkApiImplTest.java b/btrace-extensions/examples/btrace-spark/src/test/java/org/example/btrace/spark/SparkApiImplTest.java new file mode 100644 index 000000000..dc1edbfe9 --- /dev/null +++ b/btrace-extensions/examples/btrace-spark/src/test/java/org/example/btrace/spark/SparkApiImplTest.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2008, 2024, Jaroslav Bachorik . + * All rights reserved. + * + * 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 + * + * https://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 org.example.btrace.spark; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.apache.spark.scheduler.SparkListenerJobStart; +import org.apache.spark.scheduler.StageInfo; +import org.example.btrace.spark.api.SparkListenerJobStartType$Ext; +import org.example.btrace.spark.impl.SparkApiImpl; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class SparkApiImplTest { + @BeforeEach + void reset() { + StageInfo.reset(); + } + + @Test + void externalTypeAdapterDispatchesAgainstTestSparkType() { + SparkListenerJobStart jobStart = new SparkListenerJobStart(17, 42L); + + assertEquals(17, SparkListenerJobStartType$Ext.jobId(jobStart)); + assertEquals(42L, SparkListenerJobStartType$Ext.time(jobStart)); + } + + @Test + void implementationInvokesReflectiveStageInfoMethods() { + SparkApiImpl api = new SparkApiImpl(); + + api.onStageCompleted(new StageInfo("stage-a", 3)); + + assertTrue(StageInfo.nameCalled, "Expected StageInfo.name() to be invoked"); + assertTrue(StageInfo.numTasksCalled, "Expected StageInfo.numTasks() to be invoked"); + } +} diff --git a/btrace-gradle-plugin/README.md b/btrace-gradle-plugin/README.md new file mode 100644 index 000000000..7cd9b5772 --- /dev/null +++ b/btrace-gradle-plugin/README.md @@ -0,0 +1,379 @@ +# BTrace Gradle Plugins + +This module provides two Gradle plugins for the BTrace extension ecosystem: + +1. **BTrace Extension Plugin** (`io.btrace.extension`) - Build and package BTrace extensions +2. **BTrace Fat Agent Plugin** (`io.btrace.fat-agent`) - Build self-contained fat agent JARs with embedded extensions + +--- + +## BTrace Extension Plugin + +Build and package BTrace extensions with sane defaults. + +### Features +- Scans implementation bytecode to infer minimal required permissions +- Writes extension metadata into the API JAR manifest +- Produces three artifacts: API JAR, Impl JAR (shadowed), and distributable ZIP +- Uses a single authored source tree while preserving the API/impl runtime artifact split +- Auto-registers the `@ExternalType` annotation processor on the main source set (generates typed, lazy-resolution adapters for application types — see `docs/architecture/provided-style-extensions.md`) + +### Apply the Plugin + +```groovy +plugins { + id 'io.btrace.extension' version "${btraceVersion}" +} + +repositories { + mavenCentral() + mavenLocal() // if you published locally for testing +} +``` + +### Project Layout + +- `src/main/java`, `src/main/resources`: Single authored source tree +- The plugin derives the exported API closure from declared services and keeps the same runtime artifact split (`*-api.jar` + `*-impl.jar`) + +### DSL Configuration + +```groovy +btraceExtension { + id = "com.example.myext" // required: globally unique extension ID + name = "My Extension" // optional + description = "Does things" // optional + + // Optional: omit to auto-detect from @ServiceDescriptor annotations + services = [ + "com.example.myext.api.MyService" + ] + + additionalExports = [ + // optional extra API types to include in the exported API set + ] + excludedExports = [ + // optional exclusions from the computed API export set + ] + + requiresExtensions = [ + // other extension IDs if you depend on them + ] + + shadedPackages = [ + // from : to (relocations applied to impl JAR) + "com.example.dep" : "com.example.myext.shaded.dep" + ] + + // Permissions + scanPermissions = true // default: scan impl JAR + classpath + requiredPermissions = [ + // "NETWORK", "FILE_READ", "FILE_WRITE", "THREADS", "EXEC", "NATIVE", + // "REFLECTION", "CLASSLOADER", "SYSTEM_PROPS", "THREAD_INFO", "MEMORY_INFO", "JFR_EVENTS" + ] + + // Lints + apiCtorSeverity = 'error' // 'off' | 'warn' | 'error' (default: 'error') +} +``` + +### Outputs + +- **API JAR**: `build/libs/--api.jar` with manifest entries: + - `BTrace-Extension-Id`, `BTrace-Extension-Services`, `BTrace-Extension-Permissions`, etc. +- **Impl JAR**: `build/libs/--impl.jar` (shadowed, minimized) +- **Distribution ZIP**: `build/distributions/--extension.zip` + +### Tasks + +- `buildApiJar`: Builds the API JAR and writes extension metadata into the manifest +- `shadowJar`: Builds the impl JAR from the implementation portion of the extension with relocations +- `packageExtension`: Bundles API + Impl into a ZIP + +--- + +## BTrace Fat Agent Plugin + +Build self-contained fat agent JARs with embedded extensions for single-JAR deployment scenarios (Spark, Hadoop, Kubernetes, etc.). + +### Features +- Embeds extensions directly into the agent JAR +- Auto-discovers extension projects in multi-project builds +- Supports project references, Maven coordinates, and local files +- API classes as `.class` files (bootstrap), impl as `.classdata` (runtime loaded) +- Integrates with ShadowJar for package relocation + +### Apply the Plugin + +```groovy +plugins { + id 'io.btrace.fat-agent' version "${btraceVersion}" +} +``` + +### DSL Configuration + +```groovy +btraceFatAgent { + // Output configuration + baseName = 'btrace-agent-fat' // default + outputDir = file('build/libs') // default + + // Extension sources (multiple can be combined) + embedExtensions { + // Project references (requires multi-project build) + project(':btrace-spark') + projects(':btrace-metrics', ':btrace-utils') + + // Maven coordinates + maven('io.btrace:btrace-kafka-extension:2.3.0') + maven(group: 'io.btrace', name: 'btrace-flink-extension', version: '2.3.0') + + // Local extension ZIPs or directories + file('/path/to/extension.zip') + files('/path/to/extensions/*.zip') + } + + // Bundled probes (optional) + bundledProbes { + from 'src/probes/compiled' // pre-compiled .class files + fromSource 'src/probes/java' // Java sources (compiled by plugin) + include 'SparkJobTracer', 'SparkStageTracer' // specific probes only + } + + // Manifest customization + manifest { + attributes(['Custom-Attr': 'value']) + } + + // Package relocations (requires ShadowJar on classpath) + relocate 'org.jctools', 'io.btrace.libs.agent.org.jctools' + relocate 'org.objectweb.asm', 'io.btrace.libs.org.objectweb.asm' + + // Auto-discovery options + autoDiscover = true // find extensions with btrace.extension plugin + filterProperty = 'embedExtensions' // use -PembedExtensions=ext1,ext2 to filter +} +``` + +### Zero-Config Probe Auto-Selection (Configurator) + +Extensions can declare an `ExtensionConfigurator` class that the agent calls at +startup to decide which bundled probes to activate automatically — without the +operator passing `probes=` on the command line. + +**Extension `extension.properties`:** +```properties +id=btrace-spark +probes=SparkJobTracer,SparkStageTracer,SparkExecutorTracer +configurator=org.example.spark.SparkConfigurator +``` + +**Configurator class (in the extension's impl artifact):** +```java +public final class SparkConfigurator implements ExtensionConfigurator { + @Override + public ProbeConfiguration configure(RuntimeEnvironment env, Map args) { + ProbeConfiguration config = new ProbeConfiguration(); + if (env.hasClass("org.apache.spark.SparkContext")) { + config.enable("SparkJobTracer", "SparkStageTracer"); + } else if (env.hasClass("org.apache.spark.executor.Executor")) { + config.enable("SparkExecutorTracer"); + } + config.setOutput(args.getOrDefault("output", "jfr")); + return config; + } +} +``` + +**Operator usage** — attach the fat agent; no `probes=` needed: +```bash +java -javaagent:my-btrace-agent-fat.jar MyApp +``` + +If `probes=` is supplied by the operator it takes priority and the configurator +is skipped entirely: +```bash +java -javaagent:my-btrace-agent-fat.jar=probes=SparkJobTracer MyApp +``` + +See [BTraceExtensionDevelopmentGuide.md](../docs/BTraceExtensionDevelopmentGuide.md) +for the full configurator API reference. + +### Auto-Discovery Mode + +When `autoDiscover = true`, the plugin automatically finds all subprojects with the `io.btrace.extension` plugin applied: + +```groovy +btraceFatAgent { + autoDiscover = true + filterProperty = 'embedExtensions' +} +``` + +Build with specific extensions: +```bash +# Embed all discovered extensions +./gradlew fatAgentJar + +# Embed only specific extensions +./gradlew fatAgentJar -PembedExtensions=btrace-metrics,btrace-statsd +``` + +### Standalone Project Usage + +For projects outside the BTrace monorepo: + +```groovy +plugins { + id 'io.btrace.fat-agent' version '2.3.0' +} + +btraceFatAgent { + baseName = 'my-custom-agent' + + // Reference base BTrace JAR (required for standalone builds) + agentJarTask = 'btraceJar' // or provide path + + embedExtensions { + maven('io.btrace:btrace-metrics:2.3.0') + maven('io.btrace:btrace-statsd:2.3.0') + file('libs/my-custom-extension.zip') + } +} +``` + +### Tasks + +- `stageExtensions`: Resolves and stages extension content (API as `.class`, impl as `.classdata`) +- `stageProbes`: Stages bundled probes to `META-INF/btrace-probes/` +- `fatAgentJar`: Creates the fat agent JAR with all embedded content + +### Output Structure + +The fat agent JAR contains: +``` +btrace-agent-fat.jar +├── META-INF/ +│ ├── MANIFEST.MF +│ │ ├── Premain-Class: io.btrace.agent.Main +│ │ ├── Agent-Class: io.btrace.agent.Main +│ │ ├── Boot-Class-Path: btrace-agent-fat.jar +│ │ └── BTrace-Embedded-Extensions: ext1,ext2,ext3 +│ └── btrace-extensions/ +│ ├── ext1/ +│ │ └── extension.properties +│ ├── ext2/ +│ │ └── extension.properties +│ └── ext3/ +│ └── extension.properties +├── org/openjdk/btrace/... # Agent + boot classes +├── org/example/ext/api/... # Extension API classes (.class) +└── org/example/ext/impl/... # Extension impl classes (.classdata) +``` + +### Using the Fat Agent + +```bash +# Attach to running JVM +java -javaagent:/path/to/btrace-agent-fat.jar + +# With options +java -javaagent:/path/to/btrace-agent-fat.jar=debug=true,port=2021 +``` + +The embedded extensions are automatically discovered and loaded at agent startup. + +--- + +## Local Development + +### Publish Plugins Locally + +```bash +./gradlew :btrace-gradle-plugin:publishToMavenLocal +``` + +Then in your project, add `mavenLocal()` to repositories or pluginManagement. + +### Testing Fat Agent Build + +```bash +# Build fat agent with all extensions +./gradlew :btrace-dist:fatAgentJar + +# Build with specific extensions only +./gradlew :btrace-dist:fatAgentJar -PembedExtensions=btrace-metrics + +# Verify output +jar -tf btrace-dist/build/resources/main/v*/libs/btrace-agent-fat.jar | grep btrace-extensions +``` + +--- + +## Tips + +### Extension Plugin +- Keep API small and stable; only types used by BTrace scripts belong in API +- Put all runtime dependencies into `impl` and shade them +- If permission scanning is too conservative, add `requiredPermissions` explicitly + +### Fat Agent Plugin +- Use auto-discovery for monorepo setups +- Use Maven coordinates for external/published extensions +- Test the fat agent in isolation before production deployment +- Package relocations help avoid classpath conflicts in target JVMs + +--- + +## BTrace Maven Plugin + +For Maven users, a Maven plugin is also available to build fat agent JARs. + +### Usage + +```xml + + + + io.btrace + btrace-maven-plugin + ${btrace.version} + + + + fat-agent + + + + + my-btrace-agent + + io.btrace:btrace-metrics:${btrace.version} + io.btrace:btrace-statsd:${btrace.version} + + + + + +``` + +### Configuration Parameters + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `btraceVersion` | Plugin version | BTrace version to use for base agent/boot JARs | +| `extensions` | (none) | List of extension coordinates (`groupId:artifactId:version`) | +| `outputName` | `btrace-agent-fat` | Output file name (without `.jar`) | +| `outputDirectory` | `${project.build.directory}` | Output directory | +| `skip` | `false` | Skip execution | + +### Build + +```bash +mvn package +``` + +The fat agent JAR is created at `target/${outputName}.jar`. + +See the main [README](../README.md) and [Getting Started Guide](../docs/GettingStarted.md) for usage instructions. diff --git a/btrace-gradle-plugin/build.gradle b/btrace-gradle-plugin/build.gradle new file mode 100644 index 000000000..44c26566c --- /dev/null +++ b/btrace-gradle-plugin/build.gradle @@ -0,0 +1,86 @@ +plugins { + id 'groovy' + id 'java-gradle-plugin' + id 'maven-publish' +} + +java { + toolchain { + languageVersion = JavaLanguageVersion.of(11) + } +} + +group = project.findProperty('GROUP') ?: (rootProject.group ?: 'io.btrace') +version = rootProject.version + +repositories { + gradlePluginPortal() + mavenCentral() +} + +dependencies { + implementation gradleApi() + implementation localGroovy() + // Match versions commonly cached in this repository to avoid extra fetches + implementation 'org.ow2.asm:asm:9.9.1' + implementation 'org.ow2.asm:asm-tree:9.9.1' + + // Testing — version pinned here to match the root project's version catalog (settings.gradle). + // Note: this is an included build and cannot access the root project's 'libs' version catalog. + testImplementation gradleTestKit() + testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4' + testRuntimeOnly 'org.junit.platform:junit-platform-launcher' +} + +test { + useJUnitPlatform() +} + +gradlePlugin { + plugins { + btraceExtension { + id = 'io.btrace.extension' + implementationClass = 'io.btrace.gradle.BTraceExtensionPlugin' + displayName = 'BTrace Extension Plugin' + description = 'Builds and packages BTrace extensions, scanning permissions and wiring manifests.' + } + btraceFatAgent { + id = 'io.btrace.fat-agent' + implementationClass = 'io.btrace.gradle.BTraceFatAgentPlugin' + displayName = 'BTrace Fat Agent Plugin' + description = 'Builds fat agent JARs with embedded extensions for single-JAR deployment.' + } + } +} + +publishing { + publications { + // java-gradle-plugin will add pluginMaven and marker publications automatically. + // This block allows publishing to local/remote Maven repositories. + withType(MavenPublication) { + pom { + name = 'BTrace Gradle Extension Plugin' + description = 'Gradle plugin for building BTrace extensions' + url = 'https://github.com/btraceio/btrace' + licenses { + license { + name = 'GPL-2.0 with Classpath Exception' + url = 'https://openjdk.org/legal/gplv2+ce.html' + } + } + developers { + developer { + id = 'btrace' + name = 'BTrace Project' + url = 'https://github.com/btraceio' + } + } + scm { + url = 'https://github.com/btraceio/btrace' + connection = 'scm:git:https://github.com/btraceio/btrace.git' + developerConnection = 'scm:git:ssh://git@github.com:btraceio/btrace.git' + } + } + } + } +} diff --git a/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceExtensionPlugin.groovy b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceExtensionPlugin.groovy new file mode 100644 index 000000000..f36619825 --- /dev/null +++ b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceExtensionPlugin.groovy @@ -0,0 +1,1404 @@ +package io.btrace.gradle + +import org.gradle.api.Plugin +import org.gradle.api.Project +import org.gradle.api.GradleException +import org.gradle.api.tasks.bundling.Jar +import org.gradle.api.tasks.bundling.Zip +import org.gradle.api.tasks.javadoc.Javadoc +import org.gradle.api.tasks.compile.JavaCompile +import org.gradle.api.tasks.Copy +import org.gradle.api.file.DuplicatesStrategy +import java.lang.reflect.Modifier +import java.net.URLClassLoader +import org.objectweb.asm.ClassReader +import org.objectweb.asm.Type +import org.objectweb.asm.tree.AnnotationNode +import org.objectweb.asm.tree.ClassNode +import org.objectweb.asm.tree.MethodNode +import org.objectweb.asm.tree.TypeAnnotationNode +import org.objectweb.asm.TypeReference +import org.objectweb.asm.signature.SignatureReader +import org.objectweb.asm.signature.SignatureVisitor +import org.objectweb.asm.Opcodes + +class BTraceExtensionPlugin implements Plugin { + + @Override + void apply(Project project) { + // Apply required plugins + project.plugins.apply('java') + // Optionally apply maven-publish when available so we can publish artifacts easily + try { project.plugins.apply('maven-publish') } catch (Throwable ignore) {} + + // Try to ensure Shadow is available; if resolution is blocked, we will emit a clear + // error later with guidance. This is best-effort and safe when already applied. + try { + if (!project.pluginManager.hasPlugin('com.gradleup.shadow')) { + // Respect opt-out + def ext = project.extensions.findByType(BTraceExtensionMetadata) + boolean shouldAutoApply = (ext == null) ? true : (ext.autoApplyShadow != false) + if (shouldAutoApply) { + project.logger.lifecycle("[BTRACE-EXT] Applying Shadow plugin automatically (com.gradleup.shadow) for ${project.path}") + project.pluginManager.apply('com.gradleup.shadow') + } else { + project.logger.lifecycle("[BTRACE-EXT] Shadow auto-apply disabled (btraceExtension.autoApplyShadow=false) for ${project.path}") + } + } + } catch (Throwable t) { + project.logger.warn("[BTRACE-EXT] Unable to auto-apply Shadow plugin: ${t.message}. Apply it explicitly via plugins { id 'com.gradleup.shadow' } or alias(libs.plugins.shadow), or set btraceExtension.autoApplyShadow=true.") + } + + // Create extension for metadata + def extension = project.extensions.create('btraceExtension', BTraceExtensionMetadata) + extension.version = project.version + def authoredSourceSet = { + project.sourceSets.main + } + def authoredOutput = { + authoredSourceSet().output + } + def authoredClassesDirs = { + authoredOutput().classesDirs.files + } + def authoredResourcesDir = { + authoredSourceSet().output.resourcesDir + } + def authoredCompileClasspath = { + authoredSourceSet().compileClasspath.files + } + def authoredCompileTask = { + project.tasks.named('compileJava') + } + def explicitServiceTypes = { + def services = extension.services as List + if (services != null && !services.isEmpty()) { + return services + } + return SingleSourceApiPartition.detectServiceTypes(authoredClassesDirs()) as List + } + def apiIncludes = { + return SingleSourceApiPartition.classFileIncludes( + authoredClassesDirs(), + explicitServiceTypes(), + extension.additionalExports, + extension.excludedExports) + } + def apiTypes = { + return SingleSourceApiPartition.computeExportedTypes( + authoredClassesDirs(), + explicitServiceTypes(), + extension.additionalExports, + extension.excludedExports) + } + def isExportedApiType = { String fqcn -> + apiTypes().contains(fqcn) + } + def implTypes = { + def allTypes = SingleSourceApiPartition.collectAllTypes(authoredClassesDirs()) + allTypes.removeAll(apiTypes()) + return allTypes + } + def apiSourceIncludes = { + def includes = [] as LinkedHashSet + def packages = [] as LinkedHashSet + apiTypes().each { String fqcn -> + includes.add(fqcn.replace('.', '/') + '.java') + int idx = fqcn.lastIndexOf('.') + packages.add(idx >= 0 ? fqcn.substring(0, idx) : '') + } + packages.each { String pkg -> + if (pkg == null || pkg.isEmpty()) { + includes.add('package-info.java') + } else { + includes.add(pkg.replace('.', '/') + '/package-info.java') + } + } + includes.add('module-info.java') + return includes + } + def apiSourceTree = { + project.fileTree(dir: project.file('src/main/java'), includes: apiSourceIncludes() as List) + } + + // Configure dependency configurations + project.configurations { + apiImplementation.extendsFrom implementation + apiCompileOnly.extendsFrom compileOnly + + implImplementation.extendsFrom implementation + implImplementation.extendsFrom apiImplementation + implCompileOnly.extendsFrom compileOnly + implRuntimeClasspath { + canBeConsumed = false + canBeResolved = true + extendsFrom implImplementation + } + } + project.configurations.compileClasspath.extendsFrom( + project.configurations.apiCompileOnly, + project.configurations.implCompileOnly, + project.configurations.implImplementation, + project.configurations.apiImplementation) + project.configurations.runtimeClasspath.extendsFrom( + project.configurations.implImplementation, + project.configurations.apiImplementation) + project.configurations.testCompileClasspath.extendsFrom( + project.configurations.apiCompileOnly, + project.configurations.implCompileOnly, + project.configurations.implImplementation, + project.configurations.apiImplementation) + project.configurations.testRuntimeClasspath.extendsFrom( + project.configurations.apiCompileOnly, + project.configurations.implCompileOnly, + project.configurations.implImplementation, + project.configurations.apiImplementation) + + // Auto-register @ExternalType annotation processor on the main source set. + // In-tree builds reference the sibling subproject directly; external consumers resolve + // the published artifact by version. + def processorProject = project.rootProject.findProject(':btrace-core') + if (processorProject != null) { + project.dependencies.add('annotationProcessor', processorProject) + } else { + project.dependencies.add('annotationProcessor', + "io.btrace:btrace-core:${project.version}") + } + + // Configure duplicate handling for resource tasks + project.tasks.withType(Copy).configureEach { + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + } + + // Task: Build API JAR + def buildApiJar = project.tasks.register('buildApiJar', Jar) { + dependsOn(authoredCompileTask, project.tasks.named('processResources')) + from({ + return project.files(authoredClassesDirs()).asFileTree.matching { + include apiIncludes() + } + }) + from({ + def resourcesDir = authoredResourcesDir() + return resourcesDir != null ? project.files(resourcesDir) : project.files() + }) + archiveClassifier = 'api' + archiveBaseName = project.name + } + + // Task: Validate API service interfaces (practical subset of rules) + def validateServiceApis = project.tasks.register('validateServiceApis') { + dependsOn(authoredCompileTask) + doLast { + // Lint: API classes with public constructors (discouraged; use service-provided builders) + def apiCtorIssues = [] as List + authoredClassesDirs().each { File dir -> + if (!dir.exists()) return + dir.eachFileRecurse { f -> + if (!f.name.endsWith('.class')) return + def rel = dir.toPath().relativize(f.toPath()).toString() + def internalName = rel.replace(File.separatorChar, (char)'/').replaceAll(/\.class$/, '') + if (internalName.endsWith('package-info') || internalName.endsWith('module-info')) return + def fqcn = internalName.replace('/', '.') + if (!isExportedApiType(fqcn)) return + FileInputStream is = new FileInputStream(f) + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + int acc = cn.access + boolean isInterface = (acc & Opcodes.ACC_INTERFACE) != 0 + boolean isAnnotation = (acc & Opcodes.ACC_ANNOTATION) != 0 + boolean isPublic = (acc & Opcodes.ACC_PUBLIC) != 0 + if (isPublic && !isInterface && !isAnnotation) { + boolean hasPublicCtor = false + (cn.methods ?: []).each { MethodNode mn -> + if ("".equals(mn.name) && (mn.access & Opcodes.ACC_PUBLIC) != 0) { + hasPublicCtor = true + } + } + if (hasPublicCtor) { + apiCtorIssues << internalName.replace('/', '.') + } + } + } + } + if (!apiCtorIssues.isEmpty()) { + def sev = (project.extensions.findByType(BTraceExtensionMetadata)?.apiCtorSeverity ?: 'warn') + def msg = "[BTRACE-EXT] API classes with public constructors (avoid 'new' in probes; provide service builders/factories instead): ${apiCtorIssues}" + if ("error".equalsIgnoreCase(sev)) { + throw new GradleException(msg) + } else if (!"off".equalsIgnoreCase(sev)) { + project.logger.warn(msg) + } + } + // Enforce: at most one package-level @ExtensionDescriptor across the project + def extDescDesc = 'Lorg/openjdk/btrace/core/extensions/ExtensionDescriptor;' + int extDescCount = 0 + def scanForPkgDescriptors = { File classesDir -> + if (classesDir == null || !classesDir.exists()) return + classesDir.eachFileRecurse { f -> + if (!f.name.endsWith('.class')) return + if (!f.name.equals('package-info.class')) return + FileInputStream is = new FileInputStream(f) + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + boolean has = false + (cn.visibleAnnotations ?: []).each { has |= (it.desc == extDescDesc) } + (cn.invisibleAnnotations ?: []).each { has |= (it.desc == extDescDesc) } + if (has) extDescCount++ + } + } + authoredClassesDirs().each { scanForPkgDescriptors(it) } + if (extDescCount > 1) { + throw new GradleException("[BTRACE-EXT] Found ${extDescCount} package-level @ExtensionDescriptor annotations. Only one is allowed per extension project (place it in API package-info.java).") + } + + // Prefer explicitly configured services; otherwise, detect via @ServiceDescriptor annotations + def services = extension.services as List + if (!services || services.isEmpty()) { + def detected = new LinkedHashSet() + authoredClassesDirs().each { File dir -> + if (!dir.exists()) return + dir.eachFileRecurse { f -> + if (!f.name.endsWith('.class')) return + def rel = dir.toPath().relativize(f.toPath()).toString() + def fq = rel.replace(File.separatorChar, (char)'.').replaceAll(/\.class$/, '') + if (!isExportedApiType(fq)) return + FileInputStream is = new FileInputStream(f) + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + def isInterface = (cn.access & Opcodes.ACC_INTERFACE) != 0 + def hasMarker = false + (cn.visibleAnnotations ?: []).each { hasMarker |= (it.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') } + (cn.invisibleAnnotations ?: []).each { hasMarker |= (it.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') } + if (hasMarker && isInterface) detected.add(fq) + } + } + services = detected as List + if (!services.isEmpty()) { + project.logger.lifecycle("[BTRACE-EXT] detected services via @ServiceDescriptor: ${services}") + } else { + project.logger.warn('[BTRACE-EXT] No services declared or detected; skipping validation') + return + } + } + def cp = new LinkedHashSet() + cp.addAll(authoredClassesDirs()) + try { cp.addAll(authoredCompileClasspath()) } catch (Throwable ignore) {} + URLClassLoader cl = new URLClassLoader(cp.collect { it.toURI().toURL() } as URL[], (ClassLoader) null) + def errors = [] + def warnings = [] + def perService = new LinkedHashMap>() + def perServiceWarn = new LinkedHashMap>() + + // Build set of impl class names for purity checks + def implClassNames = new HashSet(implTypes()) + + // Nullability annotation descriptors (configurable) + def toDesc = { String fqcn -> 'L' + fqcn.replace('.', '/') + ';' } + def defaultNullable = ['javax.annotation.Nullable','org.jspecify.annotations.Nullable','org.jetbrains.annotations.Nullable','jakarta.annotation.Nullable'] + def defaultNonnull = ['javax.annotation.Nonnull','org.jspecify.annotations.NonNull','org.jetbrains.annotations.NotNull','jakarta.annotation.Nonnull'] + def NULLABLE = ((extension.nullableAnnotations ?: defaultNullable).collect(toDesc)) as Set + def NONNULL = ((extension.nonnullAnnotations ?: defaultNonnull).collect(toDesc)) as Set + int countW020 = 0 + int countW021 = 0 + int count022 = 0 + + services.each { String fqcn -> + try { + Class c = Class.forName(fqcn, false, cl) + def errs = perService.computeIfAbsent(fqcn) { [] } + if (!c.isInterface()) { + def msg = "Service '${fqcn}' must be a public top-level interface; found ${c.modifiers.toString()}\n Fix: Convert to a public top-level interface." + errors << msg; errs << msg + } + if (!Modifier.isPublic(c.getModifiers())) { + def msg = "Service '${fqcn}' must be public\n Fix: Add 'public' modifier." + errors << msg; errs << msg + } + if (c.getDeclaringClass() != null) { + def msg = "Service '${fqcn}' must be top-level (not inner)\n Fix: Move to a top-level interface." + errors << msg; errs << msg + } + // No fields except constants (public static final primitives/Strings) + c.getDeclaredFields().each { f -> + int m = f.modifiers + if (!(Modifier.isPublic(m) && Modifier.isStatic(m) && Modifier.isFinal(m))) { + def msg = "Field '${fqcn}.${f.name}' not allowed; only compile-time constants permitted\n Fix: Remove mutable/stateful fields from interfaces." + errors << msg; errs << msg + } + } + // Prepare ASM method annotation info for this class + def resName = fqcn.replace('.', '/') + '.class' + def is = cl.getResourceAsStream(resName) + if (is == null) { + def msg = "Declared service '${fqcn}' not found in the exported API output\n Fix: Keep the interface under src/main/java, ensure it is reachable from the export set, or list it in btraceExtension.services." + errors << msg; perService.computeIfAbsent(fqcn) { [] } << msg + return + } + byte[] classBytes + try { classBytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(classBytes) + def cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + def methodAnnoInfo = [:] // key=name+desc -> [retNullable, retNonNull, paramAnno: idx->[nullable, nonnull]] + def permAnnoSet = new HashSet() + // Collect ServiceDescriptor.permissions + def collectServicePerms = { AnnotationNode an -> + if (an == null) return + if (an.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') { + def vals = an.values ?: [] + for (int i = 0; i < vals.size(); i += 2) { + if (vals[i] == 'permissions') { + def arr = vals[i+1] as List + arr?.each { ev -> + if (ev instanceof List && ev.size() >= 2) { + permAnnoSet.add(String.valueOf(ev[1])) + } + } + } + } + } + } + (cn.visibleAnnotations ?: []).each(collectServicePerms) + (cn.invisibleAnnotations ?: []).each(collectServicePerms) + cn.methods.each { MethodNode mn -> + def key = mn.name + mn.desc + def info = [retNullable:false, retNonNull:false, paramAnno:[:]] + (mn.visibleAnnotations ?: []).each { AnnotationNode an -> + if (NULLABLE.contains(an.desc)) info.retNullable = true + if (NONNULL.contains(an.desc)) info.retNonNull = true + collectServicePerms(an) + } + (mn.invisibleAnnotations ?: []).each { AnnotationNode an -> + if (NULLABLE.contains(an.desc)) info.retNullable = true + if (NONNULL.contains(an.desc)) info.retNonNull = true + collectServicePerms(an) + } + (mn.visibleTypeAnnotations ?: []).each { TypeAnnotationNode tan -> + def tr = new TypeReference(tan.typeRef) + if (tr.sort == TypeReference.METHOD_RETURN) { + if (NULLABLE.contains(tan.desc)) info.retNullable = true + if (NONNULL.contains(tan.desc)) info.retNonNull = true + } else if (tr.sort == TypeReference.METHOD_FORMAL_PARAMETER) { + int pidx = tr.formalParameterIndex + def pa = info.paramAnno.computeIfAbsent(pidx) { [nullable:false, nonnull:false] } + if (NULLABLE.contains(tan.desc)) pa.nullable = true + if (NONNULL.contains(tan.desc)) pa.nonnull = true + } + } + (mn.invisibleTypeAnnotations ?: []).each { TypeAnnotationNode tan -> + def tr = new TypeReference(tan.typeRef) + if (tr.sort == TypeReference.METHOD_RETURN) { + if (NULLABLE.contains(tan.desc)) info.retNullable = true + if (NONNULL.contains(tan.desc)) info.retNonNull = true + } else if (tr.sort == TypeReference.METHOD_FORMAL_PARAMETER) { + int pidx = tr.formalParameterIndex + def pa = info.paramAnno.computeIfAbsent(pidx) { [nullable:false, nonnull:false] } + if (NULLABLE.contains(tan.desc)) pa.nullable = true + if (NONNULL.contains(tan.desc)) pa.nonnull = true + } + } + // Parameter annotations (non type-use) + int paramCount = (mn.visibleParameterAnnotations ?: new List[0]).length + for (int i = 0; i < paramCount; i++) { + def lst = mn.visibleParameterAnnotations[i] + if (lst == null) continue + def pa = info.paramAnno.computeIfAbsent(i) { [nullable:false, nonnull:false] } + lst.each { AnnotationNode an -> + if (NULLABLE.contains(an.desc)) pa.nullable = true + if (NONNULL.contains(an.desc)) pa.nonnull = true + } + } + paramCount = (mn.invisibleParameterAnnotations ?: new List[0]).length + for (int i = 0; i < paramCount; i++) { + def lst = mn.invisibleParameterAnnotations[i] + if (lst == null) continue + def pa = info.paramAnno.computeIfAbsent(i) { [nullable:false, nonnull:false] } + lst.each { AnnotationNode an -> + if (NULLABLE.contains(an.desc)) pa.nullable = true + if (NONNULL.contains(an.desc)) pa.nonnull = true + } + } + methodAnnoInfo[key] = info + } + + // Permission alignment: if permissions annotated in API, ensure either scanning is on + // or declared requiredPermissions include at least those. + if (!permAnnoSet.isEmpty()) { + if (!extension.scanPermissions) { + def declared = (extension.requiredPermissions ?: [])*.toString()*.toUpperCase(java.util.Locale.ROOT) as Set + def missing = permAnnoSet.findAll { !declared.contains(String.valueOf(it).toUpperCase(java.util.Locale.ROOT)) } + if (!missing.isEmpty()) { + errors << "Service '${fqcn}' requires permissions ${missing} not covered by plugin requiredPermissions; enable scanPermissions or add them." + } + } + } + + // Methods: no default methods, no checked throws, no forbidden signature types + c.getMethods().each { m -> + // Only methods declared on this interface (avoid Object methods) + if (m.declaringClass != c) return + if (m.isDefault()) { + def msg = "Default method '${fqcn}#${m.name}' not allowed (Java 8 shim-compat)\n Fix: Move behavior to implementation; keep API pure." + errors << msg; errs << msg + } + // Checked exceptions + m.exceptionTypes.each { ex -> + if (!(RuntimeException.isAssignableFrom(ex) || Error.isAssignableFrom(ex))) { + def msg = "Method '${fqcn}#${m.name}' declares checked exception: ${ex.name}\n Fix: Remove checked exceptions from API signatures." + errors << msg; errs << msg + } + } + // Forbidden signature packages + def forbid = [ + 'java.io.', 'java.net.', 'java.nio.channels.', 'java.lang.reflect.' + ] + def allTypes = [] + allTypes << m.returnType + allTypes.addAll(m.parameterTypes) + allTypes.each { t -> + String n = t.name + if (forbid.any { n.startsWith(it) }) { + def msg = "Method '${fqcn}#${m.name}' uses forbidden type in signature: ${n}\n Fix: Restrict signatures to JDK types and API interfaces." + errors << msg; errs << msg + } + if (implClassNames.contains(n)) { + def msg = "API surface leaks implementation type in signature: ${n}\n Fix: Do not expose implementation-only types in API signatures." + errors << msg; errs << msg + } + } + + // Nullability + shimability + def md = Type.getMethodDescriptor(Type.getType(m.returnType), m.parameterTypes.collect { Type.getType(it) } as Type[]) + def key = m.name + md + def info = methodAnnoInfo.get(key) ?: [retNullable:false, retNonNull:false, paramAnno:[:]] + // Return nullability: only relevant for reference types (not void/primitives) + if (m.returnType != Void.TYPE && !m.returnType.isPrimitive()) { + if (!(info.retNullable || info.retNonNull)) { + def msgWarn = "Missing nullability on return of '${fqcn}#${m.name}'\n Fix: Annotate with @NonNull or @Nullable." + warnings << msgWarn; perServiceWarn.computeIfAbsent(fqcn) { [] } << msgWarn + countW020++ + } + // Shimability: if return is interface, require @Nullable unless configured otherwise + if (m.returnType.isInterface() && !info.retNullable) { + def msg22 = "Return type '${m.returnType.name}' of '${fqcn}#${m.name}' must be @Nullable for shim compatibility\n Fix: Mark interface returns @Nullable or provide a documented default." + if ((extension.shimabilitySeverity ?: 'error').equalsIgnoreCase('warn')) { + warnings << msg22; perServiceWarn.computeIfAbsent(fqcn) { [] } << msg22 + } else { + errors << msg22; errs << msg22 + } + count022++ + } + } + // Parameter nullability: recommend but do not enforce by default + m.parameterTypes.eachWithIndex { pt, idx -> + if (!(pt.isPrimitive())) { + def pinfo = info.paramAnno.get(idx) ?: [nullable:false, nonnull:false] + if (!(pinfo.nullable || pinfo.nonnull)) { + def msg21 = "Missing nullability on parameter ${idx} of '${fqcn}#${m.name}'\n Fix: Annotate each parameter with @NonNull or @Nullable." + if ((extension.nullabilitySeverity ?: 'warn').equalsIgnoreCase('error')) { + def emsg = "Missing nullability on parameter ${idx} of '${fqcn}#${m.name}'\n Fix: Annotate each parameter with @NonNull or @Nullable." + errors << emsg; errs << emsg + } else if (!'off'.equalsIgnoreCase(extension.nullabilitySeverity ?: 'warn')) { + warnings << msg21; perServiceWarn.computeIfAbsent(fqcn) { [] } << msg21 + } + countW021++ + } + } + } + } + + // Note: we intentionally avoid scanning raw class bytes for impl internal + // names to prevent false positives (e.g., substring matches in class names). + // Purity is enforced via explicit signature/generic parsing above. + } catch (ClassNotFoundException cnf) { + def msg = "Declared service '${fqcn}' not found in the exported API output\n Fix: Keep the interface under src/main/java, ensure it is reachable from the export set, or list it in btraceExtension.services." + errors << msg; perService.computeIfAbsent(fqcn) { [] } << msg + } catch (Throwable t) { + def msg = "Failed to analyze service '${fqcn}': ${t.message}" + errors << msg; perService.computeIfAbsent(fqcn) { [] } << msg + } + } + // Only warn when there is no way to obtain permissions: both scanning disabled + // and no explicit requiredPermissions provided. If scanning is enabled (default), + // permissions will be generated later when building the API JAR. + if (!extension.scanPermissions && (!extension.requiredPermissions || extension.requiredPermissions.isEmpty())) { + project.logger.warn("[BTRACE-EXT] No permissions source configured; enable scanPermissions or set requiredPermissions") + } + // Write grouped report + def reportDir = new File(project.buildDir, 'reports/btrace') + reportDir.mkdirs() + def report = new File(reportDir, 'service-api-validation.txt') + report.withWriter('UTF-8') { w -> + w.println("BTrace Service API Validation Report") + w.println("Project: ${project.path}") + w.println() + perService.each { k, v -> + w.println("Service: ${k}") + if (v.isEmpty()) { + w.println(" OK") + } else { + v.each { w.println(" - ${it}") } + } + w.println() + } + if (!perServiceWarn.isEmpty()) { + w.println("Warnings:") + perServiceWarn.each { k, v -> + if (v.isEmpty()) return + w.println("Service: ${k}") + v.each { w.println(" - ${it}") } + w.println() + } + } + // Summary + w.println("Summary:") + w.println(" Missing @Nullable on interface returns (shimability): ${count022}") + if (!'off'.equalsIgnoreCase(extension.nullabilitySeverity ?: 'warn')) { + w.println(" Missing return nullability annotations: ${countW020}") + w.println(" Missing parameter nullability annotations: ${countW021}") + } + w.println() + w.println("Total errors: ${errors.size()}") + } + project.logger.lifecycle("[BTRACE-EXT] validation report: ${project.relativePath(report)}") + if (!errors.isEmpty()) { + errors.each { project.logger.error("[BTRACE-EXT] ${it}") } + throw new GradleException("BTrace extension API validation failed with ${errors.size()} error(s)") + } + if (!warnings.isEmpty()) { + warnings.each { project.logger.warn("[BTRACE-EXT] ${it}") } + } + project.logger.lifecycle("[BTRACE-EXT] validateServiceApis: OK for ${services.size()} service(s)") + } + } + + // Summary report task that never fails; emits grouped violations with fixes + def serviceApiValidationReport = project.tasks.register('serviceApiValidationReport') { + dependsOn(authoredCompileTask) + doLast { + // Reuse the validation task to produce the report; do not fail build + try { + project.tasks.named('validateServiceApis').get().actions.each { it.execute(project.tasks.named('validateServiceApis').get()) } + } catch (Throwable t) { + // ignore failures; report was already written by validate task + } + def report = new File(project.buildDir, 'reports/btrace/service-api-validation.txt') + if (report.exists()) { + project.logger.lifecycle("[BTRACE-EXT] validation report available at: ${project.relativePath(report)}") + project.logger.quiet(report.getText('UTF-8')) + } else { + project.logger.lifecycle('[BTRACE-EXT] No report generated (no services or validation skipped)') + } + } + } + + // Task: Build Implementation JAR (requires Shadow plugin applied by the consumer project) + def implJarProviderRef = new Object[1] + project.pluginManager.withPlugin('com.gradleup.shadow') { + def shadowJarProvider = project.tasks.named('shadowJar', Jar) + project.afterEvaluate { + shadowJarProvider.configure { + dependsOn(authoredCompileTask) + from({ + return project.files(authoredClassesDirs()).asFileTree.matching { + exclude apiIncludes() + } + }) + configurations = [project.configurations.implRuntimeClasspath] + archiveClassifier = 'impl' + archiveBaseName = project.name + + // Apply relocations from extension metadata + extension.shadedPackages.each { from, to -> + relocate from, to + } + + // Minimize to remove unused classes + minimize() + } + } + implJarProviderRef[0] = shadowJarProvider + } + + // Wrapper task to build implementation jar via selected strategy + def buildImplJar = project.tasks.register('buildImplJar') { + doFirst { + if (implJarProviderRef[0] == null) { + throw new IllegalStateException("Shadow plugin ('com.gradleup.shadow') must be applied in the project using the BTrace extension plugin.") + } + } + dependsOn { implJarProviderRef[0] } + } + + // Configure API JAR manifest with extension metadata + project.afterEvaluate { + if (implJarProviderRef[0] == null) { + def ext = project.extensions.findByType(BTraceExtensionMetadata) + boolean autoApplied = (ext == null) ? true : (ext.autoApplyShadow != false) + String hint = autoApplied ? "Ensure the Shadow plugin is resolvable/available." : "Enable auto-apply (btraceExtension.autoApplyShadow=true) or apply Shadow explicitly." + throw new GradleException("[BTRACE-EXT] Shadow plugin is required for ${project.path}. Apply id 'com.gradleup.shadow' (or alias(libs.plugins.shadow)). ${hint}") + } + def implArchiveProvider = ((org.gradle.api.tasks.TaskProvider) implJarProviderRef[0]).flatMap { it.archiveFile } + buildApiJar.configure { + // Ensure we consider impl jar and classpath as inputs and we run when they change + dependsOn { implJarProviderRef[0] } + inputs.files(implArchiveProvider) + inputs.files(project.configurations.implRuntimeClasspath) + inputs.property('btraceExtension.services', { explicitServiceTypes().join(',') }) + inputs.property('btraceExtension.additionalExports', { extension.additionalExports.join(',') }) + inputs.property('btraceExtension.excludedExports', { extension.excludedExports.join(',') }) + doFirst { + // Compute permissions: scan impl jar and transitive classpath, then merge with overrides + def implJar = implArchiveProvider.get().asFile + Set scannedPerms = [] as Set + if (extension.scanPermissions) { + Set cp = [] as Set + try { + cp = project.configurations.implRuntimeClasspath.resolve() as Set + } catch (Throwable ignore) { } + scannedPerms = PermissionScanner.scan(implJar, cp) + } + Set mergedPerms = [] as Set + mergedPerms.addAll(scannedPerms) + mergedPerms.addAll(extension.requiredPermissions) + + // Emit concise info about permissions for traceability + if (extension.scanPermissions) { + project.logger.lifecycle("[BTRACE-EXT] permissions: scanned=${scannedPerms} merged=${mergedPerms}") + } else { + project.logger.lifecycle("[BTRACE-EXT] permissions: merged=${mergedPerms} (scan disabled)") + } + + // Cross-check: ensure manifest permissions cover descriptor-declared requirements + try { + def cp = new LinkedHashSet() + cp.addAll(authoredClassesDirs()) + try { cp.addAll(authoredCompileClasspath()) } catch (Throwable ignore) {} + URLClassLoader cl = new URLClassLoader(cp.collect { it.toURI().toURL() } as URL[], (ClassLoader) null) + def enumConstName = { Object enumConst -> + if (enumConst instanceof List && enumConst.size() >= 2) { + return String.valueOf(enumConst[1]).toUpperCase(Locale.ROOT) + } + return null + } + Set annotatedPerms = [] as Set + explicitServiceTypes().each { String fqcn -> + try { + def res = fqcn.replace('.', '/') + '.class' + def is = cl.getResourceAsStream(res) + if (is == null) return + def cr = new ClassReader(is) + def cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + (cn.visibleAnnotations ?: []).each { an -> + if (an.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') { + def vals = an.values ?: [] + for (int i = 0; i < vals.size(); i += 2) { + if (vals[i] == 'permissions') { + def arr = vals[i+1] as List + arr?.each { ev -> + def n = enumConstName(ev) + if (n != null) annotatedPerms.add(n) + } + } + } + } + } + (cn.invisibleAnnotations ?: []).each { an -> + if (an.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') { + def vals = an.values ?: [] + for (int i = 0; i < vals.size(); i += 2) { + if (vals[i] == 'permissions') { + def arr = vals[i+1] as List + arr?.each { ev -> + def n = enumConstName(ev) + if (n != null) annotatedPerms.add(n) + } + } + } + } + } + } catch (Throwable ignore) { } + } + // Also include package-level ExtensionDescriptor.permissions() + authoredClassesDirs().each { File dir -> + if (!dir.exists()) return + dir.eachFileRecurse { f -> + if (!f.name.equals('package-info.class')) return + FileInputStream is2 = new FileInputStream(f) + byte[] bytes2 + try { bytes2 = is2.bytes } finally { try { is2.close() } catch (Throwable ignore) {} } + def cr2 = new ClassReader(bytes2) + def cn2 = new ClassNode(); cr2.accept(cn2, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + (cn2.visibleAnnotations ?: []).each { an -> + if (an.desc == 'Lorg/openjdk/btrace/core/extensions/ExtensionDescriptor;') { + def vals = an.values ?: [] + for (int i = 0; i < vals.size(); i += 2) { + if (vals[i] == 'permissions') { + def arr = vals[i+1] as List + arr?.each { ev -> + def n = enumConstName(ev) + if (n != null) annotatedPerms.add(n) + } + } + } + } + } + (cn2.invisibleAnnotations ?: []).each { an -> + if (an.desc == 'Lorg/openjdk/btrace/core/extensions/ExtensionDescriptor;') { + def vals = an.values ?: [] + for (int i = 0; i < vals.size(); i += 2) { + if (vals[i] == 'permissions') { + def arr = vals[i+1] as List + arr?.each { ev -> + def n = enumConstName(ev) + if (n != null) annotatedPerms.add(n) + } + } + } + } + } + } + } + Set manifestPerms = mergedPerms.collect { it.toString().toUpperCase(Locale.ROOT) } as Set + Set missing = annotatedPerms.findAll { !manifestPerms.contains(it) } as Set + if (!missing.isEmpty()) { + throw new GradleException("[BTRACE-EXT] Manifest permissions missing annotated requirements: ${missing}. Fix: enable scanPermissions or add to requiredPermissions.") + } + } catch (GradleException ge) { + throw ge + } catch (Throwable t) { + project.logger.warn("[BTRACE-EXT] permission alignment check failed to run: ${t.message}") + } + + def shadedPkgs = extension.shadedPackages.collect { k, v -> "$k->$v" }.join(',') + def servicesStr = extension.services.join(',') + def requiresStr = extension.requiresExtensions.join(',') + def permsStr = mergedPerms.join(',') + + manifest { + attributes( + 'BTrace-Extension-Id': extension.id, + 'BTrace-Extension-Version': extension.version, + 'BTrace-Extension-Name': extension.name, + 'BTrace-Extension-Description': extension.description, + 'BTrace-API-Version': '2.3+', + 'BTrace-Java-Version': '8+', + 'BTrace-Extension-Services': { + if (servicesStr && !servicesStr.isEmpty()) return servicesStr + // If not explicitly configured, detect services via @ServiceDescriptor in API output + return explicitServiceTypes().join(',') + }.call(), + 'BTrace-Extension-Requires': requiresStr, + 'BTrace-Shaded-Packages': shadedPkgs, + 'BTrace-Extension-Impl': "${project.name}-${extension.version}-impl.jar", + 'BTrace-Extension-Permissions': permsStr, + // Read exports index (if present) and add a short summary attribute + 'BTrace-Extension-Exports': { + try { + def idxFile = new File(project.buildDir, 'generated/resources/btraceExports/META-INF/btrace/exports.index') + List lines = [] + if (idxFile.exists()) { + lines = idxFile.readLines('UTF-8') + } else { + lines = extension.services as List + } + int limit = 20 + def head = lines.take(limit) + def extra = Math.max(0, lines.size() - limit) + return head.join(',') + (extra > 0 ? ", +${extra} more" : '') + } catch (Throwable ignore) { + return servicesStr + } + }.call() + ) + } + } + } + } + + // Generate shims Java sources for API interfaces + def shimsSrcDir = new File(project.buildDir, 'generated/sources/btraceShims/api') + def shimsClsDir = new File(project.buildDir, 'generated/classes/btraceShims/api') + def shimsResDir = new File(project.buildDir, 'generated/resources/btraceShims') + + def generateServiceShims = project.tasks.register('generateServiceShims') { + dependsOn(authoredCompileTask) + doLast { + shimsSrcDir.mkdirs() + // Build ClassLoader over API outputs to reflect methods + def cp = new LinkedHashSet() + cp.addAll(authoredClassesDirs()) + try { cp.addAll(authoredCompileClasspath()) } catch (Throwable ignore) {} + URLClassLoader cl = new URLClassLoader(cp.collect { it.toURI().toURL() } as URL[], (ClassLoader) null) + // Discover ALL API interfaces in the api output + def apiInterfaces = new LinkedHashSet() + authoredClassesDirs().each { File dir -> + if (!dir.exists()) return + dir.eachFileRecurse { f -> + if (f.name.endsWith('.class')) { + def rel = dir.toPath().relativize(f.toPath()).toString() + def fq = rel.replace(File.separatorChar, (char)'.').replaceAll(/\.class$/, '') + if (!isExportedApiType(fq)) return + // Use ASM to filter interfaces (skip annotations) + def is = new FileInputStream(f) + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + int acc = cr.access + boolean isInterface = (acc & Opcodes.ACC_INTERFACE) != 0 + boolean isAnnotation = (acc & Opcodes.ACC_ANNOTATION) != 0 + if (isInterface && !isAnnotation) { + apiInterfaces.add(fq) + } + } + } + } + if (apiInterfaces.isEmpty()) { + project.logger.warn('[BTRACE-EXT] No API interfaces found; skipping shim generation') + return + } + // Optionally restrict to interfaces reachable from services via descriptors + generics + def targetInterfaces = new LinkedHashSet() + if (extension.generateShimsReachableOnly) { + def services = explicitServiceTypes() ?: [] + // BFS closure over referenced API interface types + def visited = new HashSet() + def queue = new ArrayDeque(services) + while (!queue.isEmpty()) { + def cur = queue.removeFirst() + if (cur == null || visited.contains(cur)) continue + visited.add(cur) + if (apiInterfaces.contains(cur)) targetInterfaces.add(cur) + try { + def res = cur.replace('.', '/') + '.class' + def is = cl.getResourceAsStream(res) + if (is == null) continue + byte[] bytes; try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode(); cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + def addType = { String fq -> if (fq!=null && apiInterfaces.contains(fq) && !visited.contains(fq)) queue.addLast(fq) } + // class generics + if (cn.signature != null) { + try { + new SignatureReader(cn.signature).accept(new SignatureVisitor(Opcodes.ASM9){ + void visitClassType(String name){ addType(name?.replace('/', '.')) } + void visitInnerClassType(String name){ addType(name?.replace('/', '.')) } + SignatureVisitor visitSuperclass(){ return this } + SignatureVisitor visitInterface(){ return this } + SignatureVisitor visitTypeArgument(char w){ return this } + SignatureVisitor visitClassBound(){ return this } + SignatureVisitor visitInterfaceBound(){ return this } + }) + } catch(Throwable ignore){} + } + // method descriptors + generics + cn.methods?.each { MethodNode mn -> + def mt = Type.getMethodType(mn.desc) + [mt.returnType].each { t -> if (t.sort==Type.OBJECT) addType(t.className) } + mt.argumentTypes?.each { t -> if (t.sort==Type.OBJECT) addType(t.className) } + if (mn.signature != null) { + try { + new SignatureReader(mn.signature).accept(new SignatureVisitor(Opcodes.ASM9){ + void visitClassType(String name){ addType(name?.replace('/', '.')) } + void visitInnerClassType(String name){ addType(name?.replace('/', '.')) } + SignatureVisitor visitParameterType(){ return this } + SignatureVisitor visitReturnType(){ return this } + SignatureVisitor visitExceptionType(){ return this } + SignatureVisitor visitArrayType(){ return this } + SignatureVisitor visitTypeArgument(char w){ return this } + }) + } catch(Throwable ignore){} + } + } + } catch (Throwable ignore) {} + } + } else { + targetInterfaces.addAll(apiInterfaces) + } + + // Generate shims for selected API interfaces + targetInterfaces.each { String fqcn -> + try { + Class c = Class.forName(fqcn, false, cl) + if (!c.isInterface()) return + def pkg = c.package?.name ?: '' + def simple = c.simpleName + def shimPkg = (pkg ? pkg + '.btrace.shim' : 'btrace.shim') + def dir = new File(shimsSrcDir, shimPkg.replace('.', '/')) + dir.mkdirs() + def noopName = "NoOp${simple}" + def throwName = "Throwing${simple}" + def methods = c.getMethods().findAll { it.declaringClass == c } + // Emit NoOp + new File(dir, noopName + '.java').withWriter('UTF-8') { w -> + w.println("package ${shimPkg};") + w.println() + w.println("public final class ${noopName} implements ${fqcn} {") + w.println(" public static final ${fqcn} INSTANCE = new ${noopName}();") + methods.each { m -> + def ret = m.returnType + def params = [] + m.parameterTypes.eachWithIndex { pt, idx -> params << (pt.name + " p" + idx) } + w.println(" public ${ret.name} ${m.name}(${params.join(', ')}) {") + if (ret == Void.TYPE) { + w.println(" return;") + } else if (ret.isPrimitive()) { + if (ret == Boolean.TYPE) w.println(" return false;") + else if (ret == Character.TYPE) w.println(" return (char)0;") + else if (ret == Byte.TYPE) w.println(" return (byte)0;") + else if (ret == Short.TYPE) w.println(" return (short)0;") + else if (ret == Integer.TYPE) w.println(" return 0;") + else if (ret == Long.TYPE) w.println(" return 0L;") + else if (ret == Float.TYPE) w.println(" return 0f;") + else if (ret == Double.TYPE) w.println(" return 0d;") + } else if (ret.isArray() && ret.componentType.isInterface() && apiInterfaces.contains(ret.componentType.name)) { + // Return empty array of API interface type + w.println(" return new ${ret.componentType.name}[0];") + } else if (ret.isInterface() && apiInterfaces.contains(ret.name)) { + // Return nested shim INSTANCE (or this if fluent self-return) + if (ret.name == fqcn) { + w.println(" return this;") + } else { + def retSimple = ret.simpleName + def retShimFqcn = (ret.package?.name ? ret.package.name + '.btrace.shim.NoOp' + retSimple : 'btrace.shim.NoOp' + retSimple) + w.println(" return ${retShimFqcn}.INSTANCE;") + } + } else if (m.genericReturnType instanceof java.lang.reflect.ParameterizedType) { + def pt = (java.lang.reflect.ParameterizedType) m.genericReturnType + def raw = (pt.rawType instanceof Class) ? (Class) pt.rawType : null + if (raw != null) { + def rawName = raw.name + if (rawName == 'java.util.List' || rawName == 'java.util.Collection' || rawName == 'java.lang.Iterable') { + w.println(" return java.util.Collections.emptyList();") + } else if (rawName == 'java.util.Set') { + w.println(" return java.util.Collections.emptySet();") + } else if (rawName == 'java.util.Queue' || rawName == 'java.util.Deque') { + w.println(" return new java.util.ArrayDeque<>();") + } else if (rawName == 'java.util.Map') { + w.println(" return java.util.Collections.emptyMap();") + } else if (rawName == 'java.util.Optional') { + w.println(" return java.util.Optional.empty();") + } else if (rawName == 'java.util.stream.Stream') { + w.println(" return java.util.stream.Stream.empty();") + } else if (rawName == 'java.util.stream.IntStream') { + w.println(" return java.util.stream.IntStream.empty();") + } else if (rawName == 'java.util.stream.LongStream') { + w.println(" return java.util.stream.LongStream.empty();") + } else if (rawName == 'java.util.stream.DoubleStream') { + w.println(" return java.util.stream.DoubleStream.empty();") + } else { + w.println(" return null;") + } + } + } else { + w.println(" return null;") + } + w.println(" }") + } + // equals/hashCode/toString + w.println(" public boolean equals(Object o) { return this == o; }") + w.println(" public int hashCode() { return System.identityHashCode(this); }") + w.println(" public String toString() { return \"NoOp${simple}\"; }") + w.println("}") + } + // Emit Throwing + new File(dir, throwName + '.java').withWriter('UTF-8') { w -> + w.println("package ${shimPkg};") + w.println() + w.println("public final class ${throwName} implements ${fqcn} {") + w.println(" public static final ${fqcn} INSTANCE = new ${throwName}();") + w.println(" private static RuntimeException unavailable() { return new IllegalStateException(\"BTrace optional service unavailable: ${fqcn}\"); }") + methods.each { m -> + def ret = m.returnType + def params = [] + m.parameterTypes.eachWithIndex { pt, idx -> params << (pt.name + " p" + idx) } + w.println(" public ${ret.name} ${m.name}(${params.join(', ')}) {") + w.println(" throw unavailable();") + w.println(" }") + } + // equals/hashCode/toString + w.println(" public boolean equals(Object o) { return this == o; }") + w.println(" public int hashCode() { return System.identityHashCode(this); }") + w.println(" public String toString() { return \"Throwing${simple}\"; }") + w.println("}") + } + } catch (Throwable t) { + project.logger.warn("[BTRACE-EXT] Skipping shim generation for ${fqcn}: ${t.message}") + } + } + } + } + + def compileServiceShims = project.tasks.register('compileServiceShims', JavaCompile) { t -> + dependsOn generateServiceShims + source = project.fileTree(shimsSrcDir) + destinationDirectory.set(shimsClsDir) + classpath = project.files(authoredClassesDirs(), authoredCompileClasspath()) + options.release = 8 + } + + def generateShimIndex = project.tasks.register('generateShimIndex') { + dependsOn generateServiceShims + doLast { + // Recompute the same target set as generateServiceShims (respect generateShimsReachableOnly) + def apiInterfaces = new LinkedHashSet() + authoredClassesDirs().each { File dir -> + if (!dir.exists()) return + dir.eachFileRecurse { f -> + if (f.name.endsWith('.class')) { + def rel = dir.toPath().relativize(f.toPath()).toString() + def fq = rel.replace(File.separatorChar, (char)'.').replaceAll(/\.class$/, '') + if (!isExportedApiType(fq)) return + def is = new FileInputStream(f) + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + int acc = cr.access + boolean isInterface = (acc & Opcodes.ACC_INTERFACE) != 0 + boolean isAnnotation = (acc & Opcodes.ACC_ANNOTATION) != 0 + if (isInterface && !isAnnotation) apiInterfaces.add(fq) + } + } + } + if (apiInterfaces.isEmpty()) return + def cp = new LinkedHashSet() + cp.addAll(authoredClassesDirs()) + try { cp.addAll(authoredCompileClasspath()) } catch (Throwable ignore) {} + URLClassLoader cl = new URLClassLoader(cp.collect { it.toURI().toURL() } as URL[], (ClassLoader) null) + def targetInterfaces = new LinkedHashSet() + if (extension.generateShimsReachableOnly) { + def services = explicitServiceTypes() ?: [] + if (services.isEmpty()) { + // fall back to detected annotated services + authoredClassesDirs().each { File dir -> + if (!dir.exists()) return + dir.eachFileRecurse { f -> + if (!f.name.endsWith('.class')) return + def rel = dir.toPath().relativize(f.toPath()).toString() + def fq = rel.replace(File.separatorChar, (char)'.').replaceAll(/\.class$/, '') + FileInputStream is = new FileInputStream(f) + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode(); cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + boolean isInterface = (cn.access & Opcodes.ACC_INTERFACE) != 0 + boolean hasMarker = false + (cn.visibleAnnotations ?: []).each { hasMarker |= (it.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') } + (cn.invisibleAnnotations ?: []).each { hasMarker |= (it.desc == 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;') } + if (hasMarker && isInterface) services.add(fq) + } + } + } + def visited = new HashSet() + def queue = new ArrayDeque(services) + while (!queue.isEmpty()) { + def cur = queue.removeFirst() + if (cur == null || visited.contains(cur)) continue + visited.add(cur) + if (apiInterfaces.contains(cur)) targetInterfaces.add(cur) + try { + def res = cur.replace('.', '/') + '.class' + def is = cl.getResourceAsStream(res) + if (is == null) continue + byte[] bytes; try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode(); cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + def addType = { String fq -> if (fq!=null && apiInterfaces.contains(fq) && !visited.contains(fq)) queue.addLast(fq) } + if (cn.signature != null) { + try { new SignatureReader(cn.signature).accept(new SignatureVisitor(Opcodes.ASM9){ + void visitClassType(String name){ addType(name?.replace('/', '.')) } + void visitInnerClassType(String name){ addType(name?.replace('/', '.')) } + SignatureVisitor visitSuperclass(){ return this } + SignatureVisitor visitInterface(){ return this } + SignatureVisitor visitTypeArgument(char w){ return this } + SignatureVisitor visitClassBound(){ return this } + SignatureVisitor visitInterfaceBound(){ return this } + }) } catch(Throwable ignore){} + } + cn.methods?.each { MethodNode mn -> + def mt = Type.getMethodType(mn.desc) + [mt.returnType].each { t -> if (t.sort==Type.OBJECT) addType(t.className) } + mt.argumentTypes?.each { t -> if (t.sort==Type.OBJECT) addType(t.className) } + if (mn.signature != null) { + try { new SignatureReader(mn.signature).accept(new SignatureVisitor(Opcodes.ASM9){ + void visitClassType(String name){ addType(name?.replace('/', '.')) } + void visitInnerClassType(String name){ addType(name?.replace('/', '.')) } + SignatureVisitor visitParameterType(){ return this } + SignatureVisitor visitReturnType(){ return this } + SignatureVisitor visitExceptionType(){ return this } + SignatureVisitor visitArrayType(){ return this } + SignatureVisitor visitTypeArgument(char w){ return this } + }) } catch(Throwable ignore){} + } + } + } catch (Throwable ignore) {} + } + } else { + targetInterfaces.addAll(apiInterfaces) + } + def idxFile = new File(shimsResDir, 'META-INF/btrace/shims.index') + idxFile.parentFile.mkdirs() + idxFile.withWriter('UTF-8') { w -> + targetInterfaces.each { String fqcn -> + def pkg = fqcn.contains('.') ? fqcn.substring(0, fqcn.lastIndexOf('.')) : '' + def simple = fqcn.substring(fqcn.lastIndexOf('.')+1) + def shimPkg = (pkg ? pkg + '.btrace.shim' : 'btrace.shim') + def noop = shimPkg + '.NoOp' + simple + def thrw = shimPkg + '.Throwing' + simple + w.println("${fqcn} = ${noop}, ${thrw}") + } + } + } + } + + // Exports index: collect all API types referenced in service method signatures (return and params) + def exportsResDir = new File(project.buildDir, 'generated/resources/btraceExports') + def generateExportsIndex = project.tasks.register('generateExportsIndex') { + dependsOn(authoredCompileTask) + doLast { + def services = explicitServiceTypes() + if (!services || services.isEmpty()) return + def cp = new LinkedHashSet() + cp.addAll(authoredClassesDirs()) + try { cp.addAll(authoredCompileClasspath()) } catch (Throwable ignore) {} + URLClassLoader cl = new URLClassLoader(cp.collect { it.toURI().toURL() } as URL[], (ClassLoader) null) + + // Collect known API/impl class names to validate placement + def apiClassNames = new HashSet(apiTypes()) + def implClassNames = new HashSet(implTypes()) + + def exports = new LinkedHashSet() + services.each { String fqcn -> + try { + exports.add(fqcn) + def res = fqcn.replace('.', '/') + '.class' + def is = cl.getResourceAsStream(res) + if (is == null) return + byte[] bytes + try { bytes = is.bytes } finally { try { is.close() } catch (Throwable ignore) {} } + def cr = new ClassReader(bytes) + def cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + // Class-level generic signature: capture bounds/supertypes/interface types + if (cn.signature != null) { + try { + def collector = new SignatureVisitor(Opcodes.ASM9) { + @Override + void visitClassType(String name) { addType(name?.replace('/', '.')) } + @Override + void visitInnerClassType(String name) { addType(name?.replace('/', '.')) } + @Override + SignatureVisitor visitSuperclass() { return this } + @Override + SignatureVisitor visitInterface() { return this } + @Override + SignatureVisitor visitTypeArgument(char wildcard) { return this } + @Override + SignatureVisitor visitClassBound() { return this } + @Override + SignatureVisitor visitInterfaceBound() { return this } + } + new SignatureReader(cn.signature).accept(collector) + } catch (Throwable ignored) { } + } + // Helper to add a referenced type found in signatures + def addType = { String fq -> + if (fq == null) return + if (fq.startsWith('java.') || fq.startsWith('javax.') || fq.startsWith('jakarta.')) return + if (apiClassNames.contains(fq)) { + exports.add(fq) + } else if (implClassNames.contains(fq)) { + throw new GradleException("[BTRACE-EXT] API method references implementation type '${fq}'. Fix: move type to API module so probes can use it.") + } + } + + cn.methods?.each { MethodNode mn -> + def mt = Type.getMethodType(mn.desc) + def all = [] as List + all << mt.returnType + all.addAll(mt.argumentTypes.toList()) + all.each { Type t -> + def fq = null + if (t.getSort() == Type.OBJECT) { + fq = t.getClassName() + } else if (t.getSort() == Type.ARRAY && t.getElementType().getSort() == Type.OBJECT) { + fq = t.getElementType().getClassName() + } + addType(fq) + } + // Parse generic signature to capture type arguments + if (mn.signature != null) { + try { + def collector = new SignatureVisitor(Opcodes.ASM9) { + @Override + SignatureVisitor visitParameterType() { return this } + @Override + SignatureVisitor visitReturnType() { return this } + @Override + SignatureVisitor visitExceptionType() { return this } + @Override + SignatureVisitor visitArrayType() { return this } + @Override + void visitClassType(String name) { addType(name?.replace('/', '.')) } + @Override + void visitInnerClassType(String name) { addType(name?.replace('/', '.')) } + @Override + void visitTypeVariable(String name) { } + @Override + void visitBaseType(char descriptor) { } + @Override + SignatureVisitor visitTypeArgument(char wildcard) { return this } + } + new SignatureReader(mn.signature).accept(collector) + } catch (Throwable ignored) { } + } + } + } catch (GradleException ge) { + throw ge + } catch (Throwable t) { + project.logger.warn("[BTRACE-EXT] export scan skipped for ${fqcn}: ${t.message}") + } + } + + if (!exports.isEmpty()) { + def idxFile = new File(exportsResDir, 'META-INF/btrace/exports.index') + idxFile.parentFile.mkdirs() + idxFile.withWriter('UTF-8') { w -> + exports.each { w.println(it) } + } + project.logger.lifecycle("[BTRACE-EXT] exports: ${exports.size()} types") + } + } + } + def packageExtension = project.tasks.register('packageExtension', Zip) { + dependsOn buildApiJar, buildImplJar, compileServiceShims, generateShimIndex, generateExportsIndex, validateServiceApis + archiveBaseName = project.name + archiveClassifier = 'extension' + + from(buildApiJar.map { it.archiveFile }) + from(((org.gradle.api.tasks.TaskProvider) implJarProviderRef[0]).flatMap { it.archiveFile }) + } + + // Disable default jar task (use packageExtension instead) + project.tasks.named('jar') { + enabled = false + } + + // Configure artifacts for consumption + project.configurations { + apiElements.outgoing.artifacts.clear() + apiElements.outgoing.artifact(buildApiJar) + + runtimeElements.outgoing.artifacts.clear() + runtimeElements.outgoing.artifact(buildApiJar) + runtimeElements.outgoing.artifact(packageExtension) + } + + // Make extension ZIP the default archive artifact + project.artifacts { archives packageExtension } + + // Include shims classes and index in API JAR + buildApiJar.configure { + dependsOn compileServiceShims, generateShimIndex, generateExportsIndex + from(shimsClsDir) + from(shimsResDir) + from(exportsResDir) + } + + // Aux tasks: API sources and javadoc jars + def apiSourcesJar = project.tasks.register('apiSourcesJar', Jar) { + dependsOn(authoredCompileTask) + archiveBaseName = project.name + archiveClassifier = 'api-sources' + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + from({ apiSourceTree() }) + from(project.sourceSets.main.resources) + } + def apiJavadoc = project.tasks.register('apiJavadoc', Javadoc) { + dependsOn(authoredCompileTask) + source = project.files({ apiSourceTree() }) + classpath = project.files(authoredClassesDirs(), authoredCompileClasspath()) + destinationDir = new File(project.buildDir, 'docs/api') + options.encoding = 'UTF-8' + } + def apiJavadocJar = project.tasks.register('apiJavadocJar', Jar) { + dependsOn apiJavadoc + archiveBaseName = project.name + archiveClassifier = 'api-javadoc' + from apiJavadoc.map { it.destinationDir } + } + + // Configure publishing if maven-publish is present + if (project.plugins.hasPlugin('maven-publish')) { + project.publishing { + publications { + mavenExtension(org.gradle.api.publish.maven.MavenPublication) { + groupId = project.group as String + artifactId = project.name + version = project.version as String + + artifact(buildApiJar) { classifier = 'api' } + artifact(apiSourcesJar) + artifact(apiJavadocJar) + artifact(packageExtension) { classifier = 'extension' } + + pom { + name = project.provider { extension.name } + description = project.provider { extension.description } + } + } + } + } + } + + // Tests can see both api and impl outputs + project.afterEvaluate { + project.dependencies { + testImplementation project.sourceSets.main.output + } + // Fail build on validation errors via check lifecycle + project.tasks.matching { it.name == 'check' }.configureEach { it.dependsOn validateServiceApis } + } + } + +} + +class BTraceExtensionMetadata { + String id + String version + String name + String description + List services = [] + List additionalExports = [] + List excludedExports = [] + List requiresExtensions = [] + Map shadedPackages = [:] + // Whether to auto-apply the Shadow plugin. Default: true + boolean autoApplyShadow = true + boolean scanPermissions = true + List requiredPermissions = [] + // Configurable nullability annotations (FQCN). Defaults cover javax/jspecify/jetbrains/jakarta + List nullableAnnotations = [] + List nonnullAnnotations = [] + // Validation severity knobs + // nullabilitySeverity: 'off' | 'warn' | 'error' (default: 'warn') + String nullabilitySeverity = 'warn' + // shimabilitySeverity: 'warn' | 'error' (default: 'error') + String shimabilitySeverity = 'error' + // apiCtorSeverity: 'off' | 'warn' | 'error' (default: 'error') + String apiCtorSeverity = 'error' + // Generate shims only for interfaces reachable from declared services (via signatures + generics) + // Set to false to generate shims for all API interfaces. + boolean generateShimsReachableOnly = true +} diff --git a/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceFatAgentExtension.groovy b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceFatAgentExtension.groovy new file mode 100644 index 000000000..1a06306da --- /dev/null +++ b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceFatAgentExtension.groovy @@ -0,0 +1,492 @@ +package io.btrace.gradle + +import org.gradle.api.Action +import org.gradle.api.Project +import org.gradle.api.file.FileCollection + +/** + * DSL extension for configuring fat agent JAR builds. + * + *

Usage: + *

+ * btraceFatAgent {
+ *     baseName = 'my-btrace-agent'
+ *
+ *     embedExtensions {
+ *         project(':btrace-spark')
+ *         maven('io.btrace:btrace-kafka:2.3.0')
+ *         file('/path/to/extension.zip')
+ *     }
+ *
+ *     bundledProbes {
+ *         from 'src/probes'
+ *     }
+ * }
+ *

+ */ +class BTraceFatAgentExtension { + static final String DEFAULT_REGISTRY_URL = 'https://btraceio.github.io/btrace-extensions/registry/extensions.json' + + private final Project project + private final List extensionSources = [] + private final ProbeBundleSpec probeBundle + + /** Output JAR base name (default: 'btrace-agent-fat') */ + String baseName = 'btrace-agent-fat' + + /** Output directory (default: project.layout.buildDirectory.dir('libs')) */ + File outputDir + + /** Additional manifest attributes */ + Map manifestAttributes = [:] + + /** Package relocations (from -> to) */ + Map relocations = [:] + + /** Reference to agent JAR task (required for standalone builds) */ + Object agentJarTask + + /** Reference to boot JAR task (required for standalone builds) */ + Object bootJarTask + + /** Whether to auto-discover extensions from subprojects (default: false) */ + boolean autoDiscover = false + + /** Property name for filtering extensions when autoDiscover is true */ + String filterProperty = 'embedExtensions' + + /** Extension registry URL for resolving registry("id") sources. */ + String registryUrl = System.getProperty('btrace.extensions.registry', DEFAULT_REGISTRY_URL) + + /** Local cache file for the extension registry document. */ + File registryCacheFile + + BTraceFatAgentExtension(Project project) { + this.project = project + this.outputDir = project.layout.buildDirectory.dir('libs').get().asFile + this.registryCacheFile = project.layout.buildDirectory.file('registry/extensions.json').get().asFile + this.probeBundle = new ProbeBundleSpec(project) + } + + /** + * Configure embedded extensions. + */ + void embedExtensions(Action action) { + def spec = new ExtensionSourceSpec(project, this) + action.execute(spec) + extensionSources.addAll(spec.sources) + } + + /** + * Configure bundled probes. + */ + void bundledProbes(Action action) { + action.execute(probeBundle) + } + + /** + * Configure manifest attributes. + */ + void manifest(Action action) { + def spec = new ManifestSpec() + action.execute(spec) + manifestAttributes.putAll(spec.attributes) + } + + /** + * Add a package relocation. + */ + void relocate(String from, String to) { + relocations[from] = to + } + + /** + * Get all configured extension sources. + */ + List getExtensionSources() { + return new ArrayList<>(extensionSources) + } + + /** + * Add an extension source directly to the internal list. + * Used by auto-discovery to add sources after configuration. + */ + void addExtensionSource(ExtensionSource source) { + extensionSources.add(source) + } + + /** + * Get probe bundle configuration. + */ + ProbeBundleSpec getProbeBundle() { + return probeBundle + } +} + +/** + * DSL spec for configuring extension sources. + */ +class ExtensionSourceSpec { + private final Project project + private final BTraceFatAgentExtension owner + final List sources = [] + + ExtensionSourceSpec(Project project, BTraceFatAgentExtension owner) { + this.project = project + this.owner = owner + } + + /** + * Add extension from a project reference. + */ + void project(String projectPath) { + sources << new ProjectExtensionSource(project, projectPath) + } + + /** + * Add extensions from multiple project references. + */ + void projects(String... projectPaths) { + projectPaths.each { path -> + sources << new ProjectExtensionSource(project, path) + } + } + + /** + * Add extension from Maven coordinates. + * @param coords Maven coordinates in format 'group:artifact:version' + */ + void maven(String coords) { + sources << new MavenExtensionSource(project, coords) + } + + /** + * Add extension from Maven coordinates with named parameters. + */ + void maven(Map coords) { + def coordStr = "${coords.group}:${coords.name}:${coords.version}" + sources << new MavenExtensionSource(project, coordStr) + } + + /** + * Add extension from a local file. + */ + void file(String path) { + sources << new FileExtensionSource(project, project.file(path)) + } + + /** + * Add extension from a local file. + */ + void file(File file) { + sources << new FileExtensionSource(project, file) + } + + /** + * Add extensions from multiple files matching a pattern. + */ + void files(String pattern) { + project.fileTree(dir: project.projectDir, includes: [pattern]).files.each { f -> + sources << new FileExtensionSource(project, f) + } + } +} + +/** + * DSL spec for configuring bundled probes. + */ +class ProbeBundleSpec { + private final Project project + final List probeDirs = [] + final List sourceRoots = [] + final List includes = [] + final List excludes = [] + + ProbeBundleSpec(Project project) { + this.project = project + } + + /** + * Add pre-compiled probe classes from a directory. + */ + void from(String path) { + probeDirs << project.file(path) + } + + /** + * Add pre-compiled probe classes from a directory. + */ + void from(File dir) { + probeDirs << dir + } + + /** + * Add probe sources to compile. + */ + void fromSource(String path) { + sourceRoots << project.file(path) + } + + /** + * Add probe sources to compile. + */ + void fromSource(File dir) { + sourceRoots << dir + } + + /** + * Include only specific probe classes by simple name. + */ + void include(String... probeNames) { + includes.addAll(probeNames) + } + + /** + * Exclude specific probe classes by simple name. + */ + void exclude(String... probeNames) { + excludes.addAll(probeNames) + } + + boolean hasProbes() { + return !probeDirs.isEmpty() || !sourceRoots.isEmpty() + } + + boolean hasSourceProbes() { + return !sourceRoots.isEmpty() + } +} + +/** + * DSL spec for manifest configuration. + */ +class ManifestSpec { + final Map attributes = [:] + + void attributes(Map attrs) { + attributes.putAll(attrs) + } +} + +/** + * Base class for extension sources. + */ +abstract class ExtensionSource { + protected final Project project + + ExtensionSource(Project project) { + this.project = project + } + + /** + * Resolve this source to a concrete extension descriptor. + */ + abstract ResolvedExtension resolve() +} + +/** + * Extension source from a project reference. + */ +class ProjectExtensionSource extends ExtensionSource { + final String projectPath + + ProjectExtensionSource(Project project, String projectPath) { + super(project) + this.projectPath = projectPath + } + + @Override + ResolvedExtension resolve() { + def extProject = project.project(projectPath) + + // Check if the project has the BTrace extension plugin + if (!extProject.plugins.hasPlugin('io.btrace.extension')) { + throw new IllegalStateException( + "Project '${projectPath}' does not have the 'io.btrace.extension' plugin applied") + } + + def buildApiJar = extProject.tasks.findByName('buildApiJar') + def shadowJar = extProject.tasks.findByName('shadowJar') + + if (buildApiJar == null || shadowJar == null) { + throw new IllegalStateException( + "Project '${projectPath}' is missing required tasks (buildApiJar, shadowJar)") + } + + def ext = extProject.extensions.findByType(BTraceExtensionMetadata) + def extId = ext?.id ?: extProject.name + + return new ResolvedExtension( + id: extId, + version: extProject.version?.toString() ?: '0.0.0', + apiJar: buildApiJar.archiveFile.get().asFile, + implJar: shadowJar.archiveFile.get().asFile, + sourceProject: extProject + ) + } + + @Override + String toString() { + return "project(${projectPath})" + } +} + +/** + * Extension source from Maven coordinates. + */ +class MavenExtensionSource extends ExtensionSource { + final String coordinates + + MavenExtensionSource(Project project, String coordinates) { + super(project) + this.coordinates = coordinates + } + + @Override + ResolvedExtension resolve() { + // Create a detached configuration to resolve the extension + def config = project.configurations.detachedConfiguration( + project.dependencies.create(coordinates) + ) + config.transitive = false + + def files = config.resolve() + if (files.isEmpty()) { + throw new IllegalStateException("Could not resolve extension: ${coordinates}") + } + + def extensionZip = files.first() + + // Extract extension metadata from ZIP + return extractFromZip(extensionZip) + } + + private ResolvedExtension extractFromZip(File zipFile) { + def tempDir = project.layout.buildDirectory + .dir("fat-agent-staging/maven/${coordinates.replace(':', '_')}") + .get() + .asFile + tempDir.mkdirs() + + // Extract ZIP + project.copy { + from project.zipTree(zipFile) + into tempDir + } + + // Find API and impl JARs + def apiJar = tempDir.listFiles()?.find { it.name.endsWith('-api.jar') } + def implJar = tempDir.listFiles()?.find { it.name.endsWith('-impl.jar') || it.name.endsWith('.jar') && !it.name.endsWith('-api.jar') } + + // Read metadata + def propsFile = new File(tempDir, 'extension.properties') + def props = new Properties() + if (propsFile.exists()) { + propsFile.withInputStream { props.load(it) } + } + + def parts = coordinates.split(':') + def extId = props.getProperty('id') ?: parts[1] + def extVersion = props.getProperty('version') ?: (parts.length > 2 ? parts[2] : '0.0.0') + + return new ResolvedExtension( + id: extId, + version: extVersion, + apiJar: apiJar, + implJar: implJar, + metadata: props + ) + } + + @Override + String toString() { + return "maven(${coordinates})" + } +} + +/** + * Extension source from a local file. + */ +class FileExtensionSource extends ExtensionSource { + final File file + + FileExtensionSource(Project project, File file) { + super(project) + this.file = file + } + + @Override + ResolvedExtension resolve() { + if (!file.exists()) { + throw new IllegalStateException("Extension file does not exist: ${file}") + } + + if (file.name.endsWith('.zip')) { + return extractFromZip(file) + } else if (file.isDirectory()) { + return extractFromDirectory(file) + } else { + throw new IllegalStateException("Unsupported extension file type: ${file}") + } + } + + private ResolvedExtension extractFromZip(File zipFile) { + def tempDir = project.layout.buildDirectory + .dir("fat-agent-staging/file/${zipFile.name.replace('.zip', '')}") + .get() + .asFile + tempDir.mkdirs() + + project.copy { + from project.zipTree(zipFile) + into tempDir + } + + return extractFromDirectory(tempDir) + } + + private ResolvedExtension extractFromDirectory(File dir) { + def apiJar = dir.listFiles()?.find { it.name.endsWith('-api.jar') } + def implJar = dir.listFiles()?.find { it.name.endsWith('-impl.jar') || (it.name.endsWith('.jar') && !it.name.endsWith('-api.jar')) } + + def propsFile = new File(dir, 'extension.properties') + def props = new Properties() + if (propsFile.exists()) { + propsFile.withInputStream { props.load(it) } + } + + def extId = props.getProperty('id') ?: dir.name + def extVersion = props.getProperty('version') ?: '0.0.0' + + return new ResolvedExtension( + id: extId, + version: extVersion, + apiJar: apiJar, + implJar: implJar, + metadata: props + ) + } + + @Override + String toString() { + return "file(${file})" + } +} + +/** + * Resolved extension descriptor with all artifacts located. + */ +class ResolvedExtension { + String id + String version + File apiJar + File implJar + Properties metadata = new Properties() + Project sourceProject // non-null if from project source + List probes = [] + + @Override + String toString() { + return "ResolvedExtension{id=${id}, version=${version}, api=${apiJar?.name}, impl=${implJar?.name}}" + } +} diff --git a/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceFatAgentPlugin.groovy b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceFatAgentPlugin.groovy new file mode 100644 index 000000000..444d0b4d9 --- /dev/null +++ b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/BTraceFatAgentPlugin.groovy @@ -0,0 +1,369 @@ +package io.btrace.gradle + +import org.gradle.api.Plugin +import org.gradle.api.Project +import org.gradle.api.GradleException +import org.gradle.api.tasks.Copy +import org.gradle.api.tasks.bundling.Jar +import org.gradle.api.file.DuplicatesStrategy + +/** + * Gradle plugin for building fat agent JARs with embedded extensions. + * + *

This plugin provides a DSL to configure which extensions to embed + * and produces a self-contained agent JAR for single-JAR deployment + * scenarios (e.g., Spark, Hadoop, Kubernetes). + * + *

Usage: + *

+ * plugins {
+ *     id 'io.btrace.fat-agent'
+ * }
+ *
+ * btraceFatAgent {
+ *     embedExtensions {
+ *         project(':btrace-spark')
+ *         maven('io.btrace:btrace-kafka:2.3.0')
+ *     }
+ * }
+ *

+ * + *

Extension API classes are flattened as {@code .class} files (bootstrap), + * while impl classes are renamed to {@code .classdata} (loaded at runtime + * via {@code ClassDataLoader}). + */ +class BTraceFatAgentPlugin implements Plugin { + + @Override + void apply(Project project) { + // Apply required plugins + project.plugins.apply('java') + + // Create DSL extension + def extension = project.extensions.create('btraceFatAgent', BTraceFatAgentExtension, project) + + // Create staging directory + def stagingDir = project.layout.buildDirectory.dir('fat-agent-staging').get().asFile + + // Task: Resolve and stage extensions + def stageExtensions = project.tasks.register('stageExtensions') { + group = 'BTrace Fat Agent' + description = 'Resolves and stages extension content for fat agent JAR' + + outputs.dir(stagingDir) + + doLast { + stagingDir.deleteDir() + stagingDir.mkdirs() + + // Get extension using getByName to avoid classloader issues with findByType + def ext = project.extensions.getByName('btraceFatAgent') + project.logger.info("[fat-agent] Extension type: ${ext.class.name}") + project.logger.info("[fat-agent] Extension sources count: ${ext.extensionSources.size()}") + ext.extensionSources.each { src -> + project.logger.info("[fat-agent] Source: ${src}") + } + + def resolvedExtensions = resolveExtensionsFromExt(project, ext) + def embeddedExtIds = [] + + resolvedExtensions.each { resolved -> + embeddedExtIds << resolved.id + stageExtension(project, stagingDir, resolved) + } + + // Write embedded extensions list for manifest + def extListFile = new File(stagingDir, 'embedded-extensions.txt') + extListFile.text = embeddedExtIds.join(',') + + project.logger.lifecycle("[fat-agent] Staged ${resolvedExtensions.size()} extension(s): ${embeddedExtIds.join(', ')}") + } + } + + // Task: Stage bundled probes + def stageProbes = project.tasks.register('stageProbes') { + group = 'BTrace Fat Agent' + description = 'Stages bundled probes for fat agent JAR' + + outputs.dir(new File(stagingDir, 'probes')) + + doLast { + def probeSpec = extension.probeBundle + if (!probeSpec.hasProbes()) { + return + } + + def probesDir = new File(stagingDir, 'META-INF/btrace-probes') + probesDir.mkdirs() + + // Copy pre-compiled probes + probeSpec.probeDirs.each { dir -> + if (dir.exists()) { + project.copy { + from dir + into probesDir + include '**/*.class' + if (!probeSpec.includes.isEmpty()) { + include probeSpec.includes.collect { "${it}.class" } + } + if (!probeSpec.excludes.isEmpty()) { + exclude probeSpec.excludes.collect { "${it}.class" } + } + } + project.logger.info("[fat-agent] Staged probes from: ${dir}") + } + } + + // Compile source probes if configured + if (probeSpec.hasSourceProbes()) { + compileProbes(project, probeSpec, probesDir) + } + } + } + + // Task: Build fat agent JAR + // Try to use ShadowJar if available for package relocation support + def jarTaskClass = Jar + try { + jarTaskClass = Class.forName('com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar') + project.logger.info("[fat-agent] Using ShadowJar for fat agent build") + } catch (ClassNotFoundException e) { + project.logger.info("[fat-agent] ShadowJar not available, using standard Jar") + } + + def fatAgentJar = project.tasks.register('fatAgentJar', jarTaskClass) { + group = 'BTrace Fat Agent' + description = 'Creates fat agent JAR with embedded extensions' + + dependsOn stageExtensions, stageProbes + + archiveBaseName.set(extension.baseName) + archiveVersion.set('') + archiveClassifier.set('') + + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + + // Configure output directory + doFirst { + destinationDirectory.set(extension.outputDir) + } + + // Include staged extension content + from(stagingDir) { + exclude 'embedded-extensions.txt' + } + + // Configure manifest + manifest { + attributes( + 'Premain-Class': 'io.btrace.agent.Main', + 'Agent-Class': 'io.btrace.agent.Main', + 'Can-Redefine-Classes': 'true', + 'Can-Retransform-Classes': 'true', + 'Boot-Class-Path': "${extension.baseName}.jar" + ) + } + + doFirst { + // Read embedded extensions list and add to manifest + def extListFile = new File(stagingDir, 'embedded-extensions.txt') + if (extListFile.exists() && extListFile.text.trim()) { + manifest.attributes['BTrace-Embedded-Extensions'] = extListFile.text.trim() + } + + // Add user-specified manifest attributes + if (!extension.manifestAttributes.isEmpty()) { + manifest.attributes.putAll(extension.manifestAttributes) + } + } + } + + // Wire up dependencies after ALL projects are evaluated (important for auto-discovery) + project.gradle.projectsEvaluated { + def fatAgentTask = fatAgentJar.get() + + // Auto-discover extensions if enabled (must happen first) + if (extension.autoDiscover) { + discoverExtensions(project, extension) + } + + // Include base agent/boot JARs if specified + if (extension.agentJarTask != null) { + def agentTask = project.tasks.named(extension.agentJarTask.toString()).get() + fatAgentTask.dependsOn(agentTask) + fatAgentTask.from(project.zipTree(agentTask.archiveFile)) + } + + if (extension.bootJarTask != null) { + def bootTask = project.tasks.named(extension.bootJarTask.toString()).get() + fatAgentTask.dependsOn(bootTask) + fatAgentTask.from(project.zipTree(bootTask.archiveFile)) + } + + // Wire extension project dependencies + extension.extensionSources.each { source -> + if (source instanceof ProjectExtensionSource) { + def extProject = project.project(source.projectPath) + stageExtensions.get().dependsOn("${source.projectPath}:buildApiJar") + stageExtensions.get().dependsOn("${source.projectPath}:shadowJar") + } + } + + // Configure relocations if using ShadowJar + if (fatAgentTask.class.name.contains('ShadowJar') && !extension.relocations.isEmpty()) { + extension.relocations.each { from, to -> + fatAgentTask.relocate(from, to) + } + } + } + } + + /** + * Resolve extensions using duck-typed extension object (avoids classloader issues). + */ + private List resolveExtensionsFromExt(Project project, def extension) { + def resolved = [] + + extension.extensionSources.each { source -> + try { + def ext = source.resolve() + if (ext != null) { + resolved << ext + project.logger.info("[fat-agent] Resolved extension: ${ext}") + } + } catch (Exception e) { + project.logger.error("[fat-agent] Failed to resolve ${source}: ${e.message}") + throw e + } + } + + return resolved + } + + /** + * Stage a resolved extension to the staging directory. + */ + private void stageExtension(Project project, File stagingDir, ResolvedExtension ext) { + // Stage API classes as .class files (for bootstrap) + if (ext.apiJar?.exists()) { + project.copy { + from project.zipTree(ext.apiJar) + into stagingDir + include '**/*.class' + } + project.logger.info("[fat-agent] Staged API from: ${ext.apiJar.name}") + } + + // Stage impl classes as .classdata files (for ClassDataLoader) + if (ext.implJar?.exists()) { + project.copy { + from project.zipTree(ext.implJar) + into stagingDir + include '**/*.class' + rename '(.+)\\.class', '$1.classdata' + } + project.logger.info("[fat-agent] Staged impl (as .classdata) from: ${ext.implJar.name}") + } + + // Stage extension metadata + def extMetaDir = new File(stagingDir, "META-INF/btrace-extensions/${ext.id}") + extMetaDir.mkdirs() + + def propsFile = new File(extMetaDir, 'extension.properties') + propsFile.text = """\ +id=${ext.id} +version=${ext.version} +name=${ext.metadata?.getProperty('name') ?: ext.id} +description=${ext.metadata?.getProperty('description') ?: ''} +""" + + project.logger.info("[fat-agent] Created extension.properties for ${ext.id}") + } + + /** + * Compile probe sources using BTrace compiler. + */ + private void compileProbes(Project project, ProbeBundleSpec probeSpec, File outputDir) { + // Find btrace-compiler dependency + def compilerJar = findBTraceCompiler(project) + if (compilerJar == null) { + project.logger.warn("[fat-agent] BTrace compiler not found, skipping probe compilation") + return + } + + probeSpec.sourceRoots.each { sourceDir -> + if (!sourceDir.exists()) { + return + } + + project.logger.info("[fat-agent] Compiling probes from: ${sourceDir}") + + // Use Gradle's JavaExec to run btracec + project.javaexec { + classpath = project.files(compilerJar) + mainClass = 'io.btrace.compiler.Compiler' + args = ['-d', outputDir.absolutePath] + + // Add all .java files + sourceDir.eachFileRecurse { f -> + if (f.name.endsWith('.java')) { + args << f.absolutePath + } + } + } + } + } + + /** + * Find btrace-compiler JAR in project dependencies. + */ + private File findBTraceCompiler(Project project) { + // Try to find from btrace-dist or similar project + def distProject = project.rootProject.subprojects.find { it.name == 'btrace-dist' } + if (distProject != null) { + def clientJar = distProject.tasks.findByName('clientJar')?.archiveFile?.get()?.asFile + if (clientJar?.exists()) { + return clientJar + } + } + + // Try configuration resolution + try { + def config = project.configurations.findByName('btracec') ?: + project.configurations.create('btracec') + if (config.dependencies.isEmpty()) { + config.dependencies.add(project.dependencies.create('io.btrace:btrace-client:+')) + } + return config.resolve().find { it.name.contains('btrace-client') } + } catch (Exception e) { + project.logger.debug("[fat-agent] Could not resolve btrace-client: ${e.message}") + } + + return null + } + + /** + * Auto-discover extension projects in the build. + */ + private void discoverExtensions(Project project, BTraceFatAgentExtension extension) { + // Check for filter property + def filterList = project.hasProperty(extension.filterProperty) + ? project.property(extension.filterProperty).toString().split(',').toList() + : null + + project.rootProject.subprojects.each { sp -> + if (sp.plugins.hasPlugin('io.btrace.extension')) { + if (filterList == null || filterList.contains(sp.name)) { + // Add as project source if not already present + def alreadyAdded = extension.extensionSources.any { source -> + source instanceof ProjectExtensionSource && source.projectPath == sp.path + } + if (!alreadyAdded) { + extension.addExtensionSource(new ProjectExtensionSource(project, sp.path)) + project.logger.info("[fat-agent] Auto-discovered extension: ${sp.path}") + } + } + } + } + } +} diff --git a/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/PermissionScanner.groovy b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/PermissionScanner.groovy new file mode 100644 index 000000000..54f090b6b --- /dev/null +++ b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/PermissionScanner.groovy @@ -0,0 +1,224 @@ +package io.btrace.gradle + +import java.io.File +import java.io.FileInputStream +import java.io.IOException +import java.io.InputStream +import java.util.ArrayDeque +import java.util.Collection +import java.util.Collections +import java.util.Deque +import java.util.List +import java.util.Set +import java.util.zip.ZipEntry +import java.util.zip.ZipFile +import org.objectweb.asm.ClassReader +import org.objectweb.asm.tree.ClassNode +import org.objectweb.asm.tree.AbstractInsnNode +import org.objectweb.asm.tree.MethodInsnNode +import org.objectweb.asm.tree.FieldInsnNode +import org.objectweb.asm.Opcodes +import org.objectweb.asm.tree.LdcInsnNode + +/** + * Scans a compiled extension implementation JAR to infer required permissions + * based on referenced JDK/runtime APIs. + */ +final class PermissionScanner { + + static Set scan(File jarFile, Collection classpath = Collections.emptyList()) { + Set perms = [] as Set + if (jarFile == null || !jarFile.exists()) return perms + + List sources = [] + sources.add(jarFile) + classpath?.each { File f -> + if (f == null || !f.exists()) return + def path = f.absolutePath + if (path.contains('/btrace-core') || path.contains('/btrace-runtime') || path.contains('/btrace-agent')) return + sources.add(f) + } + + Set visited = [] as Set + Deque queue = new ArrayDeque<>() + new ZipFile(jarFile).withCloseable { zip -> + zip.entries().each { e -> + if (!e.isDirectory() && e.name.endsWith('.class')) { + queue.add(e.name.substring(0, e.name.length() - '.class'.length())) + } + } + } + + while (!queue.isEmpty()) { + String cn = queue.removeFirst() + if (!visited.add(cn)) continue + InputStream is = openClassStream(cn, sources) + if (is == null) continue + try { + ClassReader cr = new ClassReader(is) + ClassNode node = new ClassNode() + cr.accept(node, 0) + node.methods.each { m -> + for (AbstractInsnNode insn = m.instructions.first; insn != null; insn = insn.next) { + if (insn instanceof MethodInsnNode) { + MethodInsnNode min = (MethodInsnNode) insn + handleMethod(min, perms, m, insn) + String owner = min.owner + if (owner != null && !owner.startsWith('java/') && !owner.startsWith('javax/')) { + queue.add(owner) + } + } else if (insn instanceof FieldInsnNode) { + handleField(((FieldInsnNode) insn), perms) + } + } + } + } finally { + is.close() + } + } + return perms + } + + private static void handleMethod(MethodInsnNode min, Set perms, def methodNode, AbstractInsnNode current) { + String owner = min.owner + String name = min.name + + if (owner.startsWith('java/net/') || owner.startsWith('javax/net/')) { + perms.add('NETWORK') + } + if (owner.startsWith('java/io/') || owner.startsWith('java/nio/file/')) { + if (owner == 'java/io/FileOutputStream' || owner == 'java/io/FileWriter' || owner == 'java/io/PrintWriter') { + perms.add('FILE_WRITE'); perms.add('FILE_READ') + } else if (owner == 'java/io/RandomAccessFile') { + String mode = findPreviousLdcString(methodNode, current, 8) + if ('r'.equals(mode)) { + perms.add('FILE_READ') + } else { + perms.add('FILE_WRITE'); perms.add('FILE_READ') + } + } else if (owner.startsWith('java/nio/file/Files')) { + if (name.startsWith('newOutputStream') || name.startsWith('write') || name.startsWith('create') || name.startsWith('delete')) { + perms.add('FILE_WRITE') + } else if (name.startsWith('newInputStream') || name.startsWith('read')) { + perms.add('FILE_READ') + } + } else if (owner == 'java/io/FileInputStream' || owner == 'java/io/BufferedInputStream' || owner == 'java/io/InputStreamReader') { + perms.add('FILE_READ') + } + } + if (owner == 'java/io/File') { + if (name in ['delete', 'deleteOnExit', 'renameTo', 'mkdir', 'mkdirs', 'createNewFile', 'setReadable', 'setWritable', 'setExecutable']) { + perms.add('FILE_WRITE') + } + } + if (owner == 'java/nio/file/Files') { + if (name in ['createFile','createDirectory','createDirectories','delete','deleteIfExists','move','setAttribute','setPosixFilePermissions','copy','write']) { + perms.add('FILE_WRITE') + } + } + if ((owner == 'java/nio/channels/FileChannel' || owner == 'java/nio/channels/AsynchronousFileChannel') && name == 'open') { + if (hasOpenOptionWrite(methodNode, current, 20)) { + perms.add('FILE_WRITE') + } else { + perms.add('FILE_READ') + } + } + if (owner == 'java/util/logging/FileHandler' && name == '') { + perms.add('FILE_WRITE') + } + if (owner == 'java/lang/Thread' || owner.startsWith('java/util/concurrent/')) { + perms.add('THREADS') + } + if (owner == 'sun/misc/Unsafe' || owner == 'jdk/internal/misc/Unsafe') { + perms.add('NATIVE') + } + if (owner == 'java/lang/System' && (name == 'load' || name == 'loadLibrary')) { + perms.add('NATIVE') + } + if (owner == 'java/lang/Runtime' && name == 'exec') { + perms.add('EXEC') + } + if (owner == 'java/lang/ProcessBuilder' && name == '') { + perms.add('EXEC') + } + if (owner.startsWith('java/lang/reflect/')) { + perms.add('REFLECTION') + } + if (owner == 'java/lang/ClassLoader' || owner == 'java/lang/Class' && name.startsWith('forName')) { + perms.add('CLASSLOADER') + } + if (owner == 'java/lang/System' && name == 'getProperty') { + perms.add('SYSTEM_PROPS') + } + if (owner == 'java/lang/management/ManagementFactory') { + perms.add('THREAD_INFO'); perms.add('MEMORY_INFO') + } + if (owner.startsWith('com/sun/management/')) { + perms.add('MEMORY_INFO') + } + if (owner.startsWith('jdk/jfr/') || owner.startsWith('org/openjdk/btrace/core/jfr/')) { + perms.add('JFR_EVENTS') + } + } + + private static void handleField(FieldInsnNode fin, Set perms) { + String owner = fin.owner + String name = fin.name + if (owner == 'java/lang/System' && name == 'props') { + perms.add('SYSTEM_PROPS') + } + } + + private static String findPreviousLdcString(def methodNode, AbstractInsnNode from, int window) { + if (methodNode == null || from == null) return null + int count = 0 + for (AbstractInsnNode p = from.previous; p != null && count < window; p = p.previous, count++) { + if (p.opcode == Opcodes.LDC && p instanceof LdcInsnNode) { + def cst = ((LdcInsnNode) p).cst + if (cst instanceof String) return (String) cst + } + } + return null + } + + private static boolean hasOpenOptionWrite(def methodNode, AbstractInsnNode from, int window) { + if (methodNode == null || from == null) return true + int count = 0 + for (AbstractInsnNode p = from.previous; p != null && count < window; p = p.previous, count++) { + if (p instanceof FieldInsnNode) { + FieldInsnNode fin = (FieldInsnNode) p + if (fin.owner == 'java/nio/file/StandardOpenOption') { + if (['WRITE','APPEND','CREATE','CREATE_NEW','TRUNCATE_EXISTING','DELETE_ON_CLOSE'].contains(fin.name)) { + return true + } + } + } + } + return false + } + + private static InputStream openClassStream(String internalName, List sources) { + String entry = internalName.endsWith('.class') ? internalName : (internalName + '.class') + for (File f : sources) { + if (f.isDirectory()) { + File cf = new File(f, entry) + if (cf.exists()) return new FileInputStream(cf) + } else if (f.name.endsWith('.jar')) { + try { + def zip = new ZipFile(f) + try { + def ze = zip.getEntry(entry) + if (ze != null) { + byte[] bytes = zip.getInputStream(ze).bytes + return new java.io.ByteArrayInputStream(bytes) + } + } finally { + zip.close() + } + } catch (IOException ignored) { } + } + } + return null + } +} + diff --git a/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/SingleSourceApiPartition.groovy b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/SingleSourceApiPartition.groovy new file mode 100644 index 000000000..b9708bb07 --- /dev/null +++ b/btrace-gradle-plugin/src/main/groovy/io/btrace/gradle/SingleSourceApiPartition.groovy @@ -0,0 +1,380 @@ +package io.btrace.gradle + +import groovy.transform.CompileStatic +import java.io.File +import java.io.FileInputStream +import java.util.ArrayDeque +import java.util.Collection +import java.util.Deque +import java.util.LinkedHashMap +import java.util.LinkedHashSet +import java.util.List +import java.util.Map +import java.util.Set +import java.util.regex.Pattern +import org.objectweb.asm.AnnotationVisitor +import org.objectweb.asm.ClassReader +import org.objectweb.asm.Opcodes +import org.objectweb.asm.Type +import org.objectweb.asm.signature.SignatureReader +import org.objectweb.asm.signature.SignatureVisitor +import org.objectweb.asm.tree.AnnotationNode +import org.objectweb.asm.tree.ClassNode +import org.objectweb.asm.tree.FieldNode +import org.objectweb.asm.tree.InnerClassNode +import org.objectweb.asm.tree.MethodNode + +/** + * Computes the subset of authored classes that form the API surface for a single-source + * BTrace extension. The algorithm is intentionally conservative: it starts from declared + * service interfaces and optional manual exports, then walks bytecode signatures and + * annotations to find other authored classes that must also live in the API JAR. + */ +@CompileStatic +final class SingleSourceApiPartition { + private static final String SERVICE_DESCRIPTOR_DESC = + 'Lorg/openjdk/btrace/core/extensions/ServiceDescriptor;' + private static final String EXTERNAL_TYPE_DESC = + 'Lorg/openjdk/btrace/core/extensions/ExternalType;' + private static final Pattern EXCLUDED_GENERATED = + Pattern.compile('.*(\\$Ext|\\.btrace\\.shim\\.).*') + + private SingleSourceApiPartition() {} + + static Set detectServiceTypes(Collection classDirs) { + Set detected = new LinkedHashSet<>() + indexClasses(classDirs).each { String fqcn, IndexedClass indexed -> + if (indexed.interfaceType && indexed.hasAnnotation(SERVICE_DESCRIPTOR_DESC)) { + detected.add(fqcn) + } + } + return detected + } + + static Set collectAllTypes(Collection classDirs) { + return new LinkedHashSet<>(indexClasses(classDirs).keySet()) + } + + static Set computeExportedTypes( + Collection classDirs, + Collection explicitServices, + Collection additionalExports, + Collection excludedExports + ) { + Map index = indexClasses(classDirs) + Set roots = new LinkedHashSet<>() + if (explicitServices != null) { + explicitServices.each { String fqcn -> + if (fqcn != null && !fqcn.trim().isEmpty()) { + roots.add(fqcn.trim()) + } + } + } + if (roots.isEmpty()) { + roots.addAll(detectServiceTypes(classDirs)) + } + if (additionalExports != null) { + additionalExports.each { String fqcn -> + if (fqcn != null && !fqcn.trim().isEmpty()) { + roots.add(fqcn.trim()) + } + } + } + Set excluded = new LinkedHashSet<>() + if (excludedExports != null) { + excludedExports.each { String fqcn -> + if (fqcn != null && !fqcn.trim().isEmpty()) { + excluded.add(fqcn.trim()) + } + } + } + + Set exports = new LinkedHashSet<>() + Set visited = new LinkedHashSet<>() + Deque queue = new ArrayDeque<>(roots) + while (!queue.isEmpty()) { + String current = queue.removeFirst() + if (current == null || excluded.contains(current) || !visited.add(current)) { + continue + } + IndexedClass indexed = index.get(current) + if (indexed == null) { + continue + } + if (isGeneratedSupport(current)) { + continue + } + exports.add(current) + indexed.referencedTypes.each { String ref -> + if (ref == null || excluded.contains(ref) || isGeneratedSupport(ref)) { + return + } + if (index.containsKey(ref) && !visited.contains(ref)) { + queue.addLast(ref) + } + } + } + return exports + } + + static Set classFileIncludes( + Collection classDirs, + Collection explicitServices, + Collection additionalExports, + Collection excludedExports + ) { + Map index = indexClasses(classDirs) + Set exportedTypes = computeExportedTypes( + classDirs, explicitServices, additionalExports, excludedExports) + Set includes = new LinkedHashSet<>() + index.each { String fqcn, IndexedClass indexed -> + if (exportedTypes.contains(fqcn)) { + includes.add(indexed.relativeClassPath) + if (indexed.hasAnnotation(EXTERNAL_TYPE_DESC)) { + IndexedClass adapter = index.get(fqcn + '$Ext') + if (adapter != null) { + includes.add(adapter.relativeClassPath) + } + } + } + } + // Retain package metadata; it is harmless if additional packages are present. + classDirs.each { File dir -> + if (dir == null || !dir.exists()) { + return + } + dir.eachFileRecurse { File f -> + if (f.name == 'package-info.class' || f.name == 'module-info.class') { + includes.add(dir.toPath().relativize(f.toPath()).toString().replace(File.separatorChar, '/' as char)) + } + } + } + return includes + } + + private static boolean isGeneratedSupport(String fqcn) { + return fqcn != null && EXCLUDED_GENERATED.matcher(fqcn).matches() + } + + private static Map indexClasses(Collection classDirs) { + Map index = new LinkedHashMap<>() + classDirs?.each { File dir -> + if (dir == null || !dir.exists()) { + return + } + dir.eachFileRecurse { File f -> + if (!f.name.endsWith('.class')) { + return + } + String rel = dir.toPath().relativize(f.toPath()).toString() + String classPath = rel.replace(File.separatorChar, '/' as char) + if (classPath == 'module-info.class' || classPath == 'package-info.class') { + return + } + FileInputStream is = new FileInputStream(f) + try { + ClassReader cr = new ClassReader(is) + ClassNode cn = new ClassNode() + cr.accept(cn, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG) + IndexedClass indexed = IndexedClass.fromClassNode(cn, classPath) + index.put(indexed.fqcn, indexed) + } finally { + try { + is.close() + } catch (Throwable ignore) {} + } + } + } + return index + } + + @CompileStatic + private static final class IndexedClass { + final String fqcn + final String relativeClassPath + final boolean interfaceType + final Set referencedTypes + final Set annotations + + private IndexedClass( + String fqcn, + String relativeClassPath, + boolean interfaceType, + Set referencedTypes, + Set annotations + ) { + this.fqcn = fqcn + this.relativeClassPath = relativeClassPath + this.interfaceType = interfaceType + this.referencedTypes = referencedTypes + this.annotations = annotations + } + + boolean hasAnnotation(String descriptor) { + return annotations.contains(descriptor) + } + + static IndexedClass fromClassNode(ClassNode cn, String relativeClassPath) { + Set refs = new LinkedHashSet<>() + Set annos = new LinkedHashSet<>() + addInternalName(refs, cn.superName) + (cn.interfaces ?: Collections.emptyList()).each { Object name -> + addInternalName(refs, String.valueOf(name)) + } + collectSignatureTypes(cn.signature, refs) + collectAnnotationNodes(cn.visibleAnnotations, refs, annos) + collectAnnotationNodes(cn.invisibleAnnotations, refs, annos) + (cn.fields ?: Collections.emptyList()).each { Object field -> + FieldNode fn = (FieldNode) field + addDescriptorTypes(refs, fn.desc) + collectSignatureTypes(fn.signature, refs) + collectAnnotationNodes(fn.visibleAnnotations, refs, annos) + collectAnnotationNodes(fn.invisibleAnnotations, refs, annos) + } + (cn.methods ?: Collections.emptyList()).each { Object method -> + MethodNode mn = (MethodNode) method + addMethodDescriptorTypes(refs, mn.desc) + collectSignatureTypes(mn.signature, refs) + (mn.exceptions ?: Collections.emptyList()).each { Object ex -> + addInternalName(refs, String.valueOf(ex)) + } + collectAnnotationNodes(mn.visibleAnnotations, refs, annos) + collectAnnotationNodes(mn.invisibleAnnotations, refs, annos) + collectParameterAnnotations(mn.visibleParameterAnnotations, refs, annos) + collectParameterAnnotations(mn.invisibleParameterAnnotations, refs, annos) + } + (cn.innerClasses ?: Collections.emptyList()).each { Object inner -> + InnerClassNode icn = (InnerClassNode) inner + addInternalName(refs, icn.name) + } + return new IndexedClass( + cn.name.replace('/', '.'), + relativeClassPath, + (cn.access & Opcodes.ACC_INTERFACE) != 0, + refs, + annos + ) + } + + private static void collectParameterAnnotations(List[] params, Set refs, Set annos) { + if (params == null) { + return + } + params.each { List annotations -> + collectAnnotationNodes(annotations, refs, annos) + } + } + + private static void collectAnnotationNodes( + List annotations, + Set refs, + Set annos + ) { + if (annotations == null) { + return + } + annotations.each { AnnotationNode node -> + annos.add(node.desc) + addDescriptorTypes(refs, node.desc) + collectAnnotationValues(node.values, refs) + } + } + + private static void collectAnnotationValues(List

Important!!!

Important!!!

Quick start — latency only (works with any SDK)

Full metrics with fluent builder

BTrace Extension TCK Report

%s