Add MongoDB 5.x plugin and extend 4.x to cover 5.0-5.1

MongoDB 5.2+ replaced MongoClientDelegate with package-private MongoClusterImpl.
New mongodb-5.x-plugin module with:
- MongoClusterImplInstrumentation: intercept constructor (Cluster at arg[1])
  and getOperationExecutor() to propagate remotePeer
- MongoClusterOperationExecutorInstrumentation: intercept inner class
  OperationExecutorImpl constructor and execute() methods

Key challenge: OperationExecutorImpl is created inside MongoClusterImpl's
constructor before onConstruct fires. Solved by calling getOperationExecutor()
via setAccessible reflection in onConstruct.

Note: Same-package helper classes (@InternalAccessor approach) do NOT work
because agent and application use different classloaders — Java treats them
as different runtime packages even with identical package names.

Locally verified: 5.0.1, 5.1.4 (4.x plugin), 5.2.0, 5.5.1 (5.x plugin) all passed.

Author: wu-sheng

.claude/skills/new-plugin/SKILL.md

@@ -57,6 +57,17 @@ Pick interception points based on these principles:
 **Principle 1: Data accessibility without reflection.**
 Choose methods where the information you need (peer address, operation name, request/response details, headers for inject/extract) is directly available as method arguments, return values, or accessible through the `this` object's public API. **Never use reflection to read private fields.** If the data is not accessible at one method, look at a different point in the execution flow.
 
+If the target class is **package-private** (e.g., `final class` without `public`), you cannot import or cast to it. **Same-package helper classes do NOT work** because the agent and application use different classloaders — Java treats them as different runtime packages even with the same package name (`IllegalAccessError`). Use `setAccessible` reflection to call public methods:
+```java
+try {
+    java.lang.reflect.Method method = objInst.getClass().getMethod("publicMethodName");
+    method.setAccessible(true);  // Required for package-private class
+    Object result = method.invoke(objInst);
+} catch (Exception e) {
+    LOGGER.warn("Failed to access method", e);
+}
+```
+
 **Principle 2: Use `EnhancedInstance` dynamic field to propagate context inside the library.**
 This is the primary mechanism for passing data between interception points. The agent adds a dynamic field to every enhanced class via `EnhancedInstance`. Use it to:
 - Store server address (peer) at connection/client creation time, retrieve it at command execution time

.gitignore

@@ -22,3 +22,4 @@ packages/
 /test/jacoco/classes
 /test/jacoco/*.exec
 test/jacoco
+.claude/settings.local.json

apm-sniffer/apm-sdk-plugin/CLAUDE.md

@@ -145,6 +145,25 @@ public class MyPluginConfig {
 ```
 Config key becomes: `plugin.myplugin.some_setting`
 
+### Accessing Package-Private Classes
+
+When a plugin needs to call methods on a **package-private** class in the target library (e.g., `MongoClusterImpl` which is `final class` without `public`), you cannot import or cast to it from the plugin package.
+
+**Same-package helper classes do NOT work** because the agent and application use different classloaders. Even though the package names match, Java considers them different runtime packages, so package-private access is denied (`IllegalAccessError`).
+
+**Solution: use `setAccessible` reflection** to call public methods on package-private classes:
+```java
+try {
+    java.lang.reflect.Method method = objInst.getClass().getMethod("publicMethodName");
+    method.setAccessible(true);  // Required for package-private class
+    Object result = method.invoke(objInst);
+} catch (Exception e) {
+    LOGGER.warn("Failed to access method", e);
+}
+```
+
+**When to use:** Only when the target class is package-private and you need to call its public methods. Prefer normal casting when the class is public.
+
 ### Dependency Management
 
 **Plugin dependencies must use `provided` scope:**

apm-sniffer/apm-sdk-plugin/mongodb-5.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/mongodb/v5/interceptor/MongoClusterImplConstructorInterceptor.java

@@ -48,7 +48,9 @@ public void onConstruct(EnhancedInstance objInst, Object[] allArguments) {
 
         // The OperationExecutorImpl is created INSIDE this constructor (before onConstruct fires),
         // so its constructor interceptor couldn't read the peer yet. Set it now.
-        // MongoClusterImpl is package-private, access getOperationExecutor via reflection.
+        // MongoClusterImpl is package-private and loaded by application classloader.
+        // Same-package helpers from agent classloader cannot access it (different runtime packages).
+        // Use setAccessible reflection to call getOperationExecutor().
         try {
             java.lang.reflect.Method getExecutor = objInst.getClass().getMethod("getOperationExecutor");
             getExecutor.setAccessible(true);

docs/en/setup/service-agent/java-agent/Java-Plugin-Development-Guide.md

@@ -621,3 +621,26 @@ Please follow these steps:
 1. Send a pull request and ask for review.
 1. The plugin committers will approve your plugins, plugin CI-with-IT, e2e, and the plugin tests will be passed.
 1. The plugin is accepted by SkyWalking.
+
+### Accessing package-private target classes
+
+When a plugin needs to call methods on a **package-private** class in the target library (e.g., `MongoClusterImpl` which is `final class` without `public`), you cannot import or cast to it from the plugin's `org.apache.skywalking` package.
+
+**Important:** Same-package helper classes do NOT work because the agent and application use different classloaders. Java treats them as different runtime packages even with identical package names, so package-private access is denied with `IllegalAccessError`.
+
+**Solution:** Use `setAccessible` reflection to call public methods on package-private classes:
+
+```java
+try {
+    java.lang.reflect.Method method = objInst.getClass().getMethod("publicMethodName");
+    method.setAccessible(true);  // Required: class is package-private
+    Object result = method.invoke(objInst);
+    if (result instanceof EnhancedInstance) {
+        ((EnhancedInstance) result).setSkyWalkingDynamicField(value);
+    }
+} catch (Exception e) {
+    logger.warn("Failed to access method", e);
+}
+```
+
+**When to use:** Only when the target class is package-private and you need to call its public methods. Prefer normal casting in interceptors when the class is public.