[Streams] Make ES|QL view creation best-effort and guard test against unsupported ES versions (elastic#258584)

Resolves elastic#256797

## Summary

Fixes a consistent CI failure in the `basic.ts` deployment-agnostic API
integration test for Streams where `POST /api/streams/_enable` returned
a `500 Internal Server Error`. The failure was introduced by elastic#256096,
which added ES|QL view creation to the `enableStreams` flow, and had
occurred 15+ times on `main` (tracked in elastic#256797).

### Root cause

The `ExecutionPlan.execute()` method called `upsertEsqlViews()` inside
the same `try/catch` block as all other Elasticsearch operations. The
ES|QL views API (`/_query/view/`) is not available in all Elasticsearch
builds used in CI (e.g. the 9.4.0-SNAPSHOT used by the
deployment-agnostic stateful test cluster). When that call failed, the
error propagated up through `FailedToExecuteElasticsearchActionsError`
and ultimately caused `enableStreams` to return a 500.

The test itself contributed by unconditionally enabling
`OBSERVABILITY_STREAMS_ENABLE_WIRED_STREAM_VIEWS` via
`uiSettings.update` before calling `enableStreams`, which activated the
ES|QL view creation path regardless of whether the API was actually
available in the environment.

### Changes

**`execution_plan.ts` — make ES|QL view creation best-effort**

The `upsertEsqlViews()` call is moved outside the main `try/catch` block
and given its own `.catch()` that logs a warning instead of rethrowing.
This ensures that stream enablement succeeds even when the ES|QL views
API is unavailable, treating view creation as a non-critical
side-effect.

**`basic.ts` — runtime-probe the ES|QL views API before using it**

Instead of unconditionally enabling the feature flag, the `before` hook
now probes `GET /_query/view/__kibana_probe__` against the test
Elasticsearch cluster:

- A `404` response means the endpoint exists (but the probe view
doesn't) → API is available, feature flag is enabled, view assertions
run normally.
- Any other error means the API is not supported in this environment →
feature flag is left disabled, view-specific `it` blocks return early.

This makes the test self-adapting to the ES version present in each CI
environment without skipping the entire suite.

### Verification

The root cause was confirmed from [Buildkite build
90333](https://buildkite.com/elastic/kibana-on-merge/builds/90333): the
test cluster ran ES `9.4.0-SNAPSHOT` (March 9 2026 snapshot), the
failure was the 15th consecutive occurrence, and no Kibana-level error
log for `plugins.streams` was emitted — consistent with the error being
swallowed by the framework router after `throw error` in the route
handler, never reaching a log sink visible in FTR output.

Author: CoenWarmer

x-pack/platform/plugins/shared/streams/server/lib/streams/state_management/execution_plan/execution_plan.ts

@@ -243,9 +243,6 @@ export class ExecutionPlan {
         ...upsert_dot_streams_document,
         ...delete_dot_streams_document,
       ]);
-
-      // Upsert ES|QL views after the stream documents are created
-      await this.upsertEsqlViews(upsert_esql_view);
     } catch (error) {
       if (error instanceof StatusError) {
         throw error;
@@ -254,6 +251,21 @@ export class ExecutionPlan {
         `Failed to execute Elasticsearch actions: ${getErrorMessage(error)}`
       );
     }
+
+    // Upsert ES|QL views after the stream documents are created.
+    // This is best-effort: if the ES|QL views API is unavailable (e.g. older
+    // Elasticsearch versions or serverless), we log a warning instead of
+    // failing the whole operation.
+    const viewsToUpsert = this.actionsByType.upsert_esql_view;
+    if (viewsToUpsert.length > 0) {
+      await this.upsertEsqlViews(viewsToUpsert).catch((error) => {
+        this.dependencies.logger.warn(
+          `Failed to upsert ES|QL views. The ES|QL views API may not be available in this Elasticsearch version: ${getErrorMessage(
+            error
+          )}`
+        );
+      });
+    }
   }
 
   private async deleteQueries(actions: DeleteQueriesAction[]) {

x-pack/platform/test/api_integration_deployment_agnostic/apis/streams/basic.ts

@@ -70,25 +70,39 @@ export default function ({ getService }: DeploymentAgnosticFtrProviderContext) {
     });
   }
 
-  // Failing: See https://github.com/elastic/kibana/issues/256797
-  describe.skip('Basic functionality', () => {
+  describe('Basic functionality', () => {
     async function getWiredStatus() {
       const response = await viewerApiClient.fetch('GET /api/streams/_status').expect(200);
       return response.body;
     }
 
+    // Tracks whether the ES|QL views API is available in the current test environment.
+    // The API is only available in stateful (non-serverless) Elasticsearch and only in
+    // recent-enough versions. When unavailable, view-specific assertions are skipped.
+    let viewsApiAvailable = false;
+
     before(async () => {
       apiClient = await createStreamsRepositoryAdminClient(roleScopedSupertest);
       viewerApiClient = await createStreamsRepositoryViewerClient(roleScopedSupertest);
       if (!isServerless) {
-        await kibanaServer.uiSettings.update({
-          [OBSERVABILITY_STREAMS_ENABLE_WIRED_STREAM_VIEWS]: true,
-        });
+        // Probe whether the ES|QL views API exists. A 404 means the endpoint
+        // exists but the view resource was not found – i.e. the API is available.
+        // Any other error (e.g. 400/405) indicates the API is not yet supported.
+        viewsApiAvailable = await esClient.transport
+          .request({ method: 'GET', path: '/_query/view/__kibana_probe__' })
+          .then(() => true)
+          .catch((err: { statusCode?: number }) => err?.statusCode === 404);
+
+        if (viewsApiAvailable) {
+          await kibanaServer.uiSettings.update({
+            [OBSERVABILITY_STREAMS_ENABLE_WIRED_STREAM_VIEWS]: true,
+          });
+        }
       }
     });
 
     after(async () => {
-      if (!isServerless) {
+      if (!isServerless && viewsApiAvailable) {
         await kibanaServer.uiSettings.update({
           [OBSERVABILITY_STREAMS_ENABLE_WIRED_STREAM_VIEWS]: false,
         });
@@ -127,9 +141,10 @@ export default function ({ getService }: DeploymentAgnosticFtrProviderContext) {
           expect(typeof parsed.privileges.create_snapshot_repository).to.eql('boolean');
         });
 
-        // ES|QL views API is not available in serverless
+        // ES|QL views API is not available in all environments
         if (!isServerless) {
           it('creates ES|QL views for wired root streams', async () => {
+            if (!viewsApiAvailable) return;
             for (const streamName of ['logs.otel', 'logs.ecs']) {
               const response = await esClient.transport.request<{
                 views: Array<{ name: string; query: string }>;
@@ -220,9 +235,10 @@ export default function ({ getService }: DeploymentAgnosticFtrProviderContext) {
             expect(wiredStatus['logs.ecs']).to.eql(false);
           });
 
-          // ES|QL views API is not available in serverless
+          // ES|QL views API is not available in all environments
           if (!isServerless) {
             it('removes ES|QL views for wired root streams', async () => {
+              if (!viewsApiAvailable) return;
               for (const streamName of ['logs.otel', 'logs.ecs']) {
                 await esClient.transport
                   .request<{ views: Array<{ name: string; query: string }> }>({
@@ -320,9 +336,10 @@ export default function ({ getService }: DeploymentAgnosticFtrProviderContext) {
         expect(response).to.have.property('acknowledged', true);
       });
 
-      // ES|QL views API is not available in serverless
+      // ES|QL views API is not available in all environments
       if (!isServerless) {
         it(`creates ES|QL view $.${rootStream}.nginx for the forked child stream`, async () => {
+          if (!viewsApiAvailable) return;
           const childStreamName = `${rootStream}.nginx`;
           const response = await esClient.transport.request<{
             views: Array<{ name: string; query: string }>;
@@ -336,6 +353,7 @@ export default function ({ getService }: DeploymentAgnosticFtrProviderContext) {
         });
 
         it(`updates parent $.${rootStream} view to reference the forked child's view`, async () => {
+          if (!viewsApiAvailable) return;
           const response = await esClient.transport.request<{
             views: Array<{ name: string; query: string }>;
           }>({