Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

init

Dimitris Staratzis3fe218d64b8a
diff --git a/backend/CLAUDE.md b/backend/CLAUDE.md
index 7a89b83463..741d59af56 100644
--- a/backend/CLAUDE.md
+++ b/backend/CLAUDE.md
@@ -1076,6 +1076,16 @@ timezone, so pin day grouping and bound parameters to `'UTC'` or they follow the
the table is a `ReplacingMergeTree`: a retried batch inserts the same `id` twice and the copy goes away
only at some later merge, so read with `FINAL` when an exact count matters.
+### Secret Read Activity
+
+`ee/services/secret-read-activity/` answers "who has read this secret" from audit logs, for the
+per-secret access sheet and the Insights Unused Secret Access card. A bulk read only records a folder, so a
+read counts when it reaches the secret through that folder, an import of it, or a secret referencing it
+(imports and references check the reader's own access to the source, so revoking it would break them).
+A read of a parent folder is only a possible read, since whether it was recursive is not logged. Reads
+are matched on paths, and a rename or move changes the path, so only reads after the secret's current
+path existed count (`trackedSince`, from folder versions, the secret's and environment's timestamps).
+
### Audit Log Event Classes and Settings
Every `EventType` belongs to exactly one class in
diff --git a/backend/src/@types/fastify.d.ts b/backend/src/@types/fastify.d.ts
index 8d2ce22d5e..2fe6569624 100644
--- a/backend/src/@types/fastify.d.ts
+++ b/backend/src/@types/fastify.d.ts
@@ -71,6 +71,7 @@ import { TScimServiceFactory } from "@app/ee/services/scim/scim-types";
import { TSecretApprovalPolicyServiceFactory } from "@app/ee/services/secret-approval-policy/secret-approval-policy-service";
import { TSecretApprovalRequestServiceFactory } from "@app/ee/services/secret-approval-request/secret-approval-request-service";
import { TSecretChangeGlobalPolicyBridgeServiceFactory } from "@app/ee/services/secret-change-global-policy-bridge/secret-change-global-policy-bridge-service";
+import { TSecretReadActivityServiceFactory } from "@app/ee/services/secret-read-activity/secret-read-activity-service";
import { TSecretRotationV2ServiceFactory } from "@app/ee/services/secret-rotation-v2/secret-rotation-v2-service";
import { TSecretScanningServiceFactory } from "@app/ee/services/secret-scanning/secret-scanning-service";
import { TSecretScanningV2InstanceServiceFactory } from "@app/ee/services/secret-scanning-v2/secret-scanning-v2-instance-service";
@@ -441,6 +442,7 @@ declare module "fastify" {
microsoftTeams: TMicrosoftTeamsServiceFactory;
assumePrivileges: TAssumePrivilegeServiceFactory;
insights: TInsightsServiceFactory;
+ secretReadActivity: TSecretReadActivityServiceFactory;
auditReport: TAuditReportServiceFactory;
relay: TRelayServiceFactory;
gatewayV2: TGatewayV2ServiceFactory;
diff --git a/backend/src/ee/routes/v1/insights-router.ts b/backend/src/ee/routes/v1/insights-router.ts
index 641b9ad708..bf0546ccee 100644
--- a/backend/src/ee/routes/v1/insights-router.ts
+++ b/backend/src/ee/routes/v1/insights-router.ts
@@ -21,10 +21,15 @@ import {
SecretsSummarySchema,
StaticSecretsUsageSchema
} from "@app/ee/services/insights/insights-schemas";
+import {
+ SecretReadStatus,
+ UnusedSecretAccessOrderBy
+} from "@app/ee/services/secret-read-activity/secret-read-activity-types";
import { INSIGHTS } from "@app/lib/api-docs";
+import { OrderByDirection } from "@app/lib/types";
import { readLimit, writeLimit } from "@app/server/config/rateLimiter";
import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
-import { AuthMode } from "@app/services/auth/auth-type";
+import { ActorType, AuthMode } from "@app/services/auth/auth-type";
// Each report type declares exactly which inputs it accepts. The `inputs` schemas are the same consts
// the generators use, so request validation and generation never drift.
@@ -466,6 +471,62 @@ export const registerInsightsRouter = async (server: FastifyZodProvider) => {
}
});
+ server.route({
+ method: "GET",
+ url: "/:projectId/secrets/unused-access",
+ config: { rateLimit: readLimit },
+ schema: {
+ operationId: "getInsightsUnusedSecretAccess",
+ description:
+ "List the users and machine identities that can read a secret's value but have not read it in the last 30 days",
+ security: [{ bearerAuth: [] }],
+ params: z.object({
+ projectId: z.string().trim()
+ }),
+ querystring: z.object({
+ offset: z.coerce.number().int().min(0).max(1_000_000).default(0),
+ limit: z.coerce.number().int().min(1).max(100).default(20),
+ orderBy: z.nativeEnum(UnusedSecretAccessOrderBy).optional(),
+ orderDirection: z.nativeEnum(OrderByDirection).default(OrderByDirection.ASC)
+ }),
+ response: {
+ 200: z.object({
+ totalCount: z.number(),
+ unusedAccess: z
+ .object({
+ secretKey: z.string(),
+ environment: z.string(),
+ secretPath: z.string(),
+ principalType: z.enum([ActorType.USER, ActorType.IDENTITY]),
+ principalId: z.string(),
+ principalName: z.string(),
+ readStatus: z.nativeEnum(SecretReadStatus),
+ lastReadAt: z.date().nullable(),
+ trackedSince: z.date()
+ })
+ .array()
+ })
+ }
+ },
+ onRequest: verifyAuth([AuthMode.JWT, AuthMode.OAUTH]),
+ handler: async (req, reply) => {
+ const { projectId } = req.params;
+ const { unusedAccess, totalCount, remainingTTL } =
+ await server.services.secretReadActivity.listUnusedSecretAccess({ projectId, ...req.query }, req.permission);
+ await server.services.auditLog.createAuditLog({
+ projectId,
+ event: { type: EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_UNUSED_ACCESS, metadata: { projectId } },
+ ...req.auditLogInfo
+ });
+
+ if (remainingTTL && remainingTTL >= 0) {
+ void reply.header("X-Cache-TTL", remainingTTL);
+ }
+
+ return { unusedAccess, totalCount };
+ }
+ });
+
server.route({
method: "GET",
url: "/:projectId/usage/auth-methods",
diff --git a/backend/src/ee/routes/v1/secret-router.ts b/backend/src/ee/routes/v1/secret-router.ts
index cb4059f01c..7fe8c4ab4d 100644
--- a/backend/src/ee/routes/v1/secret-router.ts
+++ b/backend/src/ee/routes/v1/secret-router.ts
@@ -1,11 +1,12 @@
import z from "zod";
import { ProjectPermissionSecretActions } from "@app/ee/services/permission/project-permission";
+import { SecretReadStatus } from "@app/ee/services/secret-read-activity/secret-read-activity-types";
import { RAW_SECRETS } from "@app/lib/api-docs";
-import { removeTrailingSlash } from "@app/lib/fn";
+import { prefixWithSlash, removeTrailingSlash } from "@app/lib/fn";
import { readLimit } from "@app/server/config/rateLimiter";
import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
-import { AuthMode } from "@app/services/auth/auth-type";
+import { ActorType, AuthMode } from "@app/services/auth/auth-type";
const AccessListEntrySchema = z.object({
allowedActions: z.nativeEnum(ProjectPermissionSecretActions).array(),
@@ -75,4 +76,58 @@ export const registerSecretRouter = async (server: FastifyZodProvider) => {
});
}
});
+
+ server.route({
+ method: "GET",
+ url: "/:secretName/read-activity",
+ config: {
+ rateLimit: readLimit
+ },
+ schema: {
+ operationId: "getSecretReadActivity",
+ description: "Get which users and machine identities have recently read a secret",
+ security: [
+ {
+ bearerAuth: []
+ }
+ ],
+ params: z.object({
+ secretName: z.string().trim().min(1).describe(RAW_SECRETS.GET_READ_ACTIVITY.secretName)
+ }),
+ querystring: z.object({
+ projectId: z.string().trim().describe(RAW_SECRETS.GET_READ_ACTIVITY.projectId),
+ environment: z.string().trim().min(1).max(255).describe(RAW_SECRETS.GET_READ_ACTIVITY.environment),
+ secretPath: z
+ .string()
+ .trim()
+ .default("/")
+ .transform(prefixWithSlash)
+ .transform(removeTrailingSlash)
+ .describe(RAW_SECRETS.GET_READ_ACTIVITY.secretPath)
+ }),
+ response: {
+ 200: z.object({
+ readActivity: z.object({
+ trackedSince: z.date(),
+ reads: z
+ .object({
+ actorType: z.enum([ActorType.USER, ActorType.IDENTITY]),
+ actorId: z.string(),
+ status: z.nativeEnum(SecretReadStatus),
+ lastReadAt: z.date()
+ })
+ .array()
+ })
+ })
+ }
+ },
+ onRequest: verifyAuth([AuthMode.JWT, AuthMode.OAUTH]),
+ handler: async (req) => {
+ const readActivity = await server.services.secretReadActivity.getSecretReadActivity(
+ { ...req.query, secretName: req.params.secretName },
+ req.permission
+ );
+ return { readActivity };
+ }
+ });
};
diff --git a/backend/src/ee/services/audit-log/audit-log-clickhouse-dal.ts b/backend/src/ee/services/audit-log/audit-log-clickhouse-dal.ts
index a932d3f2ae..5b48038573 100644
--- a/backend/src/ee/services/audit-log/audit-log-clickhouse-dal.ts
+++ b/backend/src/ee/services/audit-log/audit-log-clickhouse-dal.ts
@@ -7,7 +7,7 @@ import { DatabaseError } from "@app/lib/errors";
import { logger } from "@app/lib/logger";
import { ActorType } from "@app/services/auth/auth-type";
-import { TPamAuditLogScope } from "./audit-log-dal";
+import { TFindLastSecretReadsQuery, TLastSecretRead, TPamAuditLogScope } from "./audit-log-dal";
import { ACTOR_TYPE_TO_METADATA_ID_KEY, EventType, filterableSecretEvents } from "./audit-log-types";
type TAuditLogWithProjectName = TAuditLogs & { projectName: string | null };
@@ -497,11 +497,73 @@ export const clickhouseAuditLogDALFactory = (clickhouseClient: ClickHouseClient,
}
};
+ // No FINAL: a duplicate row left by a retried batch cannot change a max().
+ const findLastSecretReads = async ({
+ orgId,
+ projectId,
+ eventTypes,
+ environments,
+ startDate,
+ endDate
+ }: TFindLastSecretReadsQuery): Promise<TLastSecretRead[]> => {
+ if (!environments.length) return [];
+ const query = `
+ SELECT
+ actor,
+ if(actor = {userActor:String}, JSONExtractString(actorMetadata, 'userId'), JSONExtractString(actorMetadata, 'identityId')) AS actorId,
+ JSONExtractString(eventMetadata, 'environment') AS environment,
+ JSONExtractString(eventMetadata, 'secretPath') AS secretPath,
+ JSONExtractString(eventMetadata, 'secretId') AS secretId,
+ toUnixTimestamp64Milli(max(createdAt)) AS lastReadAt
+ FROM ${tableName}
+ WHERE orgId = {orgId:UUID}
+ AND projectId = {projectId:String}
+ AND createdAt >= {startDate:DateTime64(6, 'UTC')}
+ AND createdAt < {endDate:DateTime64(6, 'UTC')}
+ AND eventType IN ({eventTypes:Array(String)})
+ AND actor IN ({actors:Array(String)})
+ AND JSONExtractString(eventMetadata, 'environment') IN ({environments:Array(String)})
+ GROUP BY actor, actorId, environment, secretPath, secretId
+ `;
+
+ try {
+ const result = await clickhouseClient.query({
+ query,
+ query_params: {
+ orgId,
+ projectId,
+ startDate: startDate.replace("Z", ""),
+ endDate: endDate.replace("Z", ""),
+ eventTypes,
+ environments,
+ userActor: ActorType.USER,
+ actors: [ActorType.USER, ActorType.IDENTITY]
+ },
+ clickhouse_settings: {
+ max_execution_time: 30
+ },
+ format: "JSONEachRow"
+ });
+
+ const rows = await result.json<Omit<TLastSecretRead, "lastReadAt"> & { secretId: string; lastReadAt: string }>();
+
+ return rows.map((row) => ({
+ ...row,
+ secretId: row.secretId || null,
+ lastReadAt: new Date(Number(row.lastReadAt))
+ }));
+ } catch (error) {
+ logger.error(error, `Failed to find last secret reads in ClickHouse [orgId=${orgId}] [projectId=${projectId}]`);
+ throw new DatabaseError({ error });
+ }
+ };
+
return {
find,
countByDateForOrg,
countByIdentityAuthMethodForOrg,
countByDateAndActorForProject,
- countByAuthMethodForProject
+ countByAuthMethodForProject,
+ findLastSecretReads
};
};
diff --git a/backend/src/ee/services/audit-log/audit-log-dal.ts b/backend/src/ee/services/audit-log/audit-log-dal.ts
index 299948ac96..61c38b848d 100644
--- a/backend/src/ee/services/audit-log/audit-log-dal.ts
+++ b/backend/src/ee/services/audit-log/audit-log-dal.ts
@@ -21,6 +21,18 @@ type TAggregateQuery = {
endDate: string;
};
+export type TFindLastSecretReadsQuery = TAggregateQuery & { environments: string[] };
+
+// The latest read per actor and location. secretId is set only for single-secret reads.
+export type TLastSecretRead = {
+ actor: ActorType.USER | ActorType.IDENTITY;
+ actorId: string;
+ environment: string;
+ secretPath: string;
+ secretId: string | null;
+ lastReadAt: Date;
+};
+
export interface TAuditLogDALFactory extends Omit<TOrmify<TableName.AuditLog>, "find"> {
pruneAuditLog: () => Promise<void>;
getApproximateRowCount: () => Promise<number>;
@@ -47,6 +59,7 @@ export interface TAuditLogDALFactory extends Omit<TOrmify<TableName.AuditLog>, "
arg: TAggregateQuery,
tx?: knex.Knex
) => Promise<{ actor: string; actorMetadata: unknown; count: number }[]>;
+ findLastSecretReads: (arg: TFindLastSecretReadsQuery, tx?: knex.Knex) => Promise<TLastSecretRead[]>;
}
type TFindQuery = {
@@ -430,6 +443,43 @@ export const auditLogDALFactory = (db: TDbClient) => {
return rows as { actor: string; actorMetadata: unknown; count: number }[];
};
+ const findLastSecretReads: TAuditLogDALFactory["findLastSecretReads"] = async (
+ { orgId, projectId, eventTypes, environments, startDate, endDate },
+ tx
+ ) => {
+ if (!environments.length) return [];
+ try {
+ const rows = await (tx || db.replicaNode())(TableName.AuditLog)
+ .where(`${TableName.AuditLog}.orgId`, orgId)
+ .where(`${TableName.AuditLog}.projectId`, projectId)
+ .whereIn(`${TableName.AuditLog}.eventType`, eventTypes)
+ .whereIn(`${TableName.AuditLog}.actor`, [ActorType.USER, ActorType.IDENTITY])
+ .whereRaw(`"${TableName.AuditLog}"."createdAt" >= ?::timestamptz`, [startDate])
+ .whereRaw(`"${TableName.AuditLog}"."createdAt" < ?::timestamptz`, [endDate])
+ .whereRaw(`"eventMetadata"->>'environment' IN (${environments.map(() => "?").join(", ")})`, environments)
+ .select(
+ "actor",
+ db.raw(`COALESCE("actorMetadata"->>'userId', "actorMetadata"->>'identityId') as "actorId"`),
+ db.raw(`"eventMetadata"->>'environment' as "environment"`),
+ db.raw(`"eventMetadata"->>'secretPath' as "secretPath"`),
+ db.raw(`"eventMetadata"->>'secretId' as "secretId"`),
+ db.raw(`MAX("createdAt") as "lastReadAt"`)
+ )
+ .groupByRaw("1, 2, 3, 4, 5")
+ .timeout(1000 * 120);
+
+ return rows as unknown as TLastSecretRead[];
+ } catch (error) {
+ if (error instanceof knex.KnexTimeoutError) {
+ throw new GatewayTimeoutError({
+ error,
+ message: "Loading secret read activity timed out. Try a narrower folder or a shorter time window."
+ });
+ }
+ throw new DatabaseError({ error, name: "Find last secret reads" });
+ }
+ };
+
return {
...auditLogOrm,
create,
@@ -439,6 +489,7 @@ export const auditLogDALFactory = (db: TDbClient) => {
find,
countByDateAndActor,
countByIpAddress,
- countByAuthMethod
+ countByAuthMethod,
+ findLastSecretReads
};
};
diff --git a/backend/src/ee/services/audit-log/audit-log-event-classes.ts b/backend/src/ee/services/audit-log/audit-log-event-classes.ts
index ec072c6354..0df31a673d 100644
--- a/backend/src/ee/services/audit-log/audit-log-event-classes.ts
+++ b/backend/src/ee/services/audit-log/audit-log-event-classes.ts
@@ -218,6 +218,7 @@ const DATA_ACCESS_EVENT_TYPES: readonly EventType[] = [
EventType.VIEW_INSIGHTS_AUTH_METHODS,
EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_CALENDAR,
EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_VOLUME,
+ EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_UNUSED_ACCESS,
EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ORG_AUTH_METHOD_DISTRIBUTION,
EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_LOCATIONS,
EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_SUMMARY,
diff --git a/backend/src/ee/services/audit-log/audit-log-types.ts b/backend/src/ee/services/audit-log/audit-log-types.ts
index 30faead9fb..cd997c2ffe 100644
--- a/backend/src/ee/services/audit-log/audit-log-types.ts
+++ b/backend/src/ee/services/audit-log/audit-log-types.ts
@@ -744,6 +744,7 @@ export enum EventType {
VIEW_INSIGHTS_AUTH_METHODS = "view-insights-auth-methods",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_CALENDAR = "view-insights-secrets-management-calendar",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_VOLUME = "view-insights-secrets-management-access-volume",
+ VIEW_INSIGHTS_SECRETS_MANAGEMENT_UNUSED_ACCESS = "view-insights-secrets-management-unused-access",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_ORG_AUTH_METHOD_DISTRIBUTION = "view-insights-secrets-management-org-auth-method-distribution",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_LOCATIONS = "view-insights-secrets-management-access-locations",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_SUMMARY = "view-insights-secrets-management-summary",
@@ -5922,6 +5923,13 @@ interface ViewSecretManagementInsightsAccessVolumeEvent {
};
}
+interface ViewSecretManagementInsightsUnusedAccessEvent {
+ type: EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_UNUSED_ACCESS;
+ metadata: {
+ projectId: string;
+ };
+}
+
interface ViewSecretManagementInsightsOrgAuthMethodDistributionEvent {
type: EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ORG_AUTH_METHOD_DISTRIBUTION;
metadata: {
@@ -8493,6 +8501,7 @@ export type Event =
| DashboardGetSecretVersionValueEvent
| ViewSecretManagementInsightsCalendarEvent
| ViewSecretManagementInsightsAccessVolumeEvent
+ | ViewSecretManagementInsightsUnusedAccessEvent
| ViewSecretManagementInsightsOrgAuthMethodDistributionEvent
| ViewSecretManagementInsightsAccessLocationsEvent
| ViewInsightsAuthMethodsEvent
diff --git a/backend/src/ee/services/insights/insights-service.ts b/backend/src/ee/services/insights/insights-service.ts
index bcd84f17a3..ec2d92d62d 100644
--- a/backend/src/ee/services/insights/insights-service.ts
+++ b/backend/src/ee/services/insights/insights-service.ts
@@ -127,8 +127,8 @@ const assertInsightsPlanEnabled = async (
}
};
-const checkInsightsPermission = async (
- permissionService: TInsightsServiceFactoryDep["permissionService"],
+export const checkInsightsPermission = async (
+ permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">,
licenseService: TInsightsServiceFactoryDep["licenseService"],
projectId: string,
actor: OrgServiceActor
diff --git a/backend/src/ee/services/secret-read-activity/secret-read-activity-fns.test.ts b/backend/src/ee/services/secret-read-activity/secret-read-activity-fns.test.ts
new file mode 100644
index 0000000000..fa80b09333
--- /dev/null
+++ b/backend/src/ee/services/secret-read-activity/secret-read-activity-fns.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, test } from "vitest";
+
+import { TLastSecretRead } from "@app/ee/services/audit-log/audit-log-dal";
+import { ActorType } from "@app/services/auth/auth-type";
+
+import { classifySecretReads, computeSecretReach, indexSecretReads } from "./secret-read-activity-fns";
+import { SecretReadStatus, TReachSecret, TSecretReachGraph } from "./secret-read-activity-types";
+
+// prod: /, /app, /app/nested, /shared. dev: /, /consumer (imports prod /app/nested).
+const folders: Record<string, { parentId: string | null; environment: string; secretPath: string }> = {
+ prodRoot: { parentId: null, environment: "prod", secretPath: "/" },
+ app: { parentId: "prodRoot", environment: "prod", secretPath: "/app" },
+ nested: { parentId: "app", environment: "prod", secretPath: "/app/nested" },
+ shared: { parentId: "prodRoot", environment: "prod", secretPath: "/shared" },
+ devRoot: { parentId: null, environment: "dev", secretPath: "/" },
+ consumer: { parentId: "devRoot", environment: "dev", secretPath: "/consumer" }
+};
+
+const dbPass: TReachSecret = { id: "db-pass", folderId: "shared", key: "DB_PASS" };
+const dbUrl: TReachSecret = { id: "db-url", folderId: "shared", key: "DB_URL" };
+const connection: TReachSecret = { id: "connection", folderId: "nested", key: "CONNECTION" };
+
+// DB_URL references DB_PASS locally, CONNECTION references DB_URL, and CONNECTION back to DB_PASS closes a cycle.
+const referencers: Record<string, TReachSecret[]> = {
+ [dbPass.id]: [dbUrl],
+ [dbUrl.id]: [connection],
+ [connection.id]: [dbPass]
+};
+
+const graph: TSecretReachGraph = {
+ getReferencers: (secret) => referencers[secret.id] ?? [],
+ getImporterFolderIds: (folderId) => (folderId === "nested" ? ["consumer"] : []),
+ getParentFolderId: (folderId) => folders[folderId]?.parentId,
+ getLocation: (folderId) => folders[folderId]
+};
+
+const read = (overrides: Partial<TLastSecretRead>): TLastSecretRead => ({
+ actor: ActorType.IDENTITY,
+ actorId: "identity-1",
+ environment: "prod",
+ secretPath: "/shared",
+ secretId: null,
+ lastReadAt: new Date("2026-10-10T00:00:00.000Z"),
+ ...overrides
+});
+
+const trackedSince = new Date("2026-10-01T00:00:00.000Z");
+
+describe("computeSecretReach", () => {
+ const reach = computeSecretReach(dbPass, graph);
+
+ test("follows references transitively and stops at cycles", () => {
+ expect([...reach.secretIds].sort()).toEqual([connection.id, dbPass.id, dbUrl.id].sort());
+ });
+
+ test("includes the folders holding referencing secrets and the folders importing them", () => {
+ expect([...reach.locations].sort()).toEqual(["dev:/consumer", "prod:/app/nested", "prod:/shared"]);
+ expect([...reach.environments].sort()).toEqual(["dev", "prod"]);
+ });
+
+ test("lists parent folders separately, never a folder that already returns the secret", () => {
+ expect([...reach.parentLocations].sort()).toEqual(["dev:/", "prod:/", "prod:/app"]);
+ });
+});
+
+describe("classifySecretReads", () => {
+ const reach = computeSecretReach(dbPass, graph);
+ const classify = (reads: TLastSecretRead[]) =>
+ classifySecretReads(indexSecretReads(reads), reach, trackedSince).get(`${ActorType.IDENTITY}:identity-1`);
+
+ test("counts a bulk read of a folder that imports the secret, whatever the path's trailing slash", () => {
+ expect(classify([read({ environment: "dev", secretPath: "/consumer/" })])?.status).toBe(SecretReadStatus.Read);
+ });
+
+ test("counts a single read of a secret that references it", () => {
+ expect(classify([read({ secretPath: "/app/nested", secretId: connection.id })])?.status).toBe(
+ SecretReadStatus.Read
+ );
+ });
+
+ test("ignores a single read of an unrelated secret in the same folder", () => {
+ expect(classify([read({ secretId: "unrelated" })])).toBeUndefined();
+ });
+
+ test("treats a read of a parent folder as a possible read", () => {
+ expect(classify([read({ secretPath: "/" })])?.status).toBe(SecretReadStatus.PossiblyRead);
+ });
+
+ test("ignores reads from before the secret's path existed", () => {
+ expect(classify([read({ lastReadAt: new Date("2026-09-30T00:00:00.000Z") })])).toBeUndefined();
+ });
+
+ test("prefers a definite read over a later possible one and keeps the latest of each", () => {
+ const latestRead = new Date("2026-10-08T00:00:00.000Z");
+ expect(
+ classify([
+ read({ secretPath: "/", lastReadAt: new Date("2026-10-12T00:00:00.000Z") }),
+ read({ lastReadAt: new Date("2026-10-05T00:00:00.000Z") }),
+ read({ environment: "dev", secretPath: "/consumer", lastReadAt: latestRead })
+ ])
+ ).toEqual({
+ actorType: ActorType.IDENTITY,
+ actorId: "identity-1",
+ status: SecretReadStatus.Read,
+ lastReadAt: latestRead
+ });
+ });
+});
diff --git a/backend/src/ee/services/secret-read-activity/secret-read-activity-fns.ts b/backend/src/ee/services/secret-read-activity/secret-read-activity-fns.ts
new file mode 100644
index 0000000000..51fdcb598f
--- /dev/null
+++ b/backend/src/ee/services/secret-read-activity/secret-read-activity-fns.ts
@@ -0,0 +1,111 @@
+import { TLastSecretRead } from "@app/ee/services/audit-log/audit-log-dal";
+import { EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { groupBy, prefixWithSlash, removeTrailingSlash } from "@app/lib/fn";
+
+import {
+ SecretReadStatus,
+ TReachSecret,
+ TSecretLocation,
+ TSecretReach,
+ TSecretReachGraph,
+ TSecretReadActivity
+} from "./secret-read-activity-types";
+
+export const SECRET_READ_EVENT_TYPES = [
+ EventType.GET_SECRETS,
+ EventType.GET_SECRET,
+ EventType.DASHBOARD_GET_SECRET_VALUE
+];
+
+export const toLocationKey = ({ environment, secretPath }: TSecretLocation) =>
+ `${environment}:${removeTrailingSlash(prefixWithSlash(secretPath))}`;
+
+// Imports and references check the reader's own access to the source secret, so a read through either
+// one uses that access and must count.
+export const computeSecretReach = (secret: TReachSecret, graph: TSecretReachGraph): TSecretReach => {
+ const secretIds = new Set([secret.id]);
+ const folderIds = new Set([secret.folderId]);
+
+ const pendingSecrets = [secret];
+ while (pendingSecrets.length) {
+ for (const referencer of graph.getReferencers(pendingSecrets.pop() as TReachSecret)) {
+ folderIds.add(referencer.folderId);
+ if (!secretIds.has(referencer.id)) {
+ secretIds.add(referencer.id);
+ pendingSecrets.push(referencer);
+ }
+ }
+ }
+
+ const pendingFolderIds = [...folderIds];
+ while (pendingFolderIds.length) {
+ for (const importerFolderId of graph.getImporterFolderIds(pendingFolderIds.pop() as string)) {
+ if (!folderIds.has(importerFolderId)) {
+ folderIds.add(importerFolderId);
+ pendingFolderIds.push(importerFolderId);
+ }
+ }
+ }
+
+ const reach: TSecretReach = {
+ secretIds,
+ locations: new Set(),
+ parentLocations: new Set(),
+ environments: new Set()
+ };
+ folderIds.forEach((folderId) => {
+ const location = graph.getLocation(folderId);
+ if (!location) return;
+ reach.locations.add(toLocationKey(location));
+ reach.environments.add(location.environment);
+ });
+ folderIds.forEach((folderId) => {
+ const visited = new Set<string>();
+ let parentId = graph.getParentFolderId(folderId);
+ while (parentId && !visited.has(parentId)) {
+ visited.add(parentId);
+ const location = graph.getLocation(parentId);
+ if (location && !reach.locations.has(toLocationKey(location))) {
+ reach.parentLocations.add(toLocationKey(location));
+ }
+ parentId = graph.getParentFolderId(parentId);
+ }
+ });
+ return reach;
+};
+
+export const indexSecretReads = (reads: TLastSecretRead[]) => ({
+ bySecretId: groupBy(
+ reads.filter((read) => read.secretId),
+ (read) => read.secretId as string
+ ),
+ byLocation: groupBy(
+ reads.filter((read) => !read.secretId),
+ (read) => toLocationKey(read)
+ )
+});
+
+// Reads before trackedSince are ignored: the secret, or the path it lives at, did not exist yet.
+export const classifySecretReads = (
+ reads: ReturnType<typeof indexSecretReads>,
+ reach: TSecretReach,
+ trackedSince: Date
+) => {
+ const activity = new Map<string, TSecretReadActivity>();
+ const record = (status: SecretReadStatus, matches: TLastSecretRead[] = []) => {
+ matches.forEach((read) => {
+ if (read.lastReadAt < trackedSince) return;
+ const key = `${read.actor}:${read.actorId}`;
+ const current = activity.get(key);
+ // Definite reads are recorded first, so a possible read never replaces one.
+ if (!current || (current.status === status && read.lastReadAt > current.lastReadAt)) {
+ activity.set(key, { actorType: read.actor, actorId: read.actorId, status, lastReadAt: read.lastReadAt });
+ }
+ });
+ };
+
+ reach.secretIds.forEach((secretId) => record(SecretReadStatus.Read, reads.bySecretId[secretId]));
+ reach.locations.forEach((location) => record(SecretReadStatus.Read, reads.byLocation[location]));
+ reach.parentLocations.forEach((location) => record(SecretReadStatus.PossiblyRead, reads.byLocation[location]));
+ return activity;
+};
diff --git a/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts b/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts
new file mode 100644
index 0000000000..126bfec0fd
--- /dev/null
+++ b/backend/src/ee/services/secret-read-activity/secret-read-activity-service.ts
@@ -0,0 +1,389 @@
+import { SecretType, TableName, TSecretFolders } from "@app/db/schemas";
+import { TClickHouseAuditLogDALFactory } from "@app/ee/services/audit-log/audit-log-clickhouse-dal";
+import { TAuditLogDALFactory } from "@app/ee/services/audit-log/audit-log-dal";
+import { hasAuditLogRetention } from "@app/ee/services/audit-log/audit-log-retention-fns";
+import {
+ isAuditLogEventEnabled,
+ TAuditLogSettingsServiceFactory
+} from "@app/ee/services/audit-log/audit-log-settings-service";
+import { EventType } from "@app/ee/services/audit-log/audit-log-types";
+import { DAY_IN_MS } from "@app/ee/services/audit-report/audit-report-fns";
+import { reviveDates } from "@app/ee/services/insights/insights-fns";
+import { checkInsightsPermission } from "@app/ee/services/insights/insights-service";
+import { TLicenseServiceFactory } from "@app/ee/services/license/license-service";
+import {
+ hasSecretReadValueOrDescribePermission,
+ throwIfMissingSecretReadValueOrDescribePermission
+} from "@app/ee/services/permission/permission-fns";
+import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
+import { ProjectPermissionSecretActions } from "@app/ee/services/permission/project-permission";
+import { KeyStorePrefixes, KeyStoreTtls, TKeyStoreFactory } from "@app/keystore/keystore";
+import { getCacheTtl, withCache } from "@app/lib/cache/with-cache";
+import { getConfig } from "@app/lib/config/env";
+import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { groupBy } from "@app/lib/fn";
+import { OrderByDirection, OrgServiceActor } from "@app/lib/types";
+import { ActorType } from "@app/services/auth/auth-type";
+import { TKmsServiceFactory } from "@app/services/kms/kms-service";
+import { KmsDataKey } from "@app/services/kms/kms-types";
+import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
+import { TSecretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";
+import { buildFolderIdMap, buildFolderPath } from "@app/services/secret-folder/secret-folder-fns";
+import { TSecretFolderVersionDALFactory } from "@app/services/secret-folder/secret-folder-version-dal";
+import { TSecretImportDALFactory } from "@app/services/secret-import/secret-import-dal";
+import { getAllSecretReferences } from "@app/services/secret-v2-bridge/secret-reference-fns";
+import { TSecretV2BridgeDALFactory } from "@app/services/secret-v2-bridge/secret-v2-bridge-dal";
+
+import {
+ classifySecretReads,
+ computeSecretReach,
+ indexSecretReads,
+ SECRET_READ_EVENT_TYPES,
+ toLocationKey
+} from "./secret-read-activity-fns";
+import {
+ SecretReadStatus,
+ TGetSecretReadActivityDTO,
+ TListUnusedSecretAccessDTO,
+ TReadActivityScope,
+ TSecretReachGraph,
+ TUnusedSecretAccess
+} from "./secret-read-activity-types";
+
+const SECRET_READ_ACTIVITY_WINDOW_DAYS = 30;
+
+type TSecretReadActivityServiceFactoryDep = {
+ permissionService: Pick<TPermissionServiceFactory, "getProjectPermission" | "getProjectPermissions">;
+ licenseService: Pick<TLicenseServiceFactory, "getPlan">;
+ auditLogSettingsService: Pick<TAuditLogSettingsServiceFactory, "getEffectiveSettings">;
+ auditLogDAL: Pick<TAuditLogDALFactory, "findLastSecretReads">;
+ clickhouseAuditLogDAL?: Pick<TClickHouseAuditLogDALFactory, "findLastSecretReads">;
+ folderDAL: Pick<TSecretFolderDALFactory, "findByProjectId">;
+ folderVersionDAL: Pick<TSecretFolderVersionDALFactory, "find">;
+ projectEnvDAL: Pick<TProjectEnvDALFactory, "find">;
+ secretImportDAL: Pick<TSecretImportDALFactory, "findByFolderIds">;
+ secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "find" | "findSecretReferencesByProjectId">;
+ kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
+ keyStore: Pick<TKeyStoreFactory, "setItemWithExpiry" | "getItem" | "ttl">;
+};
+
+export type TSecretReadActivityServiceFactory = ReturnType<typeof secretReadActivityServiceFactory>;
+
+export const secretReadActivityServiceFactory = ({
+ permissionService,
+ licenseService,
+ auditLogSettingsService,
+ auditLogDAL,
+ clickhouseAuditLogDAL,
+ folderDAL,
+ folderVersionDAL,
+ projectEnvDAL,
+ secretImportDAL,
+ secretV2BridgeDAL,
+ kmsService,
+ keyStore
+}: TSecretReadActivityServiceFactoryDep) => {
+ const $getReadActivity = async ({ projectId, orgId, windowDays, secret: requestedSecret }: TReadActivityScope) => {
+ const settings = await auditLogSettingsService.getEffectiveSettings(orgId, projectId);
+ if (!isAuditLogEventEnabled(settings, EventType.GET_SECRETS, projectId)) {
+ throw new BadRequestError({
+ message:
+ "Secret reads are not recorded for this project because data access audit logging is turned off. Turn it on in the project's audit log settings to see read activity."
+ });
+ }
+ const plan = await licenseService.getPlan(orgId);
+ if (!hasAuditLogRetention(plan)) {
+ throw new BadRequestError({
+ message: "Your plan does not retain audit logs, so secret read activity is unavailable."
+ });
+ }
+ const now = new Date();
+ const windowStart = new Date(
+ now.getTime() - Math.min(windowDays, plan.auditLogsRetentionDays ?? windowDays) * DAY_IN_MS
+ );
+
+ const [folders, environments] = await Promise.all([
+ folderDAL.findByProjectId(projectId),
+ projectEnvDAL.find({ projectId })
+ ]);
+ const folderById = buildFolderIdMap(folders);
+ const envById = new Map(environments.map((env) => [env.id, env]));
+ const paths = new Map<string, string>();
+ const pathOf = (folderId: string) => {
+ if (!paths.has(folderId)) paths.set(folderId, buildFolderPath(folderById[folderId], folderById));
+ return paths.get(folderId) as string;
+ };
+ const locationOf = (folderId: string) => {
+ const env = folderById[folderId] && envById.get(folderById[folderId].envId);
+ return env ? { environment: env.slug, secretPath: pathOf(folderId) } : undefined;
+ };
+ const ancestryOf = (folderId: string) => {
+ const chain: string[] = [];
+ let folder: TSecretFolders | undefined = folderById[folderId];
+ while (folder && !chain.includes(folder.id)) {
+ chain.push(folder.id);
+ folder = folder.parentId ? folderById[folder.parentId] : undefined;
+ }
+ return chain;
+ };
+
+ const requestedFolder =
+ requestedSecret &&
+ folders.find(
+ (folder) =>
+ locationOf(folder.id)?.environment === requestedSecret.environment &&
+ pathOf(folder.id) === requestedSecret.secretPath
+ );
+ if (requestedSecret && !requestedFolder) {
+ throw new NotFoundError({
+ message: `Folder with path '${requestedSecret.secretPath}' in environment '${requestedSecret.environment}' not found`
+ });
+ }
+ const scopeFolderIds = requestedFolder
+ ? [requestedFolder.id]
+ : folders.filter((folder) => !folder.isReserved).map((folder) => folder.id);
+
+ const referencesByLocation = groupBy(
+ await secretV2BridgeDAL.findSecretReferencesByProjectId(projectId),
+ (reference) => toLocationKey(reference)
+ );
+ const referencesOf = (folderId: string) => {
+ const location = locationOf(folderId);
+ return location ? (referencesByLocation[toLocationKey(location)] ?? []) : [];
+ };
+
+ // Secrets referencing a loaded one can sit outside the scope, so their folders are loaded too, until no
+ // new folders turn up.
+ type TSecret = Awaited<ReturnType<typeof secretV2BridgeDAL.find>>[number];
+ const secretsByFolder = new Map<string, TSecret[]>();
+ let pendingFolderIds = scopeFolderIds;
+ while (pendingFolderIds.length) {
+ const folderIds = pendingFolderIds;
+ // eslint-disable-next-line no-await-in-loop
+ const secrets = await secretV2BridgeDAL.find({
+ $in: { [`${TableName.SecretV2}.folderId` as "folderId"]: folderIds }
+ });
+ const secretsByFolderId = groupBy(secrets, (secret) => secret.folderId);
+ folderIds.forEach((folderId) => secretsByFolder.set(folderId, secretsByFolderId[folderId] ?? []));
+ pendingFolderIds = [...new Set(folderIds.flatMap(referencesOf).map((reference) => reference.folderId))].filter(
+ (folderId) => folderById[folderId] && !secretsByFolder.has(folderId)
+ );
+ }
+
+ const { decryptor } = await kmsService.createCipherPairWithDataKey({ type: KmsDataKey.SecretManager, projectId });
+ const localReferences = new Map<string, string[]>();
+ const localReferencesOf = (secret: TSecret) => {
+ if (!localReferences.has(secret.id)) {
+ localReferences.set(
+ secret.id,
+ secret.encryptedValue
+ ? getAllSecretReferences(decryptor({ cipherTextBlob: secret.encryptedValue }).toString()).localReferences
+ : []
+ );
+ }
+ return localReferences.get(secret.id) as string[];
+ };
+
+ const importsByLocation = groupBy(
+ await secretImportDAL.findByFolderIds(folders.map((folder) => folder.id)),
+ (secretImport) => toLocationKey({ environment: secretImport.importEnv.id, secretPath: secretImport.importPath })
+ );
+ const secretById = new Map([...secretsByFolder.values()].flat().map((secret) => [secret.id, secret]));
+ const graph: TSecretReachGraph = {
+ getReferencers: ({ id, folderId, key }) => [
+ ...(secretsByFolder.get(folderId) ?? []).filter(
+ (other) => other.id !== id && key !== undefined && localReferencesOf(other).includes(key)
+ ),
+ ...referencesOf(folderId)
+ .filter((reference) => reference.secretKey === key)
+ .map(
+ (reference) =>
+ secretById.get(reference.secretId) ?? { id: reference.secretId, folderId: reference.folderId }
+ )
+ ],
+ getImporterFolderIds: (folderId) =>
+ folderById[folderId]
+ ? (
+ importsByLocation[
+ toLocationKey({ environment: folderById[folderId].envId, secretPath: pathOf(folderId) })
+ ] ?? []
+ ).map((secretImport) => secretImport.folderId)
+ : [],
+ getParentFolderId: (folderId) => folderById[folderId]?.parentId,
+ getLocation: locationOf
+ };
+
+ const targets = scopeFolderIds.flatMap((folderId) => {
+ const location = locationOf(folderId);
+ if (!location) return [];
+ return (secretsByFolder.get(folderId) ?? [])
+ .filter(
+ (secret) =>
+ secret.type === SecretType.Shared && (!requestedSecret || secret.key === requestedSecret.secretName)
+ )
+ .map((secret) => ({ secret, ...location }));
+ });
+ const reaches = targets.map(({ secret }) => computeSecretReach(secret, graph));
+ const auditLogStore =
+ getConfig().CLICKHOUSE_AUDIT_LOG_ENABLED && clickhouseAuditLogDAL ? clickhouseAuditLogDAL : auditLogDAL;
+ const reads = indexSecretReads(
+ await auditLogStore.findLastSecretReads({
+ orgId,
+ projectId,
+ eventTypes: SECRET_READ_EVENT_TYPES,
+ environments: [...new Set(reaches.flatMap((reach) => [...reach.environments]))],
+ startDate: windowStart.toISOString(),
+ endDate: now.toISOString()
+ })
+ );
+
+ // A read can only match the secret's current path once that path exists, so the window starts no
+ // earlier than the last time the secret, its folders or its environment were created, renamed or moved.
+ // Folder versions are written on each of those.
+ const lastPathChangeAt = new Map<string, number>();
+ const chainFolderIds = [...new Set(scopeFolderIds.flatMap(ancestryOf))];
+ chainFolderIds.forEach((folderId) => lastPathChangeAt.set(folderId, folderById[folderId].createdAt.getTime()));
+ (await folderVersionDAL.find({ $in: { folderId: chainFolderIds } })).forEach(({ folderId, createdAt }) =>
+ lastPathChangeAt.set(folderId, Math.max(lastPathChangeAt.get(folderId) ?? 0, createdAt.getTime()))
+ );
+
+ return targets.map(({ secret, environment, secretPath }, index) => {
+ const trackedSince = new Date(
+ Math.max(
+ windowStart.getTime(),
+ secret.createdAt.getTime(),
+ envById.get(folderById[secret.folderId].envId)?.updatedAt.getTime() ?? 0,
+ ...ancestryOf(secret.folderId).map((folderId) => lastPathChangeAt.get(folderId) ?? 0)
+ )
+ );
+ return {
+ secret,
+ environment,
+ secretPath,
+ trackedSince,
+ reads: classifySecretReads(reads, reaches[index], trackedSince)
+ };
+ });
+ };
+
+ const getSecretReadActivity = async (
+ { projectId, environment, secretPath, secretName }: TGetSecretReadActivityDTO,
+ actor: OrgServiceActor
+ ) => {
+ const { permission } = await checkInsightsPermission(permissionService, licenseService, projectId, actor);
+
+ const [activity] = await $getReadActivity({
+ projectId,
+ orgId: actor.orgId,
+ windowDays: SECRET_READ_ACTIVITY_WINDOW_DAYS,
+ secret: { environment, secretPath, secretName }
+ });
+ if (!activity) {
+ throw new NotFoundError({
+ message: `Secret with name '${secretName}' not found at path '${secretPath}' in environment '${environment}'`
+ });
+ }
+ throwIfMissingSecretReadValueOrDescribePermission(permission, ProjectPermissionSecretActions.DescribeSecret, {
+ environment,
+ secretPath,
+ secretName,
+ secretTags: activity.secret.tags?.map((tag) => tag.slug)
+ });
+
+ return { trackedSince: activity.trackedSince, reads: [...activity.reads.values()] };
+ };
+
+ // Everyone who can read a secret's value but has not read it, ranked by the secrets with the most of them.
+ const $computeUnusedSecretAccess = async (projectId: string, orgId: string) => {
+ const activities = await $getReadActivity({ projectId, orgId, windowDays: SECRET_READ_ACTIVITY_WINDOW_DAYS });
+ const { userPermissions, identityPermissions } = await permissionService.getProjectPermissions(projectId, orgId);
+ // Principals with identical rules always get the same answer, so each distinct rule set is checked once.
+ const principalGroups = Object.values(
+ groupBy(
+ [
+ ...userPermissions.map((principal) => ({ ...principal, actorType: ActorType.USER as const })),
+ ...identityPermissions.map((principal) => ({ ...principal, actorType: ActorType.IDENTITY as const }))
+ ],
+ (principal) => JSON.stringify(principal.permission.rules)
+ )
+ );
+
+ const rowsBySecret: TUnusedSecretAccess[][] = [];
+ for (const { secret, environment, secretPath, trackedSince, reads } of activities) {
+ // Permission checks are synchronous, so yield between secrets to keep a large project from blocking other requests.
+ // eslint-disable-next-line no-await-in-loop
+ await new Promise<void>((resolve) => {
+ setImmediate(resolve);
+ });
+ const subjectFields = {
+ environment,
+ secretPath,
+ secretName: secret.key,
+ secretTags: secret.tags?.map((tag) => tag.slug)
+ };
+ rowsBySecret.push(
+ principalGroups
+ .filter(([{ permission }]) =>
+ hasSecretReadValueOrDescribePermission(permission, ProjectPermissionSecretActions.ReadValue, subjectFields)
+ )
+ .flat()
+ .flatMap((principal) => {
+ const read = reads.get(`${principal.actorType}:${principal.id}`);
+ if (read?.status === SecretReadStatus.Read) return [];
+ return {
+ secretKey: secret.key,
+ environment,
+ secretPath,
+ principalType: principal.actorType,
+ principalId: principal.id,
+ principalName: principal.name,
+ readStatus: read?.status ?? SecretReadStatus.NoReads,
+ lastReadAt: read?.lastReadAt ?? null,
+ trackedSince
+ };
+ })
+ );
+ }
+ return rowsBySecret.sort((a, b) => b.length - a.length).flat();
+ };
+
+ // The whole project is computed once and cached, so paging through it is cheap.
+ const listUnusedSecretAccess = async (
+ { projectId, offset, limit, orderBy, orderDirection }: TListUnusedSecretAccessDTO,
+ actor: OrgServiceActor
+ ) => {
+ await checkInsightsPermission(permissionService, licenseService, projectId, actor);
+
+ const cacheKey = KeyStorePrefixes.InsightsCache(projectId, "unused-secret-access");
+ const unusedAccess = await withCache({
+ keyStore,
+ key: cacheKey,
+ ttlSeconds: KeyStoreTtls.InsightsCacheInSeconds,
+ fetcher: () => $computeUnusedSecretAccess(projectId, actor.orgId),
+ reviver: (parsed) => {
+ reviveDates(parsed, "lastReadAt", "trackedSince");
+ }
+ });
+ const remainingTTL = await getCacheTtl(keyStore, cacheKey);
+
+ // Unsorted, the list keeps its ranking. The sort is stable, so ties keep it too.
+ const sorted = orderBy
+ ? [...unusedAccess].sort((a, b) => {
+ const [first, second] = orderDirection === OrderByDirection.DESC ? [b, a] : [a, b];
+ const firstValue = first[orderBy];
+ const secondValue = second[orderBy];
+ return firstValue instanceof Date && secondValue instanceof Date
+ ? firstValue.getTime() - secondValue.getTime()
+ : String(firstValue).localeCompare(String(secondValue));
+ })
+ : unusedAccess;
+
+ return {
+ unusedAccess: sorted.slice(offset, offset + limit),
+ totalCount: sorted.length,
+ remainingTTL
+ };
+ };
+
+ return { getSecretReadActivity, listUnusedSecretAccess };
+};
diff --git a/backend/src/ee/services/secret-read-activity/secret-read-activity-types.ts b/backend/src/ee/services/secret-read-activity/secret-read-activity-types.ts
new file mode 100644
index 0000000000..bfb8bd2f90
--- /dev/null
+++ b/backend/src/ee/services/secret-read-activity/secret-read-activity-types.ts
@@ -0,0 +1,82 @@
+import { TLastSecretRead } from "@app/ee/services/audit-log/audit-log-dal";
+import { OrderByDirection } from "@app/lib/types";
+
+export enum SecretReadStatus {
+ Read = "read",
+ // Only a parent folder was read. That returns the secret only if the read was recursive, which the
+ // audit log does not record.
+ PossiblyRead = "possibly-read",
+ NoReads = "no-reads"
+}
+
+export type TSecretReadActivity = {
+ actorType: TLastSecretRead["actor"];
+ actorId: string;
+ status: SecretReadStatus;
+ lastReadAt: Date;
+};
+
+// Everything whose read hands over this secret's value: the secret, every secret that references it,
+// and every folder that holds one of those or imports one that does.
+export type TSecretReach = {
+ secretIds: Set<string>;
+ locations: Set<string>;
+ parentLocations: Set<string>;
+ environments: Set<string>;
+};
+
+export type TReachSecret = { id: string; folderId: string; key?: string };
+
+export type TSecretLocation = { environment: string; secretPath: string };
+
+export type TSecretReachGraph = {
+ getReferencers: (secret: TReachSecret) => TReachSecret[];
+ getImporterFolderIds: (folderId: string) => string[];
+ getParentFolderId: (folderId: string) => string | null | undefined;
+ getLocation: (folderId: string) => TSecretLocation | undefined;
+};
+
+export type TGetSecretReadActivityDTO = {
+ projectId: string;
+ environment: string;
+ secretPath: string;
+ secretName: string;
+};
+
+// Without a secret, the whole project is in scope.
+export type TReadActivityScope = {
+ projectId: string;
+ orgId: string;
+ windowDays: number;
+ secret?: Omit<TGetSecretReadActivityDTO, "projectId">;
+};
+
+export type TUnusedSecretAccess = {
+ secretKey: string;
+ environment: string;
+ secretPath: string;
+ principalType: TLastSecretRead["actor"];
+ principalId: string;
+ principalName: string;
+ readStatus: SecretReadStatus;
+ lastReadAt: Date | null;
+ trackedSince: Date;
+};
+
+// Each value is the row field it sorts by.
+export enum UnusedSecretAccessOrderBy {
+ SecretKey = "secretKey",
+ Environment = "environment",
+ SecretPath = "secretPath",
+ Principal = "principalName",
+ Status = "readStatus",
+ TrackedSince = "trackedSince"
+}
+
+export type TListUnusedSecretAccessDTO = {
+ projectId: string;
+ offset: number;
+ limit: number;
+ orderBy?: UnusedSecretAccessOrderBy;
+ orderDirection: OrderByDirection;
+};
diff --git a/backend/src/lib/api-docs/constants.ts b/backend/src/lib/api-docs/constants.ts
index ae0c819636..27de0791ac 100644
--- a/backend/src/lib/api-docs/constants.ts
+++ b/backend/src/lib/api-docs/constants.ts
@@ -1455,6 +1455,12 @@ export const RAW_SECRETS = {
includeAllEntities:
"When true, includes all project users, identities, and groups in the response, even those without any access to the secret."
},
+ GET_READ_ACTIVITY: {
+ secretName: "The name of the secret to get read activity for.",
+ projectId: "The ID of the project where the secret is located.",
+ environment: "The slug of the environment where the secret is located.",
+ secretPath: "The folder path where the secret is located."
+ },
DUPLICATE_SECRET: {
projectId: "The ID of the project containing the secret.",
sourceEnvironment: "The slug of the source environment.",
diff --git a/backend/src/server/routes/index.ts b/backend/src/server/routes/index.ts
index 6cd06bb06e..36daf1b4e9 100644
--- a/backend/src/server/routes/index.ts
+++ b/backend/src/server/routes/index.ts
@@ -207,6 +207,7 @@ import { secretChangeGlobalPolicyBridgeDALFactory } from "@app/ee/services/secre
import { secretChangeGlobalPolicyBridgeServiceFactory } from "@app/ee/services/secret-change-global-policy-bridge/secret-change-global-policy-bridge-service";
import { secretChangeGlobalRequestBridgeDALFactory } from "@app/ee/services/secret-change-global-request-bridge/secret-change-global-request-bridge-dal";
import { secretChangeGlobalRequestBridgeServiceFactory } from "@app/ee/services/secret-change-global-request-bridge/secret-change-global-request-bridge-service";
+import { secretReadActivityServiceFactory } from "@app/ee/services/secret-read-activity/secret-read-activity-service";
import { secretReplicationServiceFactory } from "@app/ee/services/secret-replication/secret-replication-service";
import { secretRotationV2DALFactory } from "@app/ee/services/secret-rotation-v2/secret-rotation-v2-dal";
import { secretRotationV2QueueServiceFactory } from "@app/ee/services/secret-rotation-v2/secret-rotation-v2-queue";
@@ -3480,6 +3481,21 @@ export const registerRoutes = async (
secretValidationRuleService
});
+ const secretReadActivityService = secretReadActivityServiceFactory({
+ permissionService,
+ licenseService,
+ auditLogSettingsService,
+ auditLogDAL,
+ clickhouseAuditLogDAL,
+ folderDAL,
+ folderVersionDAL,
+ projectEnvDAL,
+ secretImportDAL,
+ secretV2BridgeDAL,
+ kmsService,
+ keyStore
+ });
+
const insightsService = insightsServiceFactory({
permissionService,
licenseService,
@@ -4737,6 +4753,7 @@ export const registerRoutes = async (
microsoftTeams: microsoftTeamsService,
assumePrivileges: assumePrivilegeService,
insights: insightsService,
+ secretReadActivity: secretReadActivityService,
auditReport: auditReportService,
githubOrgSync: githubOrgSyncConfigService,
gitHubApp: gitHubAppService,
diff --git a/backend/src/services/secret-v2-bridge/secret-v2-bridge-dal.ts b/backend/src/services/secret-v2-bridge/secret-v2-bridge-dal.ts
index 014d1d01f4..23af46d51a 100644
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-dal.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-dal.ts
@@ -1111,6 +1111,24 @@ export const secretV2BridgeDALFactory = ({ db, keyStore }: TSecretV2DalArg) => {
}
};
+ const findSecretReferencesByProjectId = async (projectId: string, tx?: Knex) => {
+ try {
+ const docs = await (tx || db.replicaNode())(TableName.SecretReferenceV2)
+ .whereNull(`${TableName.SecretReferenceV2}.targetProjectSlug`)
+ .join(TableName.SecretV2, `${TableName.SecretV2}.id`, `${TableName.SecretReferenceV2}.secretId`)
+ .join(TableName.SecretFolder, `${TableName.SecretV2}.folderId`, `${TableName.SecretFolder}.id`)
+ .join(TableName.Environment, `${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`)
+ .where("projectId", projectId)
+ .whereNull(`${TableName.Environment}.deleteAfter`)
+ .select(selectAllTableCols(TableName.SecretReferenceV2))
+ .select("folderId");
+
+ return docs;
+ } catch (error) {
+ throw new DatabaseError({ error, name: "FindSecretReferencesByProjectId" });
+ }
+ };
+
const findReferencedSecretReferencesBySecretKey = async (
projectId: string,
envSlug: string,
@@ -1827,6 +1845,7 @@ export const secretV2BridgeDALFactory = ({ db, keyStore }: TSecretV2DalArg) => {
findBySecretKeys,
upsertSecretReferences,
findReferencedSecretReferences,
+ findSecretReferencesByProjectId,
findAllProjectSecretValues,
findSecretsInFolderAfter,
batchSetBlindIndexes,
diff --git a/frontend/src/components/secrets/SecretReadStatusBadge.tsx b/frontend/src/components/secrets/SecretReadStatusBadge.tsx
new file mode 100644
index 0000000000..9bf54f3fe7
--- /dev/null
+++ b/frontend/src/components/secrets/SecretReadStatusBadge.tsx
@@ -0,0 +1,29 @@
+import { formatDistanceToNow } from "date-fns";
+
+import { Badge, Tooltip, TooltipContent, TooltipTrigger } from "@app/components/v3";
+import { SecretReadStatus } from "@app/hooks/api/secrets/types";
+
+type Props = {
+ status: SecretReadStatus;
+ lastReadAt?: string | null;
+};
+
+export const SecretReadStatusBadge = ({ status, lastReadAt }: Props) => {
+ if (status === SecretReadStatus.Read && lastReadAt) {
+ return <span>{formatDistanceToNow(new Date(lastReadAt))} ago</span>;
+ }
+ if (status === SecretReadStatus.PossiblyRead && lastReadAt) {
+ return (
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <Badge variant="warning">Possibly read</Badge>
+ </TooltipTrigger>
+ <TooltipContent>
+ A parent folder was read {formatDistanceToNow(new Date(lastReadAt))} ago. That returns
+ this secret only if the read was recursive.
+ </TooltipContent>
+ </Tooltip>
+ );
+ }
+ return <Badge variant="danger">No reads</Badge>;
+};
diff --git a/frontend/src/hooks/api/auditLogs/constants.tsx b/frontend/src/hooks/api/auditLogs/constants.tsx
index 8b01fbd474..710d240f5e 100644
--- a/frontend/src/hooks/api/auditLogs/constants.tsx
+++ b/frontend/src/hooks/api/auditLogs/constants.tsx
@@ -301,6 +301,8 @@ export const eventToNameMap: { [K in EventType]: string } = {
"View Secrets Management Calendar Insights",
[EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_VOLUME]:
"View Secrets Management Access Volume Insights",
+ [EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_UNUSED_ACCESS]:
+ "View Secrets Management Unused Access Insights",
[EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ORG_AUTH_METHOD_DISTRIBUTION]:
"View Organization Secrets Management Auth Method Distribution Insights",
[EventType.VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_LOCATIONS]:
diff --git a/frontend/src/hooks/api/auditLogs/enums.tsx b/frontend/src/hooks/api/auditLogs/enums.tsx
index 0915b412ab..baea88275c 100644
--- a/frontend/src/hooks/api/auditLogs/enums.tsx
+++ b/frontend/src/hooks/api/auditLogs/enums.tsx
@@ -294,6 +294,7 @@ export enum EventType {
VIEW_INSIGHTS_SECRETS_MANAGEMENT_CALENDAR = "view-insights-secrets-management-calendar",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_VOLUME = "view-insights-secrets-management-access-volume",
+ VIEW_INSIGHTS_SECRETS_MANAGEMENT_UNUSED_ACCESS = "view-insights-secrets-management-unused-access",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_ORG_AUTH_METHOD_DISTRIBUTION = "view-insights-secrets-management-org-auth-method-distribution",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_ACCESS_LOCATIONS = "view-insights-secrets-management-access-locations",
VIEW_INSIGHTS_SECRETS_MANAGEMENT_SUMMARY = "view-insights-secrets-management-summary",
diff --git a/frontend/src/hooks/api/secretInsights/index.ts b/frontend/src/hooks/api/secretInsights/index.ts
index 5cb2a2feff..145ff151d2 100644
--- a/frontend/src/hooks/api/secretInsights/index.ts
+++ b/frontend/src/hooks/api/secretInsights/index.ts
@@ -14,7 +14,8 @@ export {
// useGetSecretAccessLocations,
useGetSecretAccessVolume,
useGetSecretBlindIndexStatus,
- useGetSecretsDuplication
+ useGetSecretsDuplication,
+ useGetUnusedSecretAccess
} from "./queries";
export type {
TAccessLocation,
@@ -36,6 +37,7 @@ export type {
TGetSecretAccessVolumeResponse,
TGetSecretsDuplicationDTO,
TGetSecretsDuplicationResponse,
+ TGetUnusedSecretAccessDTO,
TOrgAuthMethodUsage,
TOrgDuplicatedSecretEntry,
TOrgDuplicatedSecretGroup,
@@ -48,5 +50,7 @@ export type {
TSearchSecretsByValueResponse,
TSecretAccessVolumeActor,
TSecretAccessVolumeDay,
- TSecretValueMatch
+ TSecretValueMatch,
+ TUnusedSecretAccess
} from "./types";
+export { UnusedSecretAccessOrderBy } from "./types";
diff --git a/frontend/src/hooks/api/secretInsights/queries.tsx b/frontend/src/hooks/api/secretInsights/queries.tsx
index a852b6b694..f5319bf34d 100644
--- a/frontend/src/hooks/api/secretInsights/queries.tsx
+++ b/frontend/src/hooks/api/secretInsights/queries.tsx
@@ -22,6 +22,8 @@ import {
TGetSecretBlindIndexStatusResponse,
TGetSecretsDuplicationDTO,
TGetSecretsDuplicationResponse,
+ TGetUnusedSecretAccessDTO,
+ TGetUnusedSecretAccessResponse,
TOrgAuthMethodUsage,
TOrgProjectsInsights,
TOrgSecretAccessVolume,
@@ -35,6 +37,8 @@ export const secretInsightsKeys = {
[...secretInsightsKeys.all(), "calendar-events", params] as const,
accessVolume: (params: TGetSecretAccessVolumeDTO) =>
[...secretInsightsKeys.all(), "access-volume", params] as const,
+ unusedSecretAccess: (params: TGetUnusedSecretAccessDTO) =>
+ [...secretInsightsKeys.all(), "unused-secret-access", params] as const,
// accessLocations: (params: TGetSecretAccessLocationsDTO) =>
// [...secretInsightsKeys.all(), "access-locations", params] as const,
authMethodDistribution: (params: TGetAuthMethodDistributionDTO) =>
@@ -119,6 +123,34 @@ export const useGetSecretAccessVolume = (
});
};
+export const useGetUnusedSecretAccess = (
+ params: TGetUnusedSecretAccessDTO,
+ options?: Omit<
+ UseQueryOptions<
+ TGetUnusedSecretAccessResponse,
+ unknown,
+ TGetUnusedSecretAccessResponse,
+ ReturnType<typeof secretInsightsKeys.unusedSecretAccess>
+ >,
+ "queryKey" | "queryFn"
+ >
+) => {
+ return useQuery({
+ queryKey: secretInsightsKeys.unusedSecretAccess(params),
+ queryFn: async () => {
+ const { projectId, ...query } = params;
+ const res = await apiRequest.get<Omit<TGetUnusedSecretAccessResponse, "remainingTtl">>(
+ `/api/v1/insights/${projectId}/secrets/unused-access`,
+ { params: query }
+ );
+ const remainingTtl = Number(res.headers["x-cache-ttl"] ?? -1);
+ return { ...res.data, remainingTtl };
+ },
+ staleTime: INSIGHTS_STALE_TIME,
+ ...options
+ });
+};
+
export const useGetAuthMethodDistribution = (
params: TGetAuthMethodDistributionDTO,
options?: Omit<
diff --git a/frontend/src/hooks/api/secretInsights/types.ts b/frontend/src/hooks/api/secretInsights/types.ts
index 0f183f015b..8ce9dc8b6d 100644
--- a/frontend/src/hooks/api/secretInsights/types.ts
+++ b/frontend/src/hooks/api/secretInsights/types.ts
@@ -1,4 +1,6 @@
+import { OrderByDirection } from "../generic/types";
import { IdentityAuthMethod } from "../identities/enums";
+import { SecretReadStatus } from "../secrets/types";
export type TCalendarRotation = {
id: string;
@@ -51,6 +53,41 @@ export type TGetSecretAccessVolumeDTO = {
projectId: string;
};
+export enum UnusedSecretAccessOrderBy {
+ SecretKey = "secretKey",
+ Environment = "environment",
+ SecretPath = "secretPath",
+ Principal = "principalName",
+ Status = "readStatus",
+ TrackedSince = "trackedSince"
+}
+
+export type TGetUnusedSecretAccessDTO = {
+ projectId: string;
+ offset: number;
+ limit: number;
+ orderBy?: UnusedSecretAccessOrderBy;
+ orderDirection?: OrderByDirection;
+};
+
+export type TUnusedSecretAccess = {
+ secretKey: string;
+ environment: string;
+ secretPath: string;
+ principalType: "user" | "identity";
+ principalId: string;
+ principalName: string;
+ readStatus: SecretReadStatus;
+ lastReadAt: string | null;
+ trackedSince: string;
+};
+
+export type TGetUnusedSecretAccessResponse = {
+ unusedAccess: TUnusedSecretAccess[];
+ totalCount: number;
+ remainingTtl: number;
+};
+
export type TGetInsightsSummaryDTO = {
projectId: string;
staleSecretsOffset?: number;
diff --git a/frontend/src/hooks/api/secrets/queries.tsx b/frontend/src/hooks/api/secrets/queries.tsx
index 51cb16aa98..f82093af15 100644
--- a/frontend/src/hooks/api/secrets/queries.tsx
+++ b/frontend/src/hooks/api/secrets/queries.tsx
@@ -22,10 +22,12 @@ import {
TGetProjectSecretsDTO,
TGetProjectSecretsKey,
TGetSecretAccessListDTO,
+ TGetSecretReadActivityDTO,
TGetSecretReferencesDTO,
TGetSecretReferenceTreeDTO,
TGetSecretVersionValue,
TSecretDependencyTreeNode,
+ TSecretReadActivity,
TSecretReferenceTraceNode,
TSecretVersionValue
} from "./types";
@@ -67,6 +69,13 @@ export const secretKeys = {
"secret-access-list",
{ projectId, environment, secretPath, secretKey, includeAllEntities }
] as const,
+ getSecretReadActivity: ({
+ projectId,
+ environment,
+ secretPath,
+ secretKey
+ }: TGetSecretReadActivityDTO) =>
+ ["secret-read-activity", { projectId, environment, secretPath, secretKey }] as const,
getSecretReferenceTree: (dto: TGetSecretReferenceTreeDTO) => ["secret-reference-tree", dto],
getSecretReferences: (dto: TGetSecretReferencesDTO) => ["secret-references", dto]
};
@@ -362,6 +371,30 @@ export const useGetSecretAccessList = (dto: TGetSecretAccessListDTO) =>
}
});
+export const useGetSecretReadActivity = (
+ dto: TGetSecretReadActivityDTO,
+ options?: Pick<UseQueryOptions<TSecretReadActivity>, "enabled">
+) =>
+ useQuery({
+ queryKey: secretKeys.getSecretReadActivity(dto),
+ queryFn: async () => {
+ const { data } = await apiRequest.get<{ readActivity: TSecretReadActivity }>(
+ `/api/v1/secrets/${encodeURIComponent(dto.secretKey)}/read-activity`,
+ {
+ params: {
+ projectId: dto.projectId,
+ environment: dto.environment,
+ secretPath: dto.secretPath
+ }
+ }
+ );
+
+ return data.readActivity;
+ },
+ ...options,
+ enabled: Boolean(dto.secretKey) && (options?.enabled ?? true)
+ });
+
const fetchSecretReferenceTree = async ({
secretPath,
projectId,
diff --git a/frontend/src/hooks/api/secrets/types.ts b/frontend/src/hooks/api/secrets/types.ts
index d4822f8c1e..3bf07e690b 100644
--- a/frontend/src/hooks/api/secrets/types.ts
+++ b/frontend/src/hooks/api/secrets/types.ts
@@ -160,6 +160,24 @@ export type TGetSecretAccessListDTO = {
includeAllEntities?: boolean;
};
+export type TGetSecretReadActivityDTO = Omit<TGetSecretAccessListDTO, "includeAllEntities">;
+
+export enum SecretReadStatus {
+ Read = "read",
+ PossiblyRead = "possibly-read",
+ NoReads = "no-reads"
+}
+
+export type TSecretReadActivity = {
+ trackedSince: string;
+ reads: {
+ actorType: "user" | "identity";
+ actorId: string;
+ status: SecretReadStatus;
+ lastReadAt: string;
+ }[];
+};
+
export type TCreateSecretsV3DTO = {
secretKey: string;
secretValue: string;
diff --git a/frontend/src/pages/secret-manager/InsightsPage/InsightsPage.tsx b/frontend/src/pages/secret-manager/InsightsPage/InsightsPage.tsx
index 1c70245edd..7ff4996c32 100644
--- a/frontend/src/pages/secret-manager/InsightsPage/InsightsPage.tsx
+++ b/frontend/src/pages/secret-manager/InsightsPage/InsightsPage.tsx
@@ -32,7 +32,8 @@ import {
CalendarCard,
DuplicatedSecretsCard,
InsightsSummaryCards,
- SecretAccessChart
+ SecretAccessChart,
+ UnusedSecretAccessCard
} from "./components";
export const InsightsPage = withProjectPermission(
@@ -135,6 +136,9 @@ export const InsightsPage = withProjectPermission(
<div className="mt-6">
<AuditReportsCard />
</div>
+ <div className="mt-6">
+ <UnusedSecretAccessCard />
+ </div>
<div className="mt-6 grid items-start gap-6 xl:grid-cols-[1.3fr_1fr]">
<div className="flex flex-col gap-6">
<DuplicatedSecretsCard />
diff --git a/frontend/src/pages/secret-manager/InsightsPage/components/UnusedSecretAccessCard.tsx b/frontend/src/pages/secret-manager/InsightsPage/components/UnusedSecretAccessCard.tsx
new file mode 100644
index 0000000000..0d7df8f7b9
--- /dev/null
+++ b/frontend/src/pages/secret-manager/InsightsPage/components/UnusedSecretAccessCard.tsx
@@ -0,0 +1,200 @@
+import axios from "axios";
+import { format } from "date-fns";
+import { ChevronDownIcon, FolderIcon, HardDriveIcon, KeyIcon, UserIcon } from "lucide-react";
+
+import { SecretReadStatusBadge } from "@app/components/secrets/SecretReadStatusBadge";
+import {
+ Badge,
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+ Empty,
+ EmptyDescription,
+ EmptyHeader,
+ EmptyTitle,
+ Pagination,
+ Skeleton,
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+ type TableSortDirection
+} from "@app/components/v3";
+import { cn } from "@app/components/v3/utils";
+import { useProject, useSubscription } from "@app/context";
+import { usePagination, useResetPageHelper } from "@app/hooks";
+import { OrderByDirection } from "@app/hooks/api/generic/types";
+import { UnusedSecretAccessOrderBy, useGetUnusedSecretAccess } from "@app/hooks/api/secretInsights";
+
+export const UnusedSecretAccessCard = () => {
+ const { currentProject, projectId } = useProject();
+ const { subscription } = useSubscription();
+ // An empty orderBy keeps the default ranking: the secrets with the most unused access first.
+ const {
+ page,
+ setPage,
+ perPage,
+ setPerPage,
+ offset,
+ limit,
+ orderBy,
+ setOrderBy,
+ orderDirection,
+ setOrderDirection
+ } = usePagination<UnusedSecretAccessOrderBy | "">("", { initPerPage: 20 });
+
+ const { data, isLoading, error } = useGetUnusedSecretAccess(
+ { projectId, offset, limit, orderBy: orderBy || undefined, orderDirection },
+ { enabled: Boolean(subscription?.secretAccessInsights) }
+ );
+ const totalCount = data?.totalCount ?? 0;
+ useResetPageHelper({ totalCount, offset, setPage });
+
+ const remainingMinutes =
+ data?.remainingTtl != null && data.remainingTtl >= 0
+ ? Math.max(1, Math.ceil(data.remainingTtl / 60))
+ : null;
+ const environmentNames = new Map(currentProject.environments.map((env) => [env.slug, env.name]));
+
+ const getSortDirection = (column: UnusedSecretAccessOrderBy): TableSortDirection => {
+ if (orderBy !== column) return "none";
+ return orderDirection === OrderByDirection.DESC ? "descending" : "ascending";
+ };
+
+ const handleSort = (column: UnusedSecretAccessOrderBy, direction: TableSortDirection) => {
+ setPage(1);
+ setOrderBy(direction === "none" ? "" : column);
+ setOrderDirection(direction === "descending" ? OrderByDirection.DESC : OrderByDirection.ASC);
+ };
+
+ const sortableColumns = [
+ { column: UnusedSecretAccessOrderBy.SecretKey, label: "Secret Key" },
+ { column: UnusedSecretAccessOrderBy.Environment, label: "Environment" },
+ { column: UnusedSecretAccessOrderBy.SecretPath, label: "Path" },
+ { column: UnusedSecretAccessOrderBy.Principal, label: "Principal" },
+ { column: UnusedSecretAccessOrderBy.Status, label: "Status" },
+ { column: UnusedSecretAccessOrderBy.TrackedSince, label: "Tracked Since" }
+ ];
+
+ return (
+ <Card>
+ <CardHeader>
+ <CardTitle>
+ Unused Secret Access
+ {remainingMinutes != null && (
+ <Badge variant="neutral" className="ml-2 font-normal">
+ Updates in {remainingMinutes} {remainingMinutes === 1 ? "minute" : "minutes"}
+ </Badge>
+ )}
+ </CardTitle>
+ <CardDescription>
+ Users and machine identities that can read a secret&apos;s value but have not read it, or
+ an import or reference of it, in the last 30 days
+ </CardDescription>
+ </CardHeader>
+ <CardContent>
+ {isLoading && <Skeleton className="h-[200px] w-full" />}
+ {Boolean(error) && (
+ <Empty className="border">
+ <EmptyHeader>
+ <EmptyTitle>Unused access could not be loaded</EmptyTitle>
+ <EmptyDescription>
+ {(axios.isAxiosError(error) &&
+ (error.response?.data as { message?: string })?.message) ||
+ "Try again in a moment."}
+ </EmptyDescription>
+ </EmptyHeader>
+ </Empty>
+ )}
+ {data && totalCount === 0 && (
+ <Empty className="border">
+ <EmptyHeader>
+ <EmptyTitle>No unused access</EmptyTitle>
+ <EmptyDescription>
+ Everyone who can read this project&apos;s secrets has read them in the last 30 days.
+ </EmptyDescription>
+ </EmptyHeader>
+ </Empty>
+ )}
+ {data && totalCount > 0 && (
+ <>
+ <Table>
+ <TableHeader>
+ <TableRow>
+ {sortableColumns.map(({ column, label }) => (
+ <TableHead
+ key={column}
+ sortDirection={getSortDirection(column)}
+ onSortChange={(direction) => handleSort(column, direction)}
+ >
+ {label}
+ <ChevronDownIcon
+ className={cn(
+ "transition-transform",
+ getSortDirection(column) === "descending" && "rotate-180",
+ getSortDirection(column) === "none" && "opacity-30"
+ )}
+ />
+ </TableHead>
+ ))}
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {data.unusedAccess.map((row) => {
+ const PrincipalIcon = row.principalType === "user" ? UserIcon : HardDriveIcon;
+ return (
+ <TableRow
+ key={`${row.environment}-${row.secretPath}-${row.secretKey}-${row.principalType}-${row.principalId}`}
+ >
+ <TableCell isTruncatable className="max-w-60">
+ <div className="flex items-center gap-2">
+ <KeyIcon className="size-4 shrink-0 text-muted" />
+ <span className="truncate font-mono">{row.secretKey}</span>
+ </div>
+ </TableCell>
+ <TableCell>
+ <Badge variant="info" isTruncatable className="max-w-full">
+ <span>{environmentNames.get(row.environment) ?? row.environment}</span>
+ </Badge>
+ </TableCell>
+ <TableCell isTruncatable className="max-w-48">
+ <div className="flex items-center gap-2">
+ <FolderIcon className="size-3.5 shrink-0 text-folder" />
+ <span className="truncate">{row.secretPath}</span>
+ </div>
+ </TableCell>
+ <TableCell isTruncatable className="max-w-60">
+ <div className="flex items-center gap-2">
+ <PrincipalIcon className="size-4 shrink-0 text-accent" />
+ <span className="truncate">{row.principalName}</span>
+ </div>
+ </TableCell>
+ <TableCell>
+ <SecretReadStatusBadge
+ status={row.readStatus}
+ lastReadAt={row.lastReadAt}
+ />
+ </TableCell>
+ <TableCell>{format(new Date(row.trackedSince), "PP")}</TableCell>
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ <Pagination
+ count={totalCount}
+ page={page}
+ perPage={perPage}
+ onChangePage={setPage}
+ onChangePerPage={setPerPage}
+ />
+ </>
+ )}
+ </CardContent>
+ </Card>
+ );
+};
diff --git a/frontend/src/pages/secret-manager/InsightsPage/components/index.ts b/frontend/src/pages/secret-manager/InsightsPage/components/index.ts
index 629fbd5337..1073b2a662 100644
--- a/frontend/src/pages/secret-manager/InsightsPage/components/index.ts
+++ b/frontend/src/pages/secret-manager/InsightsPage/components/index.ts
@@ -7,4 +7,5 @@ export { DuplicatedSecretsCard } from "./DuplicatedSecretsCard";
export { InsightsSummaryCards } from "./InsightsSummaryCards";
export { SecretAccessChart } from "./SecretAccessChart";
export type { CalendarEvent } from "./types";
+export { UnusedSecretAccessCard } from "./UnusedSecretAccessCard";
// export { WorldMap } from "./WorldMap";
diff --git a/frontend/src/pages/secret-manager/OverviewPage/components/SecretTableRow/SecretAccessInsights.tsx b/frontend/src/pages/secret-manager/OverviewPage/components/SecretTableRow/SecretAccessInsights.tsx
index 18b4a2375f..5426d98d13 100644
--- a/frontend/src/pages/secret-manager/OverviewPage/components/SecretTableRow/SecretAccessInsights.tsx
+++ b/frontend/src/pages/secret-manager/OverviewPage/components/SecretTableRow/SecretAccessInsights.tsx
@@ -1,6 +1,8 @@
import { useMemo, useRef, useState } from "react";
import { subject } from "@casl/ability";
import { Link } from "@tanstack/react-router";
+import axios from "axios";
+import { format } from "date-fns";
import {
BanIcon,
CheckIcon,
@@ -18,6 +20,7 @@ import {
} from "lucide-react";
import { createNotification } from "@app/components/notifications";
+import { SecretReadStatusBadge } from "@app/components/secrets/SecretReadStatusBadge";
import {
Button,
Command,
@@ -75,6 +78,7 @@ import {
} from "@app/context";
import {
PermissionConditionOperators,
+ ProjectPermissionInsightsActions,
ProjectPermissionSecretActions
} from "@app/context/ProjectPermissionContext/types";
import { getProjectBaseURL } from "@app/helpers/project";
@@ -86,8 +90,8 @@ import {
} from "@app/hooks/api";
import { useGetAvailableOrgUsers } from "@app/hooks/api/organization/queries";
import { useCreateProjectUserAdditionalPrivilege } from "@app/hooks/api/projectUserAdditionalPrivilege";
-import { useGetSecretAccessList } from "@app/hooks/api/secrets/queries";
-import { SecretAccessListEntry } from "@app/hooks/api/secrets/types";
+import { useGetSecretAccessList, useGetSecretReadActivity } from "@app/hooks/api/secrets/queries";
+import { SecretAccessListEntry, SecretReadStatus } from "@app/hooks/api/secrets/types";
import { IdentityProjectAdditionalPrivilegeModifySection } from "@app/pages/project/IdentityDetailsByIDPage/components/IdentityProjectAdditionalPrivilegeSection/IdentityProjectAdditionalPrivilegeModifySection";
import { MembershipProjectAdditionalPrivilegeModifySection } from "@app/pages/project/MemberDetailsByIDPage/components/MemberProjectAdditionalPrivilegeSection/MembershipProjectAdditionalPrivilegeModifySection";
@@ -464,6 +468,47 @@ export function SecretAccessInsights({ secretKey, environment, secretPath }: Pro
includeAllEntities: showAllEntities
});
+ const canReadInsights = permission.can(
+ ProjectPermissionInsightsActions.Read,
+ ProjectPermissionSub.Insights
+ );
+ const {
+ data: readActivity,
+ isLoading: isReadActivityLoading,
+ error: readActivityError
+ } = useGetSecretReadActivity(
+ { projectId: currentProject.id, environment, secretPath, secretKey },
+ { enabled: canReadInsights }
+ );
+ const lastReads = useMemo(
+ () => new Map(readActivity?.reads.map((read) => [`${read.actorType}:${read.actorId}`, read])),
+ [readActivity]
+ );
+
+ let readActivityDescription = "Loading read activity...";
+ if (readActivityError) {
+ readActivityDescription =
+ (axios.isAxiosError(readActivityError) &&
+ (readActivityError.response?.data as { message?: string })?.message) ||
+ "Read activity is unavailable.";
+ } else if (readActivity) {
+ readActivityDescription = `Reads by users and machine identities since ${format(new Date(readActivity.trackedSince), "PP")}, including reads through imports and references.`;
+ }
+
+ const renderLastRead = (row: AccessRow) => {
+ if (row.type === "group") return null;
+ if (isReadActivityLoading) return <Skeleton className="h-4 w-20 rounded" />;
+ if (!readActivity) return null;
+
+ const read = lastReads.get(`${row.type}:${row.entry.id}`);
+ return (
+ <SecretReadStatusBadge
+ status={read?.status ?? SecretReadStatus.NoReads}
+ lastReadAt={read?.lastReadAt}
+ />
+ );
+ };
+
const flatRows = useMemo<AccessRow[]>(() => {
if (!secretAccessList) return [];
const baseUrl = getProjectBaseURL(currentProject.type);
@@ -706,6 +751,19 @@ export function SecretAccessInsights({ secretKey, environment, secretPath }: Pro
<TableHead className="border-b-0 shadow-[inset_0_-1px_0_var(--color-border)]">
Name
</TableHead>
+ {canReadInsights && (
+ <TableHead className="w-40 border-b-0 shadow-[inset_0_-1px_0_var(--color-border)]">
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <span className="inline-flex items-center gap-1">
+ Last Read
+ <InfoIcon className="size-3.5 text-muted" />
+ </span>
+ </TooltipTrigger>
+ <TooltipContent>{readActivityDescription}</TooltipContent>
+ </Tooltip>
+ </TableHead>
+ )}
{visibleColumns.map((col) => (
<TableHead
key={col.action}
@@ -764,6 +822,11 @@ export function SecretAccessInsights({ secretKey, environment, secretPath }: Pro
)}
</div>
</TableCell>
+ {canReadInsights && (
+ <TableCell className="w-40 whitespace-nowrap">
+ {renderLastRead(row)}
+ </TableCell>
+ )}
{visibleColumns.map((col) => {
const hasDirect = row.entry.allowedActions.includes(col.action);
const hasInherited = row.inheritedActions?.has(col.action);