feat(osgi): add opt-in Apache Felix plugin framework

Add an opt-in plugin-loading mode backed by an embedded Apache Felix OSGi
framework, enabled with the system property -Dplugin.framework=osgi. The
default classpath loader remains the default when the flag is not set. When
the flag is not set, plugin discovery is functionally identical to today: the
same ServiceLoader-based providers are returned in the same order, the OSGi
framework never starts, and no OSGi code path executes. The only added work in
legacy mode is the construction of a couple of inert Spring beans.

The new plugin-framework-osgi module embeds the Felix lifecycle
(FelixPluginManager), bootstraps it in OSGi mode through a Spring-managed
runner (OsgiFrameworkRunner), and exposes a PluginProvider backed by the OSGi
service registry (OsgiPluginRegistry). At startup in OSGi mode,
StaticBundleLoader installs each legacy plugin JAR through BundleAdapter, which
installs already-OSGi JARs directly and wraps legacy (non-OSGi) JARs by
generating a versioned OSGi manifest. Wrapped plugins' @DataPrepperPlugin
classes are registered as OSGi services (LegacyPluginBundleActivator). Data
Prepper API packages are exported to bundles with semver version attributes
read from data-prepper-api build metadata (DataPrepperOsgiPackages,
DataPrepperApiVersion), consistent with the data-prepper-api
backward-compatibility contract from #6607, so a plugin built on 2.15 resolves
on a 2.16 host. DataPrepperOsgiPackages also exports the framework package
org.opensearch.dataprepper.plugin.osgi so adapted bundles can load the
LegacyPluginBundleActivator from the system bundle.

StaticBundleLoader installs, resolves, and starts bundles with fail-fast
behavior, a startup summary log, and Micrometer metrics.
BundleResolutionErrorTranslator turns Felix resolution failures into readable
diagnostics, and BundleHealthCheck verifies framework, bundle, and classloader
isolation state. BundleClassLoaderScope manages the thread context classloader
at the plugin invocation boundary so ServiceLoader and SPI resolve against the
bundle classloader. PluginHealthProbe is a seam for future functional health
checks.

The OsgiFrameworkRunner bean is always instantiated by Spring but does nothing
unless -Dplugin.framework=osgi is set, because it returns early in its
@PostConstruct method. The Felix framework JAR ships on the runtime classpath
as a small (<1MB) library with zero transitive dependencies, but it is not
exercised in legacy mode.

Scope is limited to classloader isolation and deploy-time validation. Bundles
install once at startup and stop once at shutdown, the same lifecycle as
classpath plugins today. No production hot-reload is included. The
PluginHotLoader helper is test-scoped only and not on the production classpath.

Wiring changes: settings.gradle adds the module, a Felix version-catalog
entry, and the bnd plugin; build-resources.gradle adds the module to
coreProjects; data-prepper-core declares a runtimeOnly dependency on the new
module; PluginProviderLoader is made public with a registerProvider() hook and
caches the framework-mode flag at construction; a test in
data-prepper-plugin-framework's PluginProviderLoaderTest verifies the
mode-caching behavior. Legacy behavior is unchanged. A new, permanent, minimal
example plugin data-prepper-plugins/echo-processor is added to the build to
demonstrate a minimal @DataPrepperPlugin and the SPI path.

Resolves #6760

Signed-off-by: Kiran Kumar Veeravelly <veeravkk@amazon.com>

Author: Kiran Kumar Veeravelly

build-resources.gradle

@@ -19,5 +19,6 @@ ext.coreProjects = [
         project(':data-prepper-test'),
         project(':data-prepper-plugin-framework'),
         project(':data-prepper-plugin-schema'),
-        project(':data-prepper-plugin-schema-cli')
+        project(':data-prepper-plugin-schema-cli'),
+        project(':plugin-framework-osgi')
 ]

data-prepper-core/build.gradle

@@ -37,6 +37,7 @@ dependencies {
     implementation project(':data-prepper-logstash-configuration')
     implementation project(':data-prepper-pipeline-parser')
     implementation project(':data-prepper-plugin-framework')
+    runtimeOnly project(':plugin-framework-osgi')
     testImplementation project(':data-prepper-plugin-framework').sourceSets.test.output
     testImplementation project(':data-prepper-plugins:common').sourceSets.test.output
     testImplementation project(':data-prepper-plugins:file-source')

data-prepper-gradle-plugins/osgi-plugin/README.md

@@ -0,0 +1,108 @@
+# Data Prepper OSGi Gradle Plugin
+
+A standalone, publishable Gradle plugin that prepares a Data Prepper plugin JAR
+for OSGi consumption by baking an OSGi-compliant manifest into it at build time.
+
+This replaces the runtime JAR-to-bundle adaptation previously performed by
+`BundleAdapter` in `plugin-framework-osgi`. By generating the manifest at build
+time, plugins are valid OSGi bundles from the moment they are built — no runtime
+repackaging is required.
+
+## Plugin ID
+
+```
+org.opensearch.dataprepper.osgi
+```
+
+## Usage
+
+### Internal Data Prepper plugin projects
+
+In your plugin's `build.gradle`:
+
+```groovy
+plugins {
+    id 'org.opensearch.dataprepper.osgi'
+}
+```
+
+### External plugin authors
+
+Add the plugin to your `buildscript` dependencies or plugin management:
+
+```groovy
+// settings.gradle
+pluginManagement {
+    repositories {
+        mavenCentral()
+        // or wherever Data Prepper publishes its artifacts
+    }
+    plugins {
+        id 'org.opensearch.dataprepper.osgi' version '<data-prepper-version>'
+    }
+}
+```
+
+Then in your plugin project's `build.gradle`:
+
+```groovy
+plugins {
+    id 'org.opensearch.dataprepper.osgi'
+}
+```
+
+## Requirements
+
+Your project must include a resource file at:
+
+```
+src/main/resources/META-INF/data-prepper.plugins.properties
+```
+
+With the following property:
+
+```properties
+org.opensearch.dataprepper.plugin.packages=com.example.myplugin
+```
+
+The value is a comma-separated list of Java package names that contain your
+`@DataPrepperPlugin`-annotated classes. The plugin scans these packages at
+bundle activation time to register your plugin classes with the OSGi service
+registry.
+
+If this file is absent, the build will fail with a clear error message.
+
+## Generated Manifest Headers
+
+When applied, this plugin produces the following OSGi manifest headers in the
+output JAR:
+
+| Header | Value | Derivation |
+|--------|-------|------------|
+| `Bundle-SymbolicName` | `org.opensearch.dataprepper.plugin.<sanitized-name>` | Project name with non-alphanumeric chars replaced by dots |
+| `Bundle-Version` | OSGi-normalized project version | `2.16.0-SNAPSHOT` becomes `2.16.0`; ensures 3-part numeric |
+| `Export-Package` | All packages except `*.internal.*` | Computed by bnd from compiled bytecode |
+| `Import-Package` | `*` (bnd default) | Computed by bnd from bytecode dependency analysis |
+| `Bundle-Activator` | `org.opensearch.dataprepper.plugin.osgi.LegacyPluginBundleActivator` | Fixed; provided by `plugin-framework-osgi` at runtime |
+| `DataPrepper-Plugin-Classes` | Comma-separated package names | Read from `data-prepper.plugins.properties` |
+
+## How it works
+
+1. The plugin applies `biz.aQute.bnd.builder` to the consuming project.
+2. After project evaluation, it reads `data-prepper.plugins.properties` from the
+   main resource directories.
+3. It configures the jar task's bnd instructions with the headers listed above.
+4. At jar time, bnd analyzes the compiled bytecode to compute accurate
+   `Import-Package` and `Export-Package` values — this is more reliable than the
+   runtime heuristic approach that `BundleAdapter` used.
+
+## Comparison with BundleAdapter
+
+| Aspect | BundleAdapter (runtime) | This plugin (build time) |
+|--------|------------------------|--------------------------|
+| When it runs | At application startup | At build time |
+| Import-Package | Static list of shared API packages | bnd computes from actual bytecode |
+| Export-Package | Discovered by scanning JAR entries | bnd computes from compiled classes |
+| Bundle-Version | Always `1.0.0` | Actual project version (OSGi-normalized) |
+| Performance | Rewrites JARs at startup | Zero startup cost |
+| External plugins | Must be adapted at runtime | Already valid bundles |

data-prepper-gradle-plugins/osgi-plugin/build.gradle

@@ -0,0 +1,42 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ */
+
+plugins {
+    id 'java-gradle-plugin'
+    id 'maven-publish'
+}
+
+group = 'org.opensearch.dataprepper'
+
+repositories {
+    mavenCentral()
+    gradlePluginPortal()
+}
+
+dependencies {
+    implementation gradleApi()
+    implementation 'biz.aQute.bnd:biz.aQute.bnd.gradle:7.0.0'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.2'
+    testImplementation 'org.hamcrest:hamcrest:2.2'
+}
+
+gradlePlugin {
+    plugins {
+        dataPrepperOsgi {
+            id = 'org.opensearch.dataprepper.osgi'
+            implementationClass = 'org.opensearch.dataprepper.gradle.plugin.osgi.DataPrepperOsgiPlugin'
+        }
+    }
+}
+
+test {
+    useJUnitPlatform()
+}

data-prepper-gradle-plugins/osgi-plugin/settings.gradle

@@ -0,0 +1,17 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+pluginManagement {
+    repositories {
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+rootProject.name = 'osgi-plugin'