Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
init
Dimitris Staratzis3fe218d64b8a
diff --git a/backend/CLAUDE.md b/backend/CLAUDE.mdindex 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 thethe table is a `ReplacingMergeTree`: a retried batch inserts the same `id` twice and the copy goes awayonly 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 SettingsEvery `EventType` belongs to exactly one class indiff --git a/backend/src/@types/fastify.d.ts b/backend/src/@types/fastify.d.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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| ViewInsightsAuthMethodsEventdiff --git a/backend/src/ee/services/insights/insights-service.ts b/backend/src/ee/services/insights/insights-service.tsindex 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: OrgServiceActordiff --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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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/secreimport { 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.tsindex 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.tsxnew file mode 100644index 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.tsxindex 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.tsxindex 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.tsindex 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.tsxindex 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.tsindex 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.tsxindex 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.tsindex 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.tsxindex 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.tsxnew file mode 100644index 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'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'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.tsindex 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.tsxindex 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 }: ProincludeAllEntities: 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) => (<TableHeadkey={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);