[Core] Expose isFeatureAvailable method from pricing API server setup (elastic#223525)

## 📓 Summary

This work exposes an asynchronous
`coreSetup.pricing.isFeatureAvailable()` method to assert whether Kibana
is running on a given pricing product during a plugin server setup
lifecycle step.

##  Why do we need it?

Some feature registrations are synchronous in the plugin setup, and
until all the plugins have registered their features, knowing features
availability at the server setup step is not possible.

## How does this fix it?

To guarantee we have access to all the registered features during the
setup lifecycle, the process works so that:
1. All the plugins are set up and the product features are registered
synchronously.
2. Once all the plugins are set, the core pricing service emits a
signal.
3. The `isFeatureAvailable` method on setup, if invoked previously,
resolves asynchronously, reacting to the emitted signal.

This guarantees access to the product feature model anywhere in Kibana,
without having to rely on the raw tier configuration values.

```ts
public setup(core: CoreSetup) {
    core.pricing.registerProductFeatures([
      {
        id: 'my-plugin:feature1',
        description: 'A feature for observability products',
        products: [
          { name: 'observability', tier: 'complete' },
        ],
      }
    ]);

    core.pricing.isFeatureAvailable('my-plugin:feature1').then((isActiveObservabilityComplete) => {
      if (isActiveObservabilityComplete) {
        // Enable feature1
      }
    });
  }
```

Author: tonyghiani

src/core/packages/plugins/server-internal/src/plugin_context.ts

@@ -293,6 +293,7 @@ export function createPluginSetupContext<TPlugin, TPluginDependencies>({
       onStart: (...dependencyNames) => runtimeResolver.onStart(plugin.name, dependencyNames),
     },
     pricing: {
+      isFeatureAvailable: deps.pricing.isFeatureAvailable,
       registerProductFeatures: deps.pricing.registerProductFeatures,
     },
     security: {

src/core/packages/pricing/common/src/pricing_tiers_client.ts

@@ -28,19 +28,17 @@ export class PricingTiersClient implements IPricingTiersClient {
    * @param productFeaturesRegistry - Registry containing the available product features
    */
   constructor(
-    private readonly tiers: TiersConfig,
+    private tiers: TiersConfig,
     private readonly productFeaturesRegistry: ProductFeaturesRegistry
   ) {}
 
   /**
-   * Checks if a product is active in the current pricing tier configuration.
+   * Sets the pricing tiers configuration.
    *
-   * @param product - The product to check
-   * @returns True if the product is active, false otherwise
-   * @internal
+   * @param tiers - The new pricing tiers configuration
    */
-  private isActiveProduct = (product: PricingProduct) => {
-    return Boolean(this.tiers.products?.some((currentProduct) => isEqual(currentProduct, product)));
+  setTiers = (tiers: TiersConfig) => {
+    this.tiers = tiers;
   };
 
   /**
@@ -53,6 +51,17 @@ export class PricingTiersClient implements IPricingTiersClient {
     return this.tiers.enabled;
   };
 
+  /**
+   * Checks if a product is active in the current pricing tier configuration.
+   *
+   * @param product - The product to check
+   * @returns True if the product is active, false otherwise
+   * @internal
+   */
+  private isActiveProduct = (product: PricingProduct) => {
+    return Boolean(this.tiers.products?.some((currentProduct) => isEqual(currentProduct, product)));
+  };
+
   /**
    * Determines if a feature is available based on the current pricing tier configuration.
    * When pricing tiers are disabled, all features are considered available.

src/core/packages/pricing/server-internal/README.md

@@ -59,20 +59,12 @@ Here's an example of how to consume the pricing service in a plugin:
 ```typescript
 // my-plugin/server/plugin.ts
 import { CoreSetup, CoreStart, Plugin } from '@kbn/core/server';
-import { PricingServiceSetup, PricingServiceStart } from '@kbn/core-pricing-server';
-
-interface MyPluginSetupDeps {
-  pricing: PricingServiceSetup;
-}
-
-interface MyPluginStartDeps {
-  pricing: PricingServiceStart;
-}
 
 export class MyPlugin implements Plugin {
-  public setup(core: CoreSetup, { pricing }: MyPluginSetupDeps) {
+  public setup(core: CoreSetup) {
     // Register features that your plugin provides
-    pricing.registerProductFeatures([
+
+    core.pricing.registerProductFeatures([
       {
         id: 'my-plugin:feature1',
         description: 'A feature for observability products',
@@ -88,12 +80,22 @@ export class MyPlugin implements Plugin {
         ],
       },
     ]);
+
+    /**
+     * Checks if a specific feature is available in the current pricing tier configuration.
+     * Resolves asynchronously after the pricing service has been set up and all the plugins have registered their features.
+     */
+    core.pricing.isFeatureAvailable('my-plugin:feature1').then((isActiveObservabilityComplete) => {
+      if (isActiveObservabilityComplete) {
+        // Enable feature1
+      }
+    });
   }
 
-  public start(core: CoreStart, { pricing }: MyPluginStartDeps) {
+  public start(core: CoreStart) {
     // Check if a feature is available based on the current pricing tier
-    const isFeature1Available = pricing.isFeatureAvailable('my-plugin:feature1');
-    const isFeature2Available = pricing.isFeatureAvailable('my-plugin:feature2');
+    const isFeature1Available = core.pricing.isFeatureAvailable('my-plugin:feature1');
+    const isFeature2Available = core.pricing.isFeatureAvailable('my-plugin:feature2');
 
     // Conditionally enable features based on availability
     if (isFeature1Available) {

src/core/packages/pricing/server-internal/src/pricing_service.test.ts

@@ -106,6 +106,56 @@ describe('PricingService', () => {
       expect(registry.get('feature1')).toBeDefined();
       expect(registry.get('feature2')).toBeDefined();
     });
+
+    it('allows checking if a feature is available', async () => {
+      await service.preboot({ http: prebootHttp });
+      const setup = await service.setup({ http: setupHttp });
+
+      const mockFeatures: PricingProductFeature[] = [
+        {
+          id: 'feature1',
+          description: 'A feature',
+          products: [{ name: 'observability', tier: 'complete' }],
+        },
+      ];
+
+      setup.registerProductFeatures(mockFeatures);
+      await setup.evaluateProductFeatures();
+
+      const isActiveObservabilityComplete = await setup.isFeatureAvailable('feature1');
+      expect(isActiveObservabilityComplete).toBe(true);
+    });
+  });
+
+  it('should block isFeatureAvailable until evaluateProductFeatures is called', async () => {
+    await service.preboot({ http: prebootHttp });
+    const setup = await service.setup({ http: setupHttp });
+
+    // Start calling isFeatureAvailable, before said feature was registered or evaluateProductFeatures is called
+    let resolved = false;
+    const promise = setup.isFeatureAvailable('testFeature').then(() => {
+      resolved = true;
+    });
+
+    // Now register the feature
+    setup.registerProductFeatures([
+      {
+        id: 'testFeature',
+        description: 'Test Feature',
+        products: [{ name: 'observability', tier: 'complete' }],
+      },
+    ]);
+
+    // Wait a short bit to ensure it doesn't resolve prematurely
+    await new Promise((r) => setTimeout(r, 100));
+    expect(resolved).toBe(false);
+
+    // Now "unlock" the gate
+    await setup.evaluateProductFeatures();
+
+    // Now it should resolve
+    await promise;
+    expect(resolved).toBe(true);
   });
 
   describe('#start()', () => {

src/core/packages/pricing/server-internal/src/pricing_service.ts

@@ -9,7 +9,7 @@
 
 import type { CoreContext } from '@kbn/core-base-server-internal';
 import type { Logger } from '@kbn/logging';
-import { firstValueFrom } from 'rxjs';
+import { Subject, firstValueFrom } from 'rxjs';
 import type { IConfigService } from '@kbn/config';
 import {
   type PricingProductFeature,
@@ -36,13 +36,22 @@ export class PricingService {
   private readonly configService: IConfigService;
   private readonly logger: Logger;
   private readonly productFeaturesRegistry: ProductFeaturesRegistry;
+
+  private readonly isEvaluated$ = new Subject<void>();
+  private readonly isEvaluatedPromise = firstValueFrom(this.isEvaluated$);
+
   private pricingConfig: PricingConfigType;
+  private tiersClient: PricingTiersClient;
 
   constructor(core: CoreContext) {
     this.logger = core.logger.get('pricing-service');
     this.configService = core.configService;
     this.productFeaturesRegistry = new ProductFeaturesRegistry();
     this.pricingConfig = { tiers: { enabled: false, products: [] } };
+    this.tiersClient = new PricingTiersClient(
+      this.pricingConfig.tiers,
+      this.productFeaturesRegistry
+    );
   }
 
   public preboot({ http }: PrebootDeps) {
@@ -64,12 +73,27 @@ export class PricingService {
       this.configService.atPath<PricingConfigType>('pricing')
     );
 
+    this.tiersClient.setTiers(this.pricingConfig.tiers);
+
     registerRoutes(http.createRouter(''), {
       pricingConfig: this.pricingConfig,
       productFeaturesRegistry: this.productFeaturesRegistry,
     });
 
     return {
+      /**
+       * Evaluates the product features and emits the `isEvaluated$` signal.
+       * This should be called after all plugins have registered their features.
+       */
+      evaluateProductFeatures: () => this.isEvaluated$.next(),
+      /**
+       * Checks if a specific feature is available in the current pricing tier configuration.
+       * Resolves asynchronously after the pricing service has been set up and all the plugins have registered their features.
+       */
+      isFeatureAvailable: async (featureId: string) => {
+        await this.isEvaluatedPromise;
+        return this.tiersClient.isFeatureAvailable(featureId);
+      },
       registerProductFeatures: (features: PricingProductFeature[]) => {
         features.forEach((feature) => {
           this.productFeaturesRegistry.register(feature);
@@ -79,13 +103,8 @@ export class PricingService {
   }
 
   public start() {
-    const tiersClient = new PricingTiersClient(
-      this.pricingConfig.tiers,
-      this.productFeaturesRegistry
-    );
-
     return {
-      isFeatureAvailable: tiersClient.isFeatureAvailable,
+      isFeatureAvailable: this.tiersClient.isFeatureAvailable,
     };
   }
 }

src/core/packages/pricing/server-mocks/src/pricing_service.mock.ts

@@ -13,6 +13,7 @@ import type { PricingService } from '@kbn/core-pricing-server-internal';
 
 const createSetupContractMock = () => {
   const setupContract: jest.Mocked<PricingServiceSetup> = {
+    isFeatureAvailable: jest.fn(),
     registerProductFeatures: jest.fn(),
   };
   return setupContract;

src/core/packages/pricing/server/src/contracts.ts

@@ -18,6 +18,19 @@ import type { IPricingTiersClient, PricingProductFeature } from '@kbn/core-prici
  * @public
  */
 export interface PricingServiceSetup {
+  /**
+   * Check if a specific feature is available in the current pricing tier configuration.
+   * Resolves asynchronously after the pricing service has been set up and all the plugins have registered their features.
+   *
+   * @example
+   * ```ts
+   * // my-plugin/server/plugin.ts
+   * public setup(core: CoreSetup) {
+   *   const isPremiumFeatureAvailable = core.pricing.isFeatureAvailable('my_premium_feature');
+   * }
+   * ```
+   */
+  isFeatureAvailable(featureId: string): Promise<boolean>;
   /**
    * Register product features that are available in specific pricing tiers.
    *

src/core/packages/root/server-internal/src/server.ts

@@ -395,6 +395,13 @@ export class Server {
 
     const pluginsSetup = await this.plugins.setup(coreSetup);
     this.#pluginsInitialized = pluginsSetup.initialized;
+    /**
+     * This is a necessary step to ensure that the pricing service is ready to be used.
+     * It must be called after all plugins have been setup.
+     * This guarantee that all plugins checking for a feature availability with isFeatureAvailable
+     * in the server setup contract get the right access to the feature availability.
+     */
+    pricingSetup.evaluateProductFeatures();
 
     this.registerCoreContext(coreSetup);
     await this.coreApp.setup(coreSetup, uiPlugins);