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 -Ddata-prepper.plugin.framework=osgi. When
the property is unset, Data Prepper uses the existing classpath loader.
In that legacy mode plugin discovery is functionally identical to before:
the same ServiceLoader providers are found in the same order, the OSGi
framework never starts, no OSGi code path executes, and only a couple of
inert Spring beans are constructed.

Plugins are prepared for OSGi at build time rather than adapted at
runtime. A new standalone, publishable Gradle plugin module
data-prepper-gradle-plugins/osgi-plugin (plugin id
org.opensearch.dataprepper.osgi) bakes an OSGi manifest into the plugin
JAR at build time using bnd (biz.aQute.bnd). The module is publishable so
plugin authors outside this repository can apply it; in-repo plugins opt
in by applying the plugin id. There is no runtime adaptation and no
BundleAdapter. At startup in OSGi mode StaticBundleLoader installs the
pre-built bundle JARs directly, resolves and starts them with fail-fast
behavior, a startup summary log, and Micrometer metrics. A JAR that lacks
an OSGi manifest (no Bundle-SymbolicName) fails fast with an actionable
message pointing the author to the Gradle plugin.

The 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). Baked plugins declare their
@DataPrepperPlugin packages through the DataPrepper-Plugin-Classes
manifest header, which the Gradle plugin generates from
META-INF/data-prepper.plugins.properties, and LegacyPluginBundleActivator
registers those classes as OSGi services.

Data Prepper API packages are exported to bundles with semver version
attributes. The exported package set is generated at build time by a
Gradle task that writes META-INF/osgi-shared-packages.properties listing
every org.opensearch.dataprepper.* package except
org.opensearch.dataprepper.plugins.*, so there is no hand-maintained
list. The version comes from the existing data-prepper-api
DataPrepperVersion, formatted into the OSGi three-part string by a small
package-private toOsgiVersion helper; the separate DataPrepperApiVersion
class was removed. This is consistent with the data-prepper-api
backward-compatibility contract from #6607, so a plugin built on 2.15
resolves on a 2.16 host. The shared set also includes jakarta.validation,
jakarta.validation.constraints, and com.fasterxml.jackson.annotation
(annotations only: jackson-databind and jackson-core are intentionally
not exported, preserving isolation), plus org.slf4j and the framework
package org.opensearch.dataprepper.plugin.osgi so bundles can load
LegacyPluginBundleActivator from the system bundle.

Felix framework storage resolves under
System.getProperty("data-prepper.dir")/data/osgi/ (felix-cache-<pid>),
matching the MaxMindConfig idiom, with a java.io.tmpdir fallback when the
property is unset such as in tests. It does not use the system temp
directory by default.

BundleResolutionErrorTranslator turns Felix resolution failures into
readable diagnostics. BundleHealthCheck verifies framework, bundle, and
classloader isolation. BundleClassLoaderScope manages the thread context
classloader at the plugin invocation boundary so ServiceLoader and SPI
lookups resolve against the bundle classloader. PluginHealthProbe is a
seam for future functional health checks.

The OsgiFrameworkRunner bean is always instantiated by Spring but returns
early in @PostConstruct unless data-prepper.plugin.framework=osgi. The
Felix framework JAR ships on the runtime classpath as a small (<1MB)
library with zero transitive dependencies and is not exercised in legacy
mode.

Scope is limited to classloader isolation and deploy-time validation.
Bundles install once at startup and stop at shutdown, the same lifecycle
as classpath plugins. There is no production hot-reload; PluginHotLoader
is test-scoped only.

Data Prepper-owned system properties use the data-prepper. namespace:
data-prepper.plugin.framework and data-prepper.plugin.bundles.dir. The
genuine OSGi and Felix properties (org.osgi.*, felix.*) are unchanged.

Testing: an integration test OsgiIT in a new integrationTest source set
under plugin-framework-osgi builds a DefaultPluginFactory like
DefaultPluginFactoryIT, loads a test plugin through it, and proves the
load happened through OSGi rather than the classpath. It asserts that
FrameworkUtil.getBundle is non-null, the plugin classloader is a
BundleReference, the classloader is not the application classloader, and
the application classloader throws ClassNotFoundException for the plugin
class because the plugin is supplied only as a bundle JAR and never on
the application classpath. The Gradle plugin has unit and functional
(GradleRunner) tests.

Wiring changes: settings.gradle adds the plugin-framework-osgi module,
the new data-prepper-gradle-plugins/osgi-plugin (consumed via
includeBuild in pluginManagement), the data-prepper-test/osgi-test-plugin
subproject, a Felix version-catalog entry, and the bnd plugin.
build-resources.gradle adds plugin-framework-osgi 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. DefaultPluginFactory
evaluates plugin providers lazily so OSGi-registered providers are
visible. Tests verify these changes, and legacy behavior is unchanged.

The example and test plugin is data-prepper-test/osgi-test-plugin, not a
released data-prepper-plugins module. It demonstrates a minimal
@DataPrepperPlugin built as an OSGi bundle through the new Gradle plugin.

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'