prep for 1.7.1 (#219)

Author: xiangshen-dk

CHANGELOG.md

@@ -1,4 +1,8 @@
 # Changelog
+## 1.7.1 (2026-08-17)
+* Add **Get trace project from the query** option to the Logs to traces settings (`logsToTraces.projectIdFromQuery`). When enabled, "View trace" links use the project of the query that produced the log entry (falling back to the default project) instead of the project embedded in the entry's `trace` path — for setups where logs are routed through a central logging project that stamps its own ID into the trace path. The setting is preserved when the trace data source is changed or cleared
+* Fix "View trace" links under GCE authentication intermittently missing for entries whose `trace` label is not a canonical resource path: the auto-detected default project is now resolved whenever a trace data source is configured (concurrently with the query), shared across simultaneous queries, and no longer re-fetched before every query after a failed lookup
+
 ## 1.7.0 (2026-07-20)
 * Add **Logs to traces** correlation: select a Google Cloud Trace data source in the data source settings, and log entries carrying a trace ID get a "View trace" link in the log details. The picker is restricted to Google Cloud Trace data sources, since the link query uses Cloud Trace's query format. When a log entry's `trace` value is not in the canonical `projects/<project>/traces/<id>` form, the link uses the data source's default project, or is omitted when no project can be determined
 * Support queries arriving via Grafana's trace-to-logs span links (`query` field): interpolate template variables and fall back to the default project when the span link carries no project ID. The fallback also covers GCE authentication (auto-detected project) and applies only to span-link queries, so dashboard queries with an empty project ID still surface an error

README.md

@@ -109,12 +109,17 @@ If a pattern contains invalid regex syntax, it is treated as a literal string ma
 
 You can link log entries to a [Google Cloud Trace](https://grafana.com/grafana/plugins/googlecloud-trace-datasource/) data source. In the data source settings, under **Logs to traces**, select the Google Cloud Trace data source. Once configured, any log entry written with the [LogEntry `trace` field](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry) shows a `traceId` field with a **View trace** link in the log details — clicking it opens the trace in the selected data source. The link carries the project parsed from the entry's `projects/<project>/traces/<id>` path; if the `trace` value is not in that form, the data source's default project is used, and if no project can be determined the link is omitted.
 
+If your logs are routed through a central logging project (for example, an OpenTelemetry collector writes to one project and a [log sink](https://cloud.google.com/logging/docs/export/configure_export_v2) forwards entries to tenant projects), the `trace` path is stamped with the routing project's ID even though the trace lives in the tenant project, so the parsed project is wrong. Enable **Get trace project from the query** to make the link use the project of the query that produced the log entry instead (falling back to the data source's default project; if neither resolves, the link is omitted). Only the link target changes — the raw `trace` label in the log details still shows the original path.
+
 Provisioning example:
 
 ```yaml
 jsonData:
   logsToTraces:
     datasourceUid: my-cloud-trace-datasource-uid
+    # Optional: use the queried project for View trace links instead of the
+    # project in the log entry's trace path (for centrally routed logs)
+    # projectIdFromQuery: true
 ```
 
 > **Note: a "View trace" link is not a guarantee that the trace was recorded.** For services with automatic request tracing (Cloud Run, App Engine, GKE ingress, and other services behind Google's HTTP load balancing), every request log entry carries a trace ID, but Cloud Trace only stores traces for **sampled** requests — and the built-in sampling rate is low (roughly 0.1 traces per second per instance for Cloud Run). Clicking **View trace** for an unsampled request shows a "trace not found" result; this is expected and matches the behavior of the trace links in the Google Cloud console's Logs Explorer. To make more links resolve, increase sampling on the application side: instrument the service with [OpenTelemetry](https://cloud.google.com/trace/docs/setup) and configure your own sampling rate, or force sampling on individual requests by sending an `X-Cloud-Trace-Context: <trace-id>/<span-id>;o=1` header (or a W3C `traceparent` header with the sampled flag set). Note that Cloud Trace bills per ingested span, so consider cost before sampling at 100% on high-traffic services.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "googlecloud-logging-datasource",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Backend Grafana plugin that enables visualization of GCP Cloud Logging logs in Grafana.",
   "scripts": {
     "build": "webpack -c ./.config/webpack/webpack.config.ts --env production",

src/ConfigEditor.tsx

@@ -19,7 +19,7 @@ import { ConnectionConfig, GoogleAuthType } from '@grafana/google-sdk';
 import { DataSourcePicker } from '@grafana/runtime';
 import { Checkbox, Field, FieldSet, Input, SecretInput, Select, TextArea } from '@grafana/ui';
 import React, { PureComponent } from 'react';
-import { authTypes, CloudLoggingOptions, DataSourceSecureJsonData } from './types';
+import { authTypes, CloudLoggingOptions, DataSourceSecureJsonData, LogsToTracesOptions } from './types';
 
 export type Props = DataSourcePluginOptionsEditorProps<CloudLoggingOptions, DataSourceSecureJsonData>;
 
@@ -171,12 +171,14 @@ export class ConfigEditor extends PureComponent<Props> {
 
 const logsToTraces = (props: Props) => {
   const { options, onOptionsChange } = props;
-  const setLogsToTraces = (uid?: string) =>
+  // Merge-style updater so changing one option (e.g. swapping the trace
+  // data source) never silently drops the others.
+  const setLogsToTraces = (patch: Partial<LogsToTracesOptions>) =>
     onOptionsChange({
       ...options,
       jsonData: {
         ...options.jsonData,
-        logsToTraces: uid ? { datasourceUid: uid } : undefined,
+        logsToTraces: { ...options.jsonData.logsToTraces, ...patch },
       },
     });
   return (
@@ -194,10 +196,23 @@ const logsToTraces = (props: Props) => {
           noDefault={true}
           width={40}
           current={options.jsonData.logsToTraces?.datasourceUid ?? null}
-          onChange={(ds) => setLogsToTraces(ds.uid)}
-          onClear={() => setLogsToTraces()}
+          onChange={(ds) => setLogsToTraces({ datasourceUid: ds.uid })}
+          onClear={() => setLogsToTraces({ datasourceUid: undefined })}
         />
       </Field>
+      {/* Options survive clearing the picker, so keep the row visible while
+          the flag is set — it must never become hidden, uneditable state. */}
+      {(options.jsonData.logsToTraces?.datasourceUid || options.jsonData.logsToTraces?.projectIdFromQuery) && (
+        <Checkbox
+          id="logs-to-traces-project-from-query"
+          label="Get trace project from the query"
+          description="Use the query's project ID (or the default project) for 'View trace' links instead of the project in the log entry's trace field. If neither resolves, the link is omitted. Enable this when logs are routed through a central logging project that stamps its own ID into the trace path."
+          value={options.jsonData.logsToTraces?.projectIdFromQuery ?? false}
+          onChange={(e) => setLogsToTraces({ projectIdFromQuery: e.currentTarget.checked })}
+          onPointerEnterCapture={undefined}
+          onPointerLeaveCapture={undefined}
+        />
+      )}
     </FieldSet>
   );
 };

src/datasource.test.ts

@@ -253,9 +253,9 @@ describe('Google Cloud Logging Data Source', () => {
             ],
         });
 
-        const runQuery = async (ds: DataSource, frame: DataFrame) => {
+        const runQuery = async (ds: DataSource, frame: DataFrame, targets: Query[] = []) => {
             jest.spyOn(DataSourceWithBackend.prototype, 'query').mockReturnValue(of({ data: [frame] }));
-            return lastValueFrom(ds.query({ targets: [] } as unknown as Parameters<DataSource['query']>[0]));
+            return lastValueFrom(ds.query({ targets, scopedVars: {} } as unknown as Parameters<DataSource['query']>[0]));
         };
 
         afterEach(() => {
@@ -332,6 +332,104 @@ describe('Google Cloud Logging Data Source', () => {
             const response = await runQuery(ds, frame);
             expect(response.data[0].fields).toHaveLength(2);
         });
+
+        it('keeps the trace-path project when targets carry a projectId and the flag is off', async () => {
+            const ds = makeDataSource({ logsToTraces: { datasourceUid: 'trace-uid' } });
+            const frame = logFrame({ trace: 'projects/my-proj/traces/abc123', traceId: 'abc123' });
+            const targets = [{ refId: 'A', projectId: 'other-proj' } as Query];
+            const response = await runQuery(ds, frame, targets);
+
+            const traceField = response.data[0].fields.find((f: { name: string }) => f.name === 'traceId');
+            expect(traceField.config.links[0].internal.query.projectId).toBe('my-proj');
+        });
+
+        it('warms the GCE default project for the trace-link fallback when the flag is off', async () => {
+            const ds = makeDataSource({
+                logsToTraces: { datasourceUid: 'trace-uid' },
+                authenticationType: GoogleAuthType.GCE,
+            });
+            const gceSpy = jest.spyOn(ds, 'getGCEDefaultProject').mockResolvedValue('gce-proj');
+            // The target carries a projectId, so the warm-up is not needed to
+            // build the request — only the non-canonical trace-path fallback
+            // consumes it when the response is mapped.
+            const frame = logFrame({ trace: 'abc123', traceId: 'abc123' });
+            const targets = [{ refId: 'A', projectId: 'some-proj' } as Query];
+            const response = await runQuery(ds, frame, targets);
+
+            expect(gceSpy).toHaveBeenCalled();
+            const traceField = response.data[0].fields.find((f: { name: string }) => f.name === 'traceId');
+            expect(traceField.config.links[0].internal.query.projectId).toBe('gce-proj');
+        });
+
+        describe('with projectIdFromQuery enabled', () => {
+            const stubTemplateSrv = {
+                replace: (s?: string) => (s === '$project' ? 'tenant-proj' : s ?? ''),
+            } as unknown as TemplateSrv;
+
+            const makeFlagOnDataSource = (overrides?: Partial<CloudLoggingOptions>) =>
+                makeDataSource(
+                    { logsToTraces: { datasourceUid: 'trace-uid', projectIdFromQuery: true }, ...overrides },
+                    stubTemplateSrv
+                );
+
+            const linkProject = (response: { data: any[] }) =>
+                response.data[0].fields.find((f: { name: string }) => f.name === 'traceId')?.config.links[0].internal
+                    .query.projectId;
+
+            const routedFrame = () =>
+                logFrame({ trace: 'projects/routing-proj/traces/abc123', traceId: 'abc123' });
+
+            it('uses the projectId of the target that produced the frame, not the trace path', async () => {
+                const ds = makeFlagOnDataSource();
+                const targets = [{ refId: 'A', projectId: 'tenant-proj' } as Query];
+                const response = await runQuery(ds, routedFrame(), targets);
+                expect(linkProject(response)).toBe('tenant-proj');
+            });
+
+            it('interpolates template variables in the target projectId', async () => {
+                const ds = makeFlagOnDataSource();
+                const targets = [{ refId: 'A', projectId: '$project' } as Query];
+                const response = await runQuery(ds, routedFrame(), targets);
+                expect(linkProject(response)).toBe('tenant-proj');
+            });
+
+            it('falls back to the default project when no target matches the frame', async () => {
+                const ds = makeFlagOnDataSource({ defaultProject: 'my-default-proj' });
+                const response = await runQuery(ds, routedFrame(), []);
+                expect(linkProject(response)).toBe('my-default-proj');
+            });
+
+            it('falls back to the default project when the matching target has no projectId', async () => {
+                const ds = makeFlagOnDataSource({ defaultProject: 'my-default-proj' });
+                const targets = [{ refId: 'A', projectId: '' } as Query];
+                const response = await runQuery(ds, routedFrame(), targets);
+                expect(linkProject(response)).toBe('my-default-proj');
+            });
+
+            it('ignores hidden targets when resolving the project', async () => {
+                const ds = makeFlagOnDataSource({ defaultProject: 'my-default-proj' });
+                const targets = [{ refId: 'A', projectId: 'tenant-proj', hide: true } as Query];
+                const response = await runQuery(ds, routedFrame(), targets);
+                expect(linkProject(response)).toBe('my-default-proj');
+            });
+
+            it('omits the link when neither a target project nor a default project resolves', async () => {
+                const ds = makeFlagOnDataSource();
+                const response = await runQuery(ds, routedFrame(), []);
+                expect(response.data[0].fields).toHaveLength(2);
+            });
+
+            it('pre-resolves the GCE default project so the link fallback works under GCE auth', async () => {
+                const ds = makeFlagOnDataSource({ authenticationType: GoogleAuthType.GCE });
+                const gceSpy = jest.spyOn(ds, 'getGCEDefaultProject').mockResolvedValue('gce-proj');
+                // All targets carry a projectId, but none matches the frame's
+                // refId, so the link must fall back to the GCE project.
+                const targets = [{ refId: 'B', projectId: 'other-proj' } as Query];
+                const response = await runQuery(ds, routedFrame(), targets);
+                expect(gceSpy).toHaveBeenCalled();
+                expect(linkProject(response)).toBe('gce-proj');
+            });
+        });
     });
 
     describe('applyTemplateVariables', () => {

src/datasource.ts

@@ -109,11 +109,25 @@ export class DataSource extends DataSourceWithBackend<Query, CloudLoggingOptions
     return this.getResource(`gceDefaultProject`);
   }
 
+  /**
+   * Resolve and cache the GCE default project. Single-flight: concurrent
+   * queries share one resource call, and a failed lookup is not retried
+   * until the next page load — retrying per query would gate every query
+   * on a full failing round-trip.
+   */
+  private gceDefaultProjectPromise: Promise<void> | null = null;
+
   async ensureGCEDefaultProject() {
     const { authenticationType, gceDefaultProject } = this.instanceSettings.jsonData;
-    if (authenticationType === 'gce' && !gceDefaultProject) {
-      this.instanceSettings.jsonData.gceDefaultProject = await this.getGCEDefaultProject();
+    if (authenticationType !== 'gce' || gceDefaultProject) {
+      return;
     }
+    if (!this.gceDefaultProjectPromise) {
+      this.gceDefaultProjectPromise = this.getGCEDefaultProject().then((project) => {
+        this.instanceSettings.jsonData.gceDefaultProject = project;
+      });
+    }
+    return this.gceDefaultProjectPromise;
   }
 
   /**
@@ -280,23 +294,48 @@ export class DataSource extends DataSourceWithBackend<Query, CloudLoggingOptions
    * @returns a modified {@link Observable<DataQueryResponse>}
    */
   query(request: DataQueryRequest<Query>): Observable<DataQueryResponse> {
-    // When a target has no projectId, applyTemplateVariables falls back to
-    // defaultProjectSync(), which for GCE auth reads a lazily-populated
-    // cache; resolve it before the backend call so the fallback is available.
-    const needsDefaultProject = request.targets.some((t) => !t.hide && !t.projectId);
-    const base =
-      needsDefaultProject && this.instanceSettings.jsonData.authenticationType === 'gce'
-        ? from(this.ensureGCEDefaultProject().catch(() => {})).pipe(mergeMap(() => super.query(request)))
-        : super.query(request);
     const uid = this.instanceSettings.jsonData.logsToTraces?.datasourceUid;
     const traceDs = uid ? getDataSourceSrv().getInstanceSettings(uid) : undefined;
+    // For GCE auth, defaultProjectSync() reads a lazily-populated cache.
+    // applyTemplateVariables falls back to it while the backend request is
+    // built, so when a target has no projectId the cache must resolve before
+    // super.query. The trace-link fallbacks read the same cache but only
+    // once the response is mapped, so for them the warm-up runs concurrently
+    // with the query and is awaited in the response pipe below.
+    const needsDefaultProjectForRequest = request.targets.some((t) => !t.hide && !t.projectId);
+    const gceWarmup =
+      this.instanceSettings.jsonData.authenticationType === 'gce' && (needsDefaultProjectForRequest || !!traceDs)
+        ? this.ensureGCEDefaultProject().catch(() => {})
+        : undefined;
+    const base =
+      gceWarmup && needsDefaultProjectForRequest
+        ? from(gceWarmup).pipe(mergeMap(() => super.query(request)))
+        : super.query(request);
     if (!traceDs) {
       return base;
     }
-    return base.pipe(
+    // With projectIdFromQuery enabled, trace links use the project of the
+    // query target that produced each frame (matched by refId) instead of
+    // the project embedded in the log entry's trace path.
+    const projectByRefId = this.instanceSettings.jsonData.logsToTraces?.projectIdFromQuery
+      ? new Map(
+          request.targets
+            .filter((t) => !t.hide && t.projectId)
+            .map((t) => [t.refId, this.templateSrv.replace(t.projectId, request.scopedVars)])
+        )
+      : undefined;
+    const awaited = gceWarmup ? base.pipe(mergeMap((response) => from(gceWarmup.then(() => response)))) : base;
+    return awaited.pipe(
       map((response) => ({
         ...response,
-        data: response.data.map((frame: DataFrame) => this.addTraceLinkField(frame, traceDs.uid, traceDs.name)),
+        data: response.data.map((frame: DataFrame) =>
+          this.addTraceLinkField(
+            frame,
+            traceDs.uid,
+            traceDs.name,
+            projectByRefId ? projectByRefId.get(frame.refId ?? '') || this.defaultProjectSync() : undefined
+          )
+        ),
       }))
     );
   }
@@ -308,8 +347,19 @@ export class DataSource extends DataSourceWithBackend<Query, CloudLoggingOptions
    * the trace ID as its own field carrying an internal data link, so the
    * log details panel renders a "View trace" link that opens the configured
    * tracing data source — the same mechanism as Loki's derived fields.
+   *
+   * `projectIdOverride` is defined when the projectIdFromQuery setting is
+   * on: it is used verbatim as the link's project and the trace path is
+   * never parsed — the entry may be stamped with a routing project the user
+   * explicitly opted out of. An empty override means nothing resolved, so
+   * the link is omitted.
    */
-  addTraceLinkField(frame: DataFrame, datasourceUid: string, datasourceName: string): DataFrame {
+  addTraceLinkField(
+    frame: DataFrame,
+    datasourceUid: string,
+    datasourceName: string,
+    projectIdOverride?: string
+  ): DataFrame {
     const contentField = frame.fields.find((f) => f.name === 'content');
     const labels = contentField?.labels;
     const traceId = labels?.['traceId'];
@@ -321,7 +371,9 @@ export class DataSource extends DataSourceWithBackend<Query, CloudLoggingOptions
     // unset skip the link entirely — Cloud Trace errors on an empty project,
     // so no link beats a broken one.
     const projectId =
-      labels['trace']?.match(/^projects\/([^/]+)\/traces\//)?.[1] ?? this.defaultProjectSync();
+      projectIdOverride !== undefined
+        ? projectIdOverride
+        : labels['trace']?.match(/^projects\/([^/]+)\/traces\//)?.[1] ?? this.defaultProjectSync();
     if (!projectId) {
       return frame;
     }