From a3a0308b62870254cb27886521160b9fa0f95834 Mon Sep 17 00:00:00 2001 From: wizardchen Date: Wed, 22 Jul 2026 19:15:27 +0800 Subject: [PATCH] feat(knowledge): add scoped activity audit trail --- docs/RBAC说明.md | 4 + docs/docs.go | 154 +++- docs/swagger.json | 154 +++- docs/swagger.yaml | 119 +++ frontend/src/api/knowledge-base/index.ts | 25 + frontend/src/api/tenant/audit-log.ts | 4 +- frontend/src/i18n/locales/en-US.ts | 31 + frontend/src/i18n/locales/ko-KR.ts | 31 + frontend/src/i18n/locales/ru-RU.ts | 31 + frontend/src/i18n/locales/zh-CN.ts | 56 ++ .../src/views/knowledge/KnowledgeBase.vue | 3 + .../knowledge/KnowledgeBaseEditorModal.vue | 28 + .../KnowledgeBaseActivitySettings.vue | 783 ++++++++++++++++++ internal/application/repository/audit_log.go | 9 + .../repository/audit_log_scope_test.go | 51 ++ .../application/service/datasource_service.go | 57 +- internal/application/service/kb_activity.go | 132 +++ .../application/service/kb_activity_test.go | 63 ++ internal/application/service/kbshare.go | 27 +- internal/application/service/knowledge.go | 3 + .../service/knowledge_clone_move.go | 51 +- .../application/service/knowledge_create.go | 135 ++- .../application/service/knowledge_delete.go | 18 + internal/application/service/knowledge_faq.go | 16 +- .../application/service/knowledge_process.go | 19 +- internal/application/service/knowledgebase.go | 32 + internal/application/service/tag.go | 22 +- .../application/service/wiki_log_entry.go | 44 +- internal/datasource/scheduler.go | 1 + internal/handler/audit_log.go | 91 +- internal/handler/audit_log_test.go | 78 ++ internal/handler/knowledge.go | 3 + internal/handler/knowledgebase.go | 9 +- internal/router/router.go | 12 + internal/types/audit_log.go | 63 +- internal/types/context_helpers.go | 33 + internal/types/datasource.go | 3 + internal/types/interfaces/audit_log.go | 13 +- internal/types/task.go | 44 +- internal/types/task_initiator_test.go | 36 + .../sqlite/000001_kb_activity_scope.down.sql | 4 + .../sqlite/000001_kb_activity_scope.up.sql | 5 + .../000073_kb_activity_scope.down.sql | 5 + .../versioned/000073_kb_activity_scope.up.sql | 8 + 44 files changed, 2429 insertions(+), 81 deletions(-) create mode 100644 frontend/src/views/knowledge/settings/KnowledgeBaseActivitySettings.vue create mode 100644 internal/application/repository/audit_log_scope_test.go create mode 100644 internal/application/service/kb_activity.go create mode 100644 internal/application/service/kb_activity_test.go create mode 100644 internal/types/task_initiator_test.go create mode 100644 migrations/sqlite/000001_kb_activity_scope.down.sql create mode 100644 migrations/sqlite/000001_kb_activity_scope.up.sql create mode 100644 migrations/versioned/000073_kb_activity_scope.down.sql create mode 100644 migrations/versioned/000073_kb_activity_scope.up.sql diff --git a/docs/RBAC说明.md b/docs/RBAC说明.md index 3aa24fd6..aa6ae2e7 100644 --- a/docs/RBAC说明.md +++ b/docs/RBAC说明.md @@ -148,6 +148,10 @@ audit: `access_denied` 采用 1 分钟滑动窗口去重,防止恶意探测刷表;同样的拒绝在应用日志(`[rbac] role insufficient ...`)里仍然条条可见。 +知识库活动记录也复用这张不可变审计表,通过 `scope_type=knowledge_base`、`scope_id=` 建立范围索引,而不是为每个知识库创建独立日志表。`GET /api/v1/knowledge-bases/:id/activity` 提供游标分页,覆盖知识库配置、知识/FAQ、标签、数据源、共享、克隆/移动任务和 Wiki 内容变更;原有空间审计接口只返回无资源范围的 RBAC 事件,避免知识库活动淹没成员与拒绝记录。解析阶段明细继续由 knowledge spans 展示,数据源同步明细继续由 sync logs 展示,活动记录只保存摘要与关联 ID。 + +该接口仅知识库创建者或所属空间 Admin+ 可读,并明确拒绝从组织共享空间读取,避免向接收方泄露源空间操作者与配置历史。活动详情不得写入知识正文、外部 URL、数据源凭据或原始错误堆栈。 + 后台 goroutine `AuditLogRetentionRunner` 启动 ~10 分钟后开始首轮清理,之后每 24 小时清扫一次超过 `audit.retention_days` 的旧行;保留期为 `0` 时整条 goroutine 短路,不产生任何 DB 流量。 ## 七、灰度上线建议 diff --git a/docs/docs.go b/docs/docs.go index 814284b8..5222aa52 100644 --- a/docs/docs.go +++ b/docs/docs.go @@ -3962,6 +3962,76 @@ const docTemplate = `{ } } }, + "/knowledge-bases/{id}/activity": { + "get": { + "security": [ + { + "Bearer": [] + } + ], + "description": "返回知识库的重要变更与后台任务入口。仅知识库创建者或所属空间管理员可读,共享空间不可读。", + "produces": [ + "application/json" + ], + "tags": [ + "知识库" + ], + "summary": "获取知识库活动记录", + "parameters": [ + { + "type": "string", + "description": "知识库ID", + "name": "id", + "in": "path", + "required": true + }, + { + "type": "integer", + "description": "游标:返回 id 小于此值的记录", + "name": "after_id", + "in": "query" + }, + { + "type": "integer", + "description": "页大小,1-100,默认 50", + "name": "limit", + "in": "query" + }, + { + "type": "string", + "description": "按 action 精确过滤", + "name": "action", + "in": "query" + }, + { + "type": "string", + "description": "按 outcome 精确过滤", + "name": "outcome", + "in": "query" + }, + { + "type": "string", + "description": "按 actor_user_id 精确过滤", + "name": "actor", + "in": "query" + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/internal_handler.auditLogListResponse" + } + }, + "403": { + "description": "Forbidden", + "schema": { + "$ref": "#/definitions/github_com_Tencent_WeKnora_internal_errors.AppError" + } + } + } + } + }, "/knowledge-bases/{id}/duplicate": { "post": { "security": [ @@ -14849,7 +14919,38 @@ const docTemplate = `{ "system.queue_task_retried", "system.queue_task_deleted", "system.queue_task_run_now", - "system.queue_task_cancelled" + "system.queue_task_cancelled", + "kb.created", + "kb.updated", + "kb.deleted", + "kb.duplicated", + "kb.clone_started", + "kb.clone_completed", + "kb.clone_failed", + "knowledge.created", + "knowledge.updated", + "knowledge.deleted", + "knowledge.batch_deleted", + "knowledge.reparse_started", + "knowledge.parse_canceled", + "knowledge.move_started", + "knowledge.move_completed", + "knowledge.move_failed", + "tag.created", + "tag.updated", + "tag.deleted", + "datasource.created", + "datasource.updated", + "datasource.deleted", + "datasource.sync_started", + "datasource.sync_completed", + "datasource.sync_failed", + "datasource.paused", + "datasource.resumed", + "kb.share_added", + "kb.share_permission_changed", + "kb.share_removed", + "wiki.content_changed" ], "x-enum-varnames": [ "AuditActionMemberAdded", @@ -14877,7 +14978,38 @@ const docTemplate = `{ "AuditActionSystemQueueTaskRetried", "AuditActionSystemQueueTaskDeleted", "AuditActionSystemQueueTaskRunNow", - "AuditActionSystemQueueTaskCancelled" + "AuditActionSystemQueueTaskCancelled", + "AuditActionKBCreated", + "AuditActionKBUpdated", + "AuditActionKBDeleted", + "AuditActionKBDuplicated", + "AuditActionKBCloneStarted", + "AuditActionKBCloneCompleted", + "AuditActionKBCloneFailed", + "AuditActionKnowledgeCreated", + "AuditActionKnowledgeUpdated", + "AuditActionKnowledgeDeleted", + "AuditActionKnowledgeBatchDeleted", + "AuditActionKnowledgeReparseStarted", + "AuditActionKnowledgeParseCanceled", + "AuditActionKnowledgeMoveStarted", + "AuditActionKnowledgeMoveCompleted", + "AuditActionKnowledgeMoveFailed", + "AuditActionTagCreated", + "AuditActionTagUpdated", + "AuditActionTagDeleted", + "AuditActionDataSourceCreated", + "AuditActionDataSourceUpdated", + "AuditActionDataSourceDeleted", + "AuditActionDataSourceSyncStarted", + "AuditActionDataSourceSyncCompleted", + "AuditActionDataSourceSyncFailed", + "AuditActionDataSourcePaused", + "AuditActionDataSourceResumed", + "AuditActionKBShareAdded", + "AuditActionKBSharePermissionChanged", + "AuditActionKBShareRemoved", + "AuditActionWikiContentChanged" ] }, "github_com_Tencent_WeKnora_internal_types.AuditLog": { @@ -14913,6 +15045,12 @@ const docTemplate = `{ "request_path": { "type": "string" }, + "scope_id": { + "type": "string" + }, + "scope_type": { + "type": "string" + }, "target_id": { "type": "string" }, @@ -14931,11 +15069,19 @@ const docTemplate = `{ "type": "string", "enum": [ "success", - "denied" + "accepted", + "denied", + "failed", + "partial", + "canceled" ], "x-enum-varnames": [ "AuditOutcomeSuccess", - "AuditOutcomeDenied" + "AuditOutcomeAccepted", + "AuditOutcomeDenied", + "AuditOutcomeFailed", + "AuditOutcomePartial", + "AuditOutcomeCanceled" ] }, "github_com_Tencent_WeKnora_internal_types.COSEngineConfig": { diff --git a/docs/swagger.json b/docs/swagger.json index adb651a6..de8bf495 100644 --- a/docs/swagger.json +++ b/docs/swagger.json @@ -3955,6 +3955,76 @@ } } }, + "/knowledge-bases/{id}/activity": { + "get": { + "security": [ + { + "Bearer": [] + } + ], + "description": "返回知识库的重要变更与后台任务入口。仅知识库创建者或所属空间管理员可读,共享空间不可读。", + "produces": [ + "application/json" + ], + "tags": [ + "知识库" + ], + "summary": "获取知识库活动记录", + "parameters": [ + { + "type": "string", + "description": "知识库ID", + "name": "id", + "in": "path", + "required": true + }, + { + "type": "integer", + "description": "游标:返回 id 小于此值的记录", + "name": "after_id", + "in": "query" + }, + { + "type": "integer", + "description": "页大小,1-100,默认 50", + "name": "limit", + "in": "query" + }, + { + "type": "string", + "description": "按 action 精确过滤", + "name": "action", + "in": "query" + }, + { + "type": "string", + "description": "按 outcome 精确过滤", + "name": "outcome", + "in": "query" + }, + { + "type": "string", + "description": "按 actor_user_id 精确过滤", + "name": "actor", + "in": "query" + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/internal_handler.auditLogListResponse" + } + }, + "403": { + "description": "Forbidden", + "schema": { + "$ref": "#/definitions/github_com_Tencent_WeKnora_internal_errors.AppError" + } + } + } + } + }, "/knowledge-bases/{id}/duplicate": { "post": { "security": [ @@ -14842,7 +14912,38 @@ "system.queue_task_retried", "system.queue_task_deleted", "system.queue_task_run_now", - "system.queue_task_cancelled" + "system.queue_task_cancelled", + "kb.created", + "kb.updated", + "kb.deleted", + "kb.duplicated", + "kb.clone_started", + "kb.clone_completed", + "kb.clone_failed", + "knowledge.created", + "knowledge.updated", + "knowledge.deleted", + "knowledge.batch_deleted", + "knowledge.reparse_started", + "knowledge.parse_canceled", + "knowledge.move_started", + "knowledge.move_completed", + "knowledge.move_failed", + "tag.created", + "tag.updated", + "tag.deleted", + "datasource.created", + "datasource.updated", + "datasource.deleted", + "datasource.sync_started", + "datasource.sync_completed", + "datasource.sync_failed", + "datasource.paused", + "datasource.resumed", + "kb.share_added", + "kb.share_permission_changed", + "kb.share_removed", + "wiki.content_changed" ], "x-enum-varnames": [ "AuditActionMemberAdded", @@ -14870,7 +14971,38 @@ "AuditActionSystemQueueTaskRetried", "AuditActionSystemQueueTaskDeleted", "AuditActionSystemQueueTaskRunNow", - "AuditActionSystemQueueTaskCancelled" + "AuditActionSystemQueueTaskCancelled", + "AuditActionKBCreated", + "AuditActionKBUpdated", + "AuditActionKBDeleted", + "AuditActionKBDuplicated", + "AuditActionKBCloneStarted", + "AuditActionKBCloneCompleted", + "AuditActionKBCloneFailed", + "AuditActionKnowledgeCreated", + "AuditActionKnowledgeUpdated", + "AuditActionKnowledgeDeleted", + "AuditActionKnowledgeBatchDeleted", + "AuditActionKnowledgeReparseStarted", + "AuditActionKnowledgeParseCanceled", + "AuditActionKnowledgeMoveStarted", + "AuditActionKnowledgeMoveCompleted", + "AuditActionKnowledgeMoveFailed", + "AuditActionTagCreated", + "AuditActionTagUpdated", + "AuditActionTagDeleted", + "AuditActionDataSourceCreated", + "AuditActionDataSourceUpdated", + "AuditActionDataSourceDeleted", + "AuditActionDataSourceSyncStarted", + "AuditActionDataSourceSyncCompleted", + "AuditActionDataSourceSyncFailed", + "AuditActionDataSourcePaused", + "AuditActionDataSourceResumed", + "AuditActionKBShareAdded", + "AuditActionKBSharePermissionChanged", + "AuditActionKBShareRemoved", + "AuditActionWikiContentChanged" ] }, "github_com_Tencent_WeKnora_internal_types.AuditLog": { @@ -14906,6 +15038,12 @@ "request_path": { "type": "string" }, + "scope_id": { + "type": "string" + }, + "scope_type": { + "type": "string" + }, "target_id": { "type": "string" }, @@ -14924,11 +15062,19 @@ "type": "string", "enum": [ "success", - "denied" + "accepted", + "denied", + "failed", + "partial", + "canceled" ], "x-enum-varnames": [ "AuditOutcomeSuccess", - "AuditOutcomeDenied" + "AuditOutcomeAccepted", + "AuditOutcomeDenied", + "AuditOutcomeFailed", + "AuditOutcomePartial", + "AuditOutcomeCanceled" ] }, "github_com_Tencent_WeKnora_internal_types.COSEngineConfig": { diff --git a/docs/swagger.yaml b/docs/swagger.yaml index df32883e..249774aa 100644 --- a/docs/swagger.yaml +++ b/docs/swagger.yaml @@ -300,6 +300,37 @@ definitions: - system.queue_task_deleted - system.queue_task_run_now - system.queue_task_cancelled + - kb.created + - kb.updated + - kb.deleted + - kb.duplicated + - kb.clone_started + - kb.clone_completed + - kb.clone_failed + - knowledge.created + - knowledge.updated + - knowledge.deleted + - knowledge.batch_deleted + - knowledge.reparse_started + - knowledge.parse_canceled + - knowledge.move_started + - knowledge.move_completed + - knowledge.move_failed + - tag.created + - tag.updated + - tag.deleted + - datasource.created + - datasource.updated + - datasource.deleted + - datasource.sync_started + - datasource.sync_completed + - datasource.sync_failed + - datasource.paused + - datasource.resumed + - kb.share_added + - kb.share_permission_changed + - kb.share_removed + - wiki.content_changed type: string x-enum-varnames: - AuditActionMemberAdded @@ -328,6 +359,37 @@ definitions: - AuditActionSystemQueueTaskDeleted - AuditActionSystemQueueTaskRunNow - AuditActionSystemQueueTaskCancelled + - AuditActionKBCreated + - AuditActionKBUpdated + - AuditActionKBDeleted + - AuditActionKBDuplicated + - AuditActionKBCloneStarted + - AuditActionKBCloneCompleted + - AuditActionKBCloneFailed + - AuditActionKnowledgeCreated + - AuditActionKnowledgeUpdated + - AuditActionKnowledgeDeleted + - AuditActionKnowledgeBatchDeleted + - AuditActionKnowledgeReparseStarted + - AuditActionKnowledgeParseCanceled + - AuditActionKnowledgeMoveStarted + - AuditActionKnowledgeMoveCompleted + - AuditActionKnowledgeMoveFailed + - AuditActionTagCreated + - AuditActionTagUpdated + - AuditActionTagDeleted + - AuditActionDataSourceCreated + - AuditActionDataSourceUpdated + - AuditActionDataSourceDeleted + - AuditActionDataSourceSyncStarted + - AuditActionDataSourceSyncCompleted + - AuditActionDataSourceSyncFailed + - AuditActionDataSourcePaused + - AuditActionDataSourceResumed + - AuditActionKBShareAdded + - AuditActionKBSharePermissionChanged + - AuditActionKBShareRemoved + - AuditActionWikiContentChanged github_com_Tencent_WeKnora_internal_types.AuditLog: properties: action: @@ -350,6 +412,10 @@ definitions: type: string request_path: type: string + scope_id: + type: string + scope_type: + type: string target_id: type: string target_type: @@ -362,11 +428,19 @@ definitions: github_com_Tencent_WeKnora_internal_types.AuditOutcome: enum: - success + - accepted - denied + - failed + - partial + - canceled type: string x-enum-varnames: - AuditOutcomeSuccess + - AuditOutcomeAccepted - AuditOutcomeDenied + - AuditOutcomeFailed + - AuditOutcomePartial + - AuditOutcomeCanceled github_com_Tencent_WeKnora_internal_types.COSEngineConfig: properties: app_id: @@ -8120,6 +8194,51 @@ paths: summary: 更新知识库 tags: - 知识库 + /knowledge-bases/{id}/activity: + get: + description: 返回知识库的重要变更与后台任务入口。仅知识库创建者或所属空间管理员可读,共享空间不可读。 + parameters: + - description: 知识库ID + in: path + name: id + required: true + type: string + - description: 游标:返回 id 小于此值的记录 + in: query + name: after_id + type: integer + - description: 页大小,1-100,默认 50 + in: query + name: limit + type: integer + - description: 按 action 精确过滤 + in: query + name: action + type: string + - description: 按 outcome 精确过滤 + in: query + name: outcome + type: string + - description: 按 actor_user_id 精确过滤 + in: query + name: actor + type: string + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/internal_handler.auditLogListResponse' + "403": + description: Forbidden + schema: + $ref: '#/definitions/github_com_Tencent_WeKnora_internal_errors.AppError' + security: + - Bearer: [] + summary: 获取知识库活动记录 + tags: + - 知识库 /knowledge-bases/{id}/duplicate: post: consumes: diff --git a/frontend/src/api/knowledge-base/index.ts b/frontend/src/api/knowledge-base/index.ts index b19572a3..37cf86ea 100644 --- a/frontend/src/api/knowledge-base/index.ts +++ b/frontend/src/api/knowledge-base/index.ts @@ -1,5 +1,30 @@ import { get, post, put, del, postUpload, getDown } from "../../utils/request"; import type { KnowledgeProcessOverrides } from '@/types/knowledgeProcess'; +import type { AuditLog, AuditOutcome, ListAuditLogResponse } from '@/api/tenant/audit-log'; + +export type KnowledgeBaseActivity = AuditLog; + +export interface ListKnowledgeBaseActivityParams { + after_id?: number; + limit?: number; + action?: string; + outcome?: AuditOutcome; + actor?: string; +} + +export async function listKnowledgeBaseActivity( + id: string, + params: ListKnowledgeBaseActivityParams = {}, +): Promise { + const query = new URLSearchParams(); + if (params.after_id) query.set('after_id', String(params.after_id)); + if (params.limit) query.set('limit', String(params.limit)); + if (params.action) query.set('action', params.action); + if (params.outcome) query.set('outcome', params.outcome); + if (params.actor) query.set('actor', params.actor); + const qs = query.toString(); + return (await get(`/api/v1/knowledge-bases/${id}/activity${qs ? `?${qs}` : ''}`)) as unknown as ListAuditLogResponse; +} // 知识库管理 API(列表、创建、获取、更新、删除、复制) export function listKnowledgeBases(params?: { diff --git a/frontend/src/api/tenant/audit-log.ts b/frontend/src/api/tenant/audit-log.ts index 3884eca5..9270fd00 100644 --- a/frontend/src/api/tenant/audit-log.ts +++ b/frontend/src/api/tenant/audit-log.ts @@ -13,7 +13,7 @@ export type AuditAction = | 'rbac.access_denied' | string // forward-compat: future namespaces shouldn't break the type -export type AuditOutcome = 'success' | 'denied' +export type AuditOutcome = 'accepted' | 'success' | 'failed' | 'partial' | 'canceled' | 'denied' // AuditLog mirrors internal/types/audit_log.go. `details` is the JSONB // blob — for role changes it carries `{"old_role":..., "new_role":...}`, @@ -26,6 +26,8 @@ export interface AuditLog { actor_user_id: string actor_role: string action: AuditAction + scope_type: string + scope_id: string target_type: string target_id: string target_user_id: string diff --git a/frontend/src/i18n/locales/en-US.ts b/frontend/src/i18n/locales/en-US.ts index da620f66..171be1ef 100755 --- a/frontend/src/i18n/locales/en-US.ts +++ b/frontend/src/i18n/locales/en-US.ts @@ -2611,6 +2611,35 @@ export default { sessionCountLabel: '{n} sessions', }, knowledgeEditor: { + activity: { + title: 'Activity', + description: 'Important changes and background-task entry points for this knowledge base. Retention follows the audit-log policy.', + allOutcomes: 'All outcomes', refresh: 'Refresh', retry: 'Retry', empty: 'No activity yet', + loadMore: 'Load more', loadingMore: 'Loading…', end: 'No earlier activity', loadFailed: 'Failed to load activity', viewDetails: 'View details', + columns: { time: 'Time', action: 'Action', target: 'Target', actor: 'Initiator', outcome: 'Outcome' }, + expanded: { targetType: 'Target type', targetId: 'Target ID', actorId: 'Initiator ID', details: 'Details' }, + drawer: { sectionSummary: 'Summary', sectionIdentifiers: 'Identifiers', sectionTask: 'Task information', targetChange: 'Change details' }, + systemActor: 'System', knowledgeBase: 'Knowledge base', countSummary: '{label} · {count} items', + targets: { knowledge_base: 'Knowledge base', knowledge: 'Knowledge', faq_entry: 'FAQ entry', knowledge_tag: 'Tag', data_source: 'Data source', knowledge_base_share: 'Share', knowledge_move: 'Knowledge move', wiki: 'Wiki' }, + outcomes: { accepted: 'Accepted', success: 'Success', failed: 'Failed', partial: 'Partial', canceled: 'Canceled', denied: 'Denied' }, + detailFields: { task_id: 'Task ID', trigger: 'Trigger', processing_status: 'Processing status', source_kb_id: 'Source knowledge base ID', target_kb_id: 'Target knowledge base ID', sync_log_id: 'Sync log ID', mode: 'Mode', attempt: 'Processing attempt', count: 'Item count', total: 'Total', processed: 'Processed', failed: 'Failed', failure_stage: 'Failure stage' }, + detailValues: { user: 'User initiated', manual: 'Manual', schedule: 'Scheduled', system: 'System', pending: 'Pending', completed: 'Completed', partial: 'Partially completed', canceled: 'Canceled', failed: 'Failed', enqueue: 'Task submission', reuse_vectors: 'Reuse vectors', reparse: 'Reparse' }, + actions: { + 'kb.created': 'Knowledge base created', 'kb.updated': 'Knowledge base updated', 'kb.deleted': 'Knowledge base deleted', + 'kb.duplicated': 'Knowledge base duplicated', 'kb.clone_started': 'Clone started', 'kb.clone_completed': 'Clone completed', + 'kb.clone_failed': 'Clone failed', + 'knowledge.created': 'Knowledge added', 'knowledge.updated': 'Knowledge updated', 'knowledge.deleted': 'Knowledge deleted', + 'knowledge.batch_deleted': 'Knowledge batch deleted', 'knowledge.reparse_started': 'Reparse started', + 'knowledge.parse_canceled': 'Parsing canceled', 'knowledge.move_started': 'Knowledge move started', + 'knowledge.move_completed': 'Knowledge move completed', 'knowledge.move_failed': 'Knowledge move failed', + 'tag.created': 'Tag created', 'tag.updated': 'Tag updated', 'tag.deleted': 'Tag deleted', + 'datasource.created': 'Data source created', 'datasource.updated': 'Data source updated', 'datasource.deleted': 'Data source deleted', + 'datasource.sync_started': 'Data source sync started', 'datasource.sync_completed': 'Data source sync completed', 'datasource.sync_failed': 'Data source sync failed', + 'datasource.paused': 'Data source paused', 'datasource.resumed': 'Data source resumed', + 'kb.share_added': 'Share added', 'kb.share_permission_changed': 'Share permission changed', 'kb.share_removed': 'Share removed', + 'wiki.content_changed': 'Wiki content changed', + }, + }, titleCreate: 'Create Knowledge Base', titleEdit: 'Knowledge Base Settings', navGroups: { @@ -2618,6 +2647,7 @@ export default { processing: 'Indexing & Parsing', data: 'Storage & Data', integration: 'Publishing', + management: 'Management & Audit', }, sidebar: { basic: 'Basic Information', @@ -2633,6 +2663,7 @@ export default { asr: 'Audio', datasource: 'Data Sources', share: 'Sharing', + activity: 'Activity', indexing: 'Indexing Strategy', }, errors: { diff --git a/frontend/src/i18n/locales/ko-KR.ts b/frontend/src/i18n/locales/ko-KR.ts index d0209398..c9327b40 100755 --- a/frontend/src/i18n/locales/ko-KR.ts +++ b/frontend/src/i18n/locales/ko-KR.ts @@ -3842,6 +3842,35 @@ export default { }, knowledgeEditor: { + activity: { + title: '활동 기록', + description: '이 지식 베이스의 주요 변경 사항과 백그라운드 작업 시작 기록입니다. 보존 기간은 감사 로그 정책을 따릅니다.', + allOutcomes: '모든 결과', refresh: '새로고침', retry: '다시 시도', empty: '아직 활동 기록이 없습니다', + loadMore: '더 보기', loadingMore: '불러오는 중…', end: '이전 기록이 없습니다', loadFailed: '활동 기록을 불러오지 못했습니다', viewDetails: '상세 보기', + columns: { time: '시간', action: '작업', target: '대상', actor: '시작자', outcome: '결과' }, + expanded: { targetType: '대상 유형', targetId: '대상 ID', actorId: '시작자 ID', details: '상세' }, + drawer: { sectionSummary: '요약', sectionIdentifiers: '식별자', sectionTask: '작업 정보', targetChange: '변경 내용' }, + systemActor: '시스템', knowledgeBase: '지식 베이스', countSummary: '{label} · {count}개 항목', + targets: { knowledge_base: '지식 베이스', knowledge: '지식', faq_entry: 'FAQ 항목', knowledge_tag: '태그', data_source: '데이터 소스', knowledge_base_share: '공유', knowledge_move: '지식 이동', wiki: 'Wiki' }, + outcomes: { accepted: '접수됨', success: '성공', failed: '실패', partial: '일부 완료', canceled: '취소됨', denied: '거부됨' }, + detailFields: { task_id: '작업 ID', trigger: '트리거', processing_status: '처리 상태', source_kb_id: '소스 지식 베이스 ID', target_kb_id: '대상 지식 베이스 ID', sync_log_id: '동기화 로그 ID', mode: '모드', attempt: '처리 시도', count: '항목 수', total: '전체', processed: '처리됨', failed: '실패', failure_stage: '실패 단계' }, + detailValues: { user: '사용자 시작', manual: '수동', schedule: '예약', system: '시스템', pending: '대기 중', completed: '완료', partial: '일부 완료', canceled: '취소됨', failed: '실패', enqueue: '작업 제출', reuse_vectors: '벡터 재사용', reparse: '재분석' }, + actions: { + 'kb.created': '지식 베이스 생성', 'kb.updated': '지식 베이스 업데이트', 'kb.deleted': '지식 베이스 삭제', + 'kb.duplicated': '지식 베이스 복제', 'kb.clone_started': '복제 시작', 'kb.clone_completed': '복제 완료', + 'kb.clone_failed': '복제 실패', + 'knowledge.created': '지식 추가', 'knowledge.updated': '지식 업데이트', 'knowledge.deleted': '지식 삭제', + 'knowledge.batch_deleted': '지식 일괄 삭제', 'knowledge.reparse_started': '재분석 시작', + 'knowledge.parse_canceled': '분석 취소', 'knowledge.move_started': '지식 이동 시작', + 'knowledge.move_completed': '지식 이동 완료', 'knowledge.move_failed': '지식 이동 실패', + 'tag.created': '태그 생성', 'tag.updated': '태그 업데이트', 'tag.deleted': '태그 삭제', + 'datasource.created': '데이터 소스 생성', 'datasource.updated': '데이터 소스 업데이트', 'datasource.deleted': '데이터 소스 삭제', + 'datasource.sync_started': '데이터 소스 동기화 시작', 'datasource.sync_completed': '데이터 소스 동기화 완료', 'datasource.sync_failed': '데이터 소스 동기화 실패', + 'datasource.paused': '데이터 소스 일시 중지', 'datasource.resumed': '데이터 소스 재개', + 'kb.share_added': '공유 추가', 'kb.share_permission_changed': '공유 권한 변경', 'kb.share_removed': '공유 제거', + 'wiki.content_changed': 'Wiki 콘텐츠 업데이트', + }, + }, titleCreate: "지식베이스 생성", titleEdit: "지식베이스 설정", navGroups: { @@ -3849,6 +3878,7 @@ export default { processing: "인덱싱 및 파싱", data: "스토리지 및 데이터", integration: "게시 및 통합", + management: "관리 및 감사", }, sidebar: { basic: "기본 정보", @@ -3862,6 +3892,7 @@ export default { multimodal: "이미지 처리", asr: "오디오", share: "공유관리", + activity: "활동 기록", storage: "스토리지 엔진", datasource: "데이터 소스", indexing: "인덱싱 전략", diff --git a/frontend/src/i18n/locales/ru-RU.ts b/frontend/src/i18n/locales/ru-RU.ts index 8c23aa58..58e20ced 100755 --- a/frontend/src/i18n/locales/ru-RU.ts +++ b/frontend/src/i18n/locales/ru-RU.ts @@ -3316,6 +3316,35 @@ export default { }, knowledgeEditor: { + activity: { + title: 'История действий', + description: 'Важные изменения и фоновые задачи этой базы знаний. Срок хранения соответствует политике аудита.', + allOutcomes: 'Все результаты', refresh: 'Обновить', retry: 'Повторить', empty: 'Действий пока нет', + loadMore: 'Загрузить ещё', loadingMore: 'Загрузка…', end: 'Более ранних записей нет', loadFailed: 'Не удалось загрузить историю', viewDetails: 'Подробнее', + columns: { time: 'Время', action: 'Действие', target: 'Объект', actor: 'Инициатор', outcome: 'Результат' }, + expanded: { targetType: 'Тип объекта', targetId: 'ID объекта', actorId: 'ID инициатора', details: 'Подробности' }, + drawer: { sectionSummary: 'Сводка', sectionIdentifiers: 'Идентификаторы', sectionTask: 'Информация о задаче', targetChange: 'Детали изменения' }, + systemActor: 'Система', knowledgeBase: 'База знаний', countSummary: '{label} · {count} элементов', + targets: { knowledge_base: 'База знаний', knowledge: 'Знание', faq_entry: 'FAQ', knowledge_tag: 'Тег', data_source: 'Источник данных', knowledge_base_share: 'Общий доступ', knowledge_move: 'Перемещение', wiki: 'Wiki' }, + outcomes: { accepted: 'Принято', success: 'Успешно', failed: 'Ошибка', partial: 'Частично', canceled: 'Отменено', denied: 'Отклонено' }, + detailFields: { task_id: 'ID задачи', trigger: 'Запуск', processing_status: 'Статус обработки', source_kb_id: 'ID исходной базы', target_kb_id: 'ID целевой базы', sync_log_id: 'ID журнала синхронизации', mode: 'Режим', attempt: 'Попытка', count: 'Количество', total: 'Всего', processed: 'Обработано', failed: 'Ошибок', failure_stage: 'Этап ошибки' }, + detailValues: { user: 'Запущено пользоватем', manual: 'Вручную', schedule: 'По расписанию', system: 'Система', pending: 'Ожидает', completed: 'Завершено', partial: 'Частично завершено', canceled: 'Отменено', failed: 'Ошибка', enqueue: 'Постановка в очередь', reuse_vectors: 'Повторное использование векторов', reparse: 'Повторный разбор' }, + actions: { + 'kb.created': 'База знаний создана', 'kb.updated': 'База знаний обновлена', 'kb.deleted': 'База знаний удалена', + 'kb.duplicated': 'База знаний скопирована', 'kb.clone_started': 'Клонирование начато', 'kb.clone_completed': 'Клонирование завершено', + 'kb.clone_failed': 'Ошибка клонирования', + 'knowledge.created': 'Знание добавлено', 'knowledge.updated': 'Знание обновлено', 'knowledge.deleted': 'Знание удалено', + 'knowledge.batch_deleted': 'Знания удалены пакетом', 'knowledge.reparse_started': 'Повторный разбор начат', + 'knowledge.parse_canceled': 'Разбор отменён', 'knowledge.move_started': 'Перемещение начато', + 'knowledge.move_completed': 'Перемещение завершено', 'knowledge.move_failed': 'Ошибка перемещения', + 'tag.created': 'Тег создан', 'tag.updated': 'Тег обновлён', 'tag.deleted': 'Тег удалён', + 'datasource.created': 'Источник данных создан', 'datasource.updated': 'Источник данных обновлён', 'datasource.deleted': 'Источник данных удалён', + 'datasource.sync_started': 'Синхронизация начата', 'datasource.sync_completed': 'Синхронизация завершена', 'datasource.sync_failed': 'Ошибка синхронизации', + 'datasource.paused': 'Источник приостановлен', 'datasource.resumed': 'Источник возобновлён', + 'kb.share_added': 'Общий доступ добавлен', 'kb.share_permission_changed': 'Права доступа изменены', 'kb.share_removed': 'Общий доступ удалён', + 'wiki.content_changed': 'Содержимое Wiki обновлено', + }, + }, titleCreate: 'Создать базу знаний', titleEdit: 'Настройки базы знаний', navGroups: { @@ -3323,6 +3352,7 @@ export default { processing: 'Индексация и разбор', data: 'Хранение и данные', integration: 'Публикация', + management: 'Управление и аудит', }, sidebar: { basic: 'Основная информация', @@ -3338,6 +3368,7 @@ export default { storage: 'Storage Engine', datasource: 'Источники данных', share: 'Sharing', + activity: 'История активности', indexing: 'Стратегия индексации', }, errors: { diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.ts index ba7b7bfd..c2294db0 100755 --- a/frontend/src/i18n/locales/zh-CN.ts +++ b/frontend/src/i18n/locales/zh-CN.ts @@ -3873,11 +3873,66 @@ export default { knowledgeEditor: { titleCreate: "新建知识库", titleEdit: "知识库设置", + activity: { + title: "活动记录", + description: "查看这个知识库的重要变更与后台任务入口,记录默认遵循审计日志保留策略。", + allOutcomes: "全部结果", + refresh: "刷新", + retry: "重试", + empty: "暂无活动记录", + loadMore: "加载更多", + loadingMore: "加载中…", + end: "没有更早的记录了", + loadFailed: "活动记录加载失败", + viewDetails: "查看详情", + columns: { + time: "时间", + action: "操作", + target: "对象", + actor: "发起人", + outcome: "结果", + }, + expanded: { + targetType: "对象类型", + targetId: "对象 ID", + actorId: "发起人 ID", + details: "详情", + }, + drawer: { + sectionSummary: "摘要", + sectionIdentifiers: "标识符", + sectionTask: "任务信息", + targetChange: "变更详情", + }, + systemActor: "系统触发", + knowledgeBase: "知识库", + countSummary: "{label} · 共 {count} 项", + targets: { knowledge_base: "知识库", knowledge: "知识", faq_entry: "FAQ 条目", knowledge_tag: "标签", data_source: "数据源", knowledge_base_share: "共享", knowledge_move: "知识移动", wiki: "Wiki" }, + outcomes: { accepted: "已受理", success: "成功", failed: "失败", partial: "部分完成", canceled: "已取消", denied: "已拒绝" }, + detailFields: { task_id: "任务 ID", trigger: "触发方式", processing_status: "处理状态", source_kb_id: "来源知识库 ID", target_kb_id: "目标知识库 ID", sync_log_id: "同步记录 ID", mode: "执行模式", attempt: "处理批次", count: "项目数", total: "总数", processed: "已处理", failed: "失败数", failure_stage: "失败阶段" }, + detailValues: { user: "用户发起", manual: "手动触发", schedule: "定时调度", system: "系统触发", pending: "待处理", completed: "已完成", partial: "部分完成", canceled: "已取消", failed: "失败", enqueue: "任务提交", reuse_vectors: "复用向量", reparse: "重新解析" }, + actions: { + 'kb.created': "创建知识库", 'kb.updated': "更新知识库", 'kb.deleted': "删除知识库", + 'kb.duplicated': "复制知识库", 'kb.clone_started': "开始克隆", 'kb.clone_completed': "完成克隆", + 'kb.clone_failed': "克隆失败", + 'knowledge.created': "添加知识", 'knowledge.updated': "更新知识", 'knowledge.deleted': "删除知识", + 'knowledge.batch_deleted': "批量删除知识", 'knowledge.reparse_started': "开始重新解析", + 'knowledge.parse_canceled': "取消解析", 'knowledge.move_started': "开始移动知识", + 'knowledge.move_completed': "完成移动知识", 'knowledge.move_failed': "移动知识失败", + 'tag.created': "创建标签", 'tag.updated': "更新标签", 'tag.deleted': "删除标签", + 'datasource.created': "创建数据源", 'datasource.updated': "更新数据源", 'datasource.deleted': "删除数据源", + 'datasource.sync_started': "开始同步数据源", 'datasource.sync_completed': "数据源同步完成", 'datasource.sync_failed': "数据源同步失败", + 'datasource.paused': "暂停数据源", 'datasource.resumed': "恢复数据源", + 'kb.share_added': "添加共享", 'kb.share_permission_changed': "修改共享权限", 'kb.share_removed': "移除共享", + 'wiki.content_changed': "更新 Wiki 内容", + }, + }, navGroups: { basic: "基础", processing: "索引与解析", data: "存储与数据", integration: "发布集成", + management: "管理与审计", }, sidebar: { basic: "基本信息", @@ -3893,6 +3948,7 @@ export default { asr: "音频处理", datasource: "数据源", share: "共享管理", + activity: "活动记录", indexing: "索引策略", }, errors: { diff --git a/frontend/src/views/knowledge/KnowledgeBase.vue b/frontend/src/views/knowledge/KnowledgeBase.vue index 0bd7ead5..63de698a 100644 --- a/frontend/src/views/knowledge/KnowledgeBase.vue +++ b/frontend/src/views/knowledge/KnowledgeBase.vue @@ -282,6 +282,9 @@ const canManage = computed(() => { return orgStore.canManageKB(kbId.value, false); }); +// The activity feed exposes owner-side actor and configuration summaries. +// It lives in KB settings (KnowledgeBaseEditorModal) for Owner/Admin in the home tenant. + // Can mutate knowledge (move / batch-delete): the backend gate for these // two endpoints is g.Contributor(), so the caller MUST be Contributor+ // in their tenant on top of having KB edit permission. Without the extra diff --git a/frontend/src/views/knowledge/KnowledgeBaseEditorModal.vue b/frontend/src/views/knowledge/KnowledgeBaseEditorModal.vue index 5b8ecbc2..2eedad70 100644 --- a/frontend/src/views/knowledge/KnowledgeBaseEditorModal.vue +++ b/frontend/src/views/knowledge/KnowledgeBaseEditorModal.vue @@ -423,6 +423,11 @@
+ + +
+ +
@@ -467,6 +472,7 @@ import ModelSelector from '@/components/ModelSelector.vue' import GraphSettings from './settings/GraphSettings.vue' import KBShareSettings from './settings/KBShareSettings.vue' import DataSourceSettings from './settings/DataSourceSettings.vue' +import KnowledgeBaseActivitySettings from './settings/KnowledgeBaseActivitySettings.vue' import { useI18n } from 'vue-i18n' const uiStore = useUIStore() @@ -542,6 +548,7 @@ const dsCount = ref(0) // that predate per-KB ownership tracking; those KBs have no "owner" and // only tenant Admin+ can mutate their share settings. const kbCreatorId = ref('') +const kbTenantId = ref(0) // Backend gate for /knowledge-bases/:id/shares (POST/PUT/DELETE) is // g.OwnedKBOrAdmin(): only the KB creator or tenant Admin+ may mutate @@ -554,6 +561,17 @@ const canShareKB = computed(() => { if (kbCreatorId.value && userId && kbCreatorId.value === userId) return true return authStore.hasRole('admin') }) + +const isKbOwner = computed(() => { + const userId = authStore.user?.id || '' + return Boolean(kbCreatorId.value && userId && kbCreatorId.value === userId) +}) + +const canViewActivity = computed(() => { + if (props.mode !== 'edit' || !props.kbId) return false + if (Number(kbTenantId.value || 0) !== Number(authStore.currentTenantId || 0)) return false + return isKbOwner.value || authStore.hasRole('admin') +}) // 用户是否在分块设置中手动改过任何值。一旦为 true,就不再根据索引策略自动调整默认分块参数。 const chunkingDirty = ref(false) @@ -603,6 +621,9 @@ const navItems = computed(() => { if (props.mode === 'edit' && props.kbId && !authStore.isLiteMode) { items.push({ key: 'share', icon: 'share', label: t('knowledgeEditor.sidebar.share') }) } + if (canViewActivity.value) { + items.push({ key: 'activity', icon: 'history', label: t('knowledgeEditor.sidebar.activity') }) + } return items }) @@ -632,6 +653,11 @@ const navGroups = computed(() => { label: t('knowledgeEditor.navGroups.integration'), items: pickItems(['share']), }, + { + key: 'management', + label: t('knowledgeEditor.navGroups.management'), + items: pickItems(['activity']), + }, ].filter((group) => group.items.length > 0) }) @@ -802,6 +828,7 @@ const loadKBData = async () => { const kb = kbInfo.data hasFiles.value = (filesResult as any)?.total > 0 kbCreatorId.value = (kb as any).creator_id || '' + kbTenantId.value = Number((kb as any).tenant_id || 0) // 设置表单数据 const kbType = (kb.type as 'document' | 'faq') || 'document' @@ -1469,6 +1496,7 @@ const resetState = () => { loading.value = false chunkingDirty.value = false kbCreatorId.value = '' + kbTenantId.value = 0 } // 关闭弹窗 diff --git a/frontend/src/views/knowledge/settings/KnowledgeBaseActivitySettings.vue b/frontend/src/views/knowledge/settings/KnowledgeBaseActivitySettings.vue new file mode 100644 index 00000000..8d67e316 --- /dev/null +++ b/frontend/src/views/knowledge/settings/KnowledgeBaseActivitySettings.vue @@ -0,0 +1,783 @@ + + + + + diff --git a/internal/application/repository/audit_log.go b/internal/application/repository/audit_log.go index 431fc4f1..d975aacf 100644 --- a/internal/application/repository/audit_log.go +++ b/internal/application/repository/audit_log.go @@ -68,6 +68,15 @@ func (r *auditLogRepository) List( if q.ActorUserID != "" { tx = tx.Where("actor_user_id = ?", q.ActorUserID) } + if q.ScopeType != "" { + tx = tx.Where("scope_type = ?", q.ScopeType) + } + if q.ScopeID != "" { + tx = tx.Where("scope_id = ?", q.ScopeID) + } + if q.UnscopedOnly { + tx = tx.Where("scope_type = ''") + } } var entries []*types.AuditLog diff --git a/internal/application/repository/audit_log_scope_test.go b/internal/application/repository/audit_log_scope_test.go new file mode 100644 index 00000000..35c87993 --- /dev/null +++ b/internal/application/repository/audit_log_scope_test.go @@ -0,0 +1,51 @@ +package repository + +import ( + "context" + "testing" + + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" + "gorm.io/driver/sqlite" + "gorm.io/gorm" +) + +func TestAuditLogRepositoryListFiltersKnowledgeBaseScope(t *testing.T) { + db, err := gorm.Open(sqlite.Open("file:audit-log-scope?mode=memory&cache=shared"), &gorm.Config{}) + if err != nil { + t.Fatalf("open sqlite: %v", err) + } + if err := db.AutoMigrate(&types.AuditLog{}); err != nil { + t.Fatalf("migrate audit log: %v", err) + } + rows := []*types.AuditLog{ + {TenantID: 7, Action: types.AuditActionMemberAdded}, + {TenantID: 7, Action: types.AuditActionKBUpdated, ScopeType: "knowledge_base", ScopeID: "kb-a"}, + {TenantID: 7, Action: types.AuditActionKnowledgeCreated, ScopeType: "knowledge_base", ScopeID: "kb-b"}, + {TenantID: 8, Action: types.AuditActionKBUpdated, ScopeType: "knowledge_base", ScopeID: "kb-a"}, + } + for _, row := range rows { + if err := db.Create(row).Error; err != nil { + t.Fatalf("insert audit log: %v", err) + } + } + + repo := NewAuditLogRepository(db) + got, err := repo.List(context.Background(), 7, &interfaces.AuditLogQuery{ + ScopeType: "knowledge_base", + ScopeID: "kb-a", + }) + if err != nil { + t.Fatalf("list audit logs: %v", err) + } + if len(got) != 1 || got[0].TenantID != 7 || got[0].ScopeID != "kb-a" { + t.Fatalf("scope filter returned unexpected rows: %+v", got) + } + unscoped, err := repo.List(context.Background(), 7, &interfaces.AuditLogQuery{UnscopedOnly: true}) + if err != nil { + t.Fatalf("list unscoped audit logs: %v", err) + } + if len(unscoped) != 1 || unscoped[0].Action != types.AuditActionMemberAdded { + t.Fatalf("unscoped filter returned unexpected rows: %+v", unscoped) + } +} diff --git a/internal/application/service/datasource_service.go b/internal/application/service/datasource_service.go index 6993f0d0..bd29d8e6 100644 --- a/internal/application/service/datasource_service.go +++ b/internal/application/service/datasource_service.go @@ -32,6 +32,7 @@ type DataSourceService struct { scheduler *datasource.Scheduler tenantRepo interfaces.TenantRepository tagService interfaces.KnowledgeTagService + audit interfaces.AuditLogService } // NewDataSourceService creates a new data source service @@ -45,6 +46,7 @@ func NewDataSourceService( scheduler *datasource.Scheduler, tenantRepo interfaces.TenantRepository, tagService interfaces.KnowledgeTagService, + audit interfaces.AuditLogService, ) interfaces.DataSourceService { return &DataSourceService{ dsRepo: dsRepo, @@ -56,6 +58,7 @@ func NewDataSourceService( scheduler: scheduler, tenantRepo: tenantRepo, tagService: tagService, + audit: audit, } } @@ -105,6 +108,9 @@ func (s *DataSourceService) CreateDataSource(ctx context.Context, ds *types.Data } logger.Infof(ctx, "data source created: id=%s type=%s kb=%s", ds.ID, ds.Type, ds.KnowledgeBaseID) + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourceCreated, + "data_source", ds.ID, types.AuditOutcomeSuccess, + map[string]any{"name": ds.Name, "type": ds.Type}) return ds, nil } @@ -218,6 +224,9 @@ func (s *DataSourceService) UpdateDataSource(ctx context.Context, ds *types.Data } logger.Infof(ctx, "data source updated: id=%s", ds.ID) + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourceUpdated, + "data_source", ds.ID, types.AuditOutcomeSuccess, + map[string]any{"name": ds.Name, "type": ds.Type, "changed_fields": []string{"settings"}}) return ds, nil } @@ -261,6 +270,9 @@ func (s *DataSourceService) UpdateDataSourceCredentials( return nil, err } logger.Infof(ctx, "DataSource credentials updated: id=%s", secutils.SanitizeForLog(id)) + recordKBActivity(ctx, s.audit, existing.TenantID, existing.KnowledgeBaseID, types.AuditActionDataSourceUpdated, + "data_source", existing.ID, types.AuditOutcomeSuccess, + map[string]any{"name": existing.Name, "type": existing.Type, "changed_fields": []string{"credentials"}}) return existing, nil } @@ -300,13 +312,16 @@ func (s *DataSourceService) ClearDataSourceCredentials(ctx context.Context, id s return err } logger.Infof(ctx, "DataSource credentials cleared by user: id=%s", secutils.SanitizeForLog(id)) + recordKBActivity(ctx, s.audit, existing.TenantID, existing.KnowledgeBaseID, types.AuditActionDataSourceUpdated, + "data_source", existing.ID, types.AuditOutcomeSuccess, + map[string]any{"name": existing.Name, "type": existing.Type, "changed_fields": []string{"credentials"}}) return nil } // DeleteDataSource deletes a data source (soft delete) func (s *DataSourceService) DeleteDataSource(ctx context.Context, id string) error { // Verify data source exists - _, err := s.dsRepo.FindByID(ctx, id) + existing, err := s.dsRepo.FindByID(ctx, id) if err != nil { return err } @@ -325,6 +340,9 @@ func (s *DataSourceService) DeleteDataSource(ctx context.Context, id string) err } logger.Infof(ctx, "data source deleted: id=%s", id) + recordKBActivity(ctx, s.audit, existing.TenantID, existing.KnowledgeBaseID, types.AuditActionDataSourceDeleted, + "data_source", existing.ID, types.AuditOutcomeSuccess, + map[string]any{"name": existing.Name, "type": existing.Type}) return nil } @@ -464,6 +482,8 @@ func (s *DataSourceService) ManualSync(ctx context.Context, dsID string) (*types TenantID: ds.TenantID, SyncLogID: syncLog.ID, ForceFull: false, + Initiator: types.TaskInitiatorFromContext(ctx), + Trigger: "manual", } langfuse.InjectTracing(ctx, payload) @@ -471,7 +491,7 @@ func (s *DataSourceService) ManualSync(ctx context.Context, dsID string) (*types task := asynq.NewTask(types.TypeDataSourceSync, payloadJSON, asynq.Queue(types.QueueSync), asynq.MaxRetry(5), asynq.Timeout(2*time.Hour)) - _, err = s.taskEnqueuer.Enqueue(task) + info, err := s.taskEnqueuer.Enqueue(task) if err != nil { logger.Errorf(ctx, "failed to enqueue sync task: %v", err) syncLog.Status = types.SyncLogStatusFailed @@ -483,10 +503,17 @@ func (s *DataSourceService) ManualSync(ctx context.Context, dsID string) (*types } ds.ErrorMessage = fmt.Sprintf("Failed to enqueue sync: %v", err) _ = s.dsRepo.Update(ctx, ds) + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourceSyncFailed, + "data_source", ds.ID, types.AuditOutcomeFailed, + map[string]any{"name": ds.Name, "type": ds.Type, "sync_log_id": syncLog.ID, "trigger": "manual"}) return nil, err } logger.Infof(ctx, "sync task enqueued: ds=%s syncLog=%s", dsID, syncLog.ID) + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourceSyncStarted, + "data_source", ds.ID, types.AuditOutcomeAccepted, + map[string]any{"name": ds.Name, "type": ds.Type, "sync_log_id": syncLog.ID, + "task_id": info.ID, "trigger": "manual", "processing_status": "pending"}) return syncLog, nil } @@ -507,6 +534,8 @@ func (s *DataSourceService) PauseDataSource(ctx context.Context, id string) erro s.scheduler.Remove(id) logger.Infof(ctx, "data source paused: id=%s", id) + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourcePaused, + "data_source", ds.ID, types.AuditOutcomeSuccess, map[string]any{"name": ds.Name, "type": ds.Type}) return nil } @@ -529,6 +558,8 @@ func (s *DataSourceService) ResumeDataSource(ctx context.Context, id string) err } logger.Infof(ctx, "data source resumed: id=%s", id) + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourceResumed, + "data_source", ds.ID, types.AuditOutcomeSuccess, map[string]any{"name": ds.Name, "type": ds.Type}) return nil } @@ -558,6 +589,9 @@ func (s *DataSourceService) ProcessSync(ctx context.Context, task *asynq.Task) e logger.Errorf(ctx, "failed to unmarshal sync payload: %v", err) return err } + ctx = payload.Initiator.Apply(ctx) + taskID, _ := asynq.GetTaskID(ctx) + ctx = withKBActivityTask(ctx, taskID, payload.Trigger) logger.Infof(ctx, "processing data source sync: ds=%s syncLog=%s", payload.DataSourceID, payload.SyncLogID) @@ -708,7 +742,7 @@ func (s *DataSourceService) ProcessSync(ctx context.Context, task *asynq.Task) e for _, item := range items { item := item - s.applyFetchedItem(ctx, ds, &item, autoTagIDs, result) + s.applyFetchedItem(withKBActivitySuppressed(ctx), ds, &item, autoTagIDs, result) } resultJSON, _ := result.ToJSON() @@ -879,7 +913,7 @@ func (h *streamSyncHandler) Emit(ctx context.Context, item types.FetchedItem) er return err } h.result.Total++ - h.svc.applyFetchedItem(ctx, h.ds, &item, h.tagIDs, h.result) + h.svc.applyFetchedItem(withKBActivitySuppressed(ctx), h.ds, &item, h.tagIDs, h.result) return nil } @@ -1028,6 +1062,21 @@ func (s *DataSourceService) updateSyncRunResult( if err := s.dsRepo.UpdateSyncState(ctx, ds); err != nil { logger.Errorf(ctx, "failed to update data source: %v", err) } + action := types.AuditActionDataSourceSyncCompleted + outcome := types.AuditOutcomeSuccess + if status == types.SyncLogStatusFailed { + action = types.AuditActionDataSourceSyncFailed + outcome = types.AuditOutcomeFailed + } else if status == types.SyncLogStatusPartial { + outcome = types.AuditOutcomePartial + } + recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, action, + "data_source", ds.ID, outcome, + map[string]any{ + "name": ds.Name, "type": ds.Type, "sync_log_id": syncLog.ID, + "total": result.Total, "created": result.Created, "updated": result.Updated, + "deleted": result.Deleted, "skipped": result.Skipped, "failed": result.Failed, + }) } func allFetchedItemsFailedError(result *types.SyncResult) error { diff --git a/internal/application/service/kb_activity.go b/internal/application/service/kb_activity.go new file mode 100644 index 00000000..353b0009 --- /dev/null +++ b/internal/application/service/kb_activity.go @@ -0,0 +1,132 @@ +package service + +import ( + "context" + "encoding/json" + + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" +) + +const auditScopeKnowledgeBase = "knowledge_base" + +type kbActivityTaskMetadata struct { + TaskID string + Trigger string +} + +type kbActivityTaskContextKey struct{} +type kbActivitySuppressedContextKey struct{} + +// withKBActivityTask annotates a worker context with stable correlation fields +// that recordKBActivity will add to each event produced by that task. +func withKBActivityTask(ctx context.Context, taskID, trigger string) context.Context { + if taskID == "" && trigger == "" { + return ctx + } + return context.WithValue(ctx, kbActivityTaskContextKey{}, kbActivityTaskMetadata{ + TaskID: taskID, Trigger: trigger, + }) +} + +func kbActivityTrigger(ctx context.Context) string { + if task, ok := ctx.Value(kbActivityTaskContextKey{}).(kbActivityTaskMetadata); ok && task.Trigger != "" { + return task.Trigger + } + if userID, ok := types.UserIDFromContext(ctx); ok && !types.IsSyntheticUserID(userID) { + return "user" + } + return "system" +} + +// withKBActivitySuppressed is used for high-volume child mutations inside a +// composite task. The task's bounded summary event remains visible, while one +// sync run cannot flood the audit table with thousands of per-item rows. +func withKBActivitySuppressed(ctx context.Context) context.Context { + return context.WithValue(ctx, kbActivitySuppressedContextKey{}, true) +} + +// recordKBActivity appends one bounded, non-secret activity summary to the +// existing audit stream. It is deliberately best-effort, matching the audit +// service's failure semantics: a temporary audit outage must not roll back a +// completed business mutation. +func recordKBActivity( + ctx context.Context, + audit interfaces.AuditLogService, + tenantID uint64, + kbID string, + action types.AuditAction, + targetType string, + targetID string, + outcome types.AuditOutcome, + details map[string]any, +) { + if suppressed, _ := ctx.Value(kbActivitySuppressedContextKey{}).(bool); suppressed { + return + } + if audit == nil || kbID == "" || action == "" { + return + } + if tenantID == 0 { + tenantID, _ = types.TenantIDFromContext(ctx) + } + if tenantID == 0 { + return + } + if outcome == "" { + outcome = types.AuditOutcomeSuccess + } + activityDetails := make(map[string]any, len(details)+2) + for key, value := range details { + activityDetails[key] = value + } + if task, ok := ctx.Value(kbActivityTaskContextKey{}).(kbActivityTaskMetadata); ok { + if task.TaskID != "" { + if _, exists := activityDetails["task_id"]; !exists { + activityDetails["task_id"] = task.TaskID + } + } + if task.Trigger != "" { + if _, exists := activityDetails["trigger"]; !exists { + activityDetails["trigger"] = task.Trigger + } + } + if _, exists := activityDetails["processing_status"]; !exists { + switch outcome { + case types.AuditOutcomeAccepted: + activityDetails["processing_status"] = "pending" + case types.AuditOutcomeSuccess: + activityDetails["processing_status"] = "completed" + case types.AuditOutcomePartial: + activityDetails["processing_status"] = "partial" + case types.AuditOutcomeFailed, types.AuditOutcomeDenied: + activityDetails["processing_status"] = "failed" + case types.AuditOutcomeCanceled: + activityDetails["processing_status"] = "canceled" + } + } + } + var detailJSON types.JSON + if len(activityDetails) > 0 { + if b, err := json.Marshal(activityDetails); err == nil { + detailJSON = types.JSON(b) + } + } + actorID := auditActor(ctx) + actorRole := "" + if actorID != "" { + actorRole = auditActorRole(ctx) + } + _ = audit.Log(ctx, &types.AuditLog{ + TenantID: tenantID, + ActorUserID: actorID, + ActorRole: actorRole, + Action: action, + ScopeType: auditScopeKnowledgeBase, + ScopeID: kbID, + TargetType: targetType, + TargetID: targetID, + Outcome: outcome, + Details: detailJSON, + }) +} diff --git a/internal/application/service/kb_activity_test.go b/internal/application/service/kb_activity_test.go new file mode 100644 index 00000000..73163aa7 --- /dev/null +++ b/internal/application/service/kb_activity_test.go @@ -0,0 +1,63 @@ +package service + +import ( + "context" + "encoding/json" + "testing" + + "github.com/Tencent/WeKnora/internal/types" + "github.com/Tencent/WeKnora/internal/types/interfaces" + "github.com/gin-gonic/gin" +) + +type captureKBActivityAudit struct { + entry *types.AuditLog +} + +func (c *captureKBActivityAudit) Log(_ context.Context, entry *types.AuditLog) error { + c.entry = entry + return nil +} + +func (*captureKBActivityAudit) LogDenied(context.Context, *gin.Context, uint64, string, string, types.TenantRole) error { + return nil +} + +func (*captureKBActivityAudit) List(context.Context, uint64, *interfaces.AuditLogQuery) ([]*types.AuditLog, error) { + return nil, nil +} + +func (*captureKBActivityAudit) Purge(context.Context, int) (int64, error) { return 0, nil } + +func TestRecordKBActivityCarriesInitiatorAndTaskMetadata(t *testing.T) { + ctx := types.TaskInitiator{UserID: "user-1", Role: types.TenantRoleAdmin}.Apply(context.Background()) + ctx = withKBActivityTask(ctx, "task-1", "user") + audit := &captureKBActivityAudit{} + + recordKBActivity(ctx, audit, 7, "kb-1", types.AuditActionKnowledgeMoveCompleted, + "knowledge_move", "task-1", types.AuditOutcomeSuccess, map[string]any{"count": 2}) + + if audit.entry == nil { + t.Fatal("expected an activity entry") + } + if audit.entry.ActorUserID != "user-1" || audit.entry.ActorRole != "admin" { + t.Fatalf("actor = %q/%q", audit.entry.ActorUserID, audit.entry.ActorRole) + } + var details map[string]any + if err := json.Unmarshal(audit.entry.Details, &details); err != nil { + t.Fatalf("unmarshal details: %v", err) + } + if details["task_id"] != "task-1" || details["trigger"] != "user" || details["count"] != float64(2) { + t.Fatalf("details = %#v", details) + } +} + +func TestRecordKBActivityCanSuppressCompositeTaskChildren(t *testing.T) { + audit := &captureKBActivityAudit{} + ctx := withKBActivitySuppressed(context.Background()) + recordKBActivity(ctx, audit, 7, "kb-1", types.AuditActionKnowledgeCreated, + "knowledge", "knowledge-1", types.AuditOutcomeAccepted, nil) + if audit.entry != nil { + t.Fatalf("suppressed child activity was recorded: %#v", audit.entry) + } +} diff --git a/internal/application/service/kbshare.go b/internal/application/service/kbshare.go index 07fe34af..1b5033fe 100644 --- a/internal/application/service/kbshare.go +++ b/internal/application/service/kbshare.go @@ -27,7 +27,7 @@ var ( // in this org, with what role" rather than "is this user". The 3-D cap // inside CheckTenantKBPermission encodes: // -// effective = min(share.Permission, tenant_org_role, tenant_role_cap) +// effective = min(share.Permission, tenant_org_role, tenant_role_cap) // // where tenant_role_cap pins tenant Viewers to OrgRoleViewer regardless // of what the org-level grant said. That keeps the tenant RBAC promise @@ -39,6 +39,7 @@ type kbShareService struct { kbRepo interfaces.KnowledgeBaseRepository kgRepo interfaces.KnowledgeRepository chunkRepo interfaces.ChunkRepository + audit interfaces.AuditLogService } // NewKBShareService creates a new knowledge base share service @@ -48,6 +49,7 @@ func NewKBShareService( kbRepo interfaces.KnowledgeBaseRepository, kgRepo interfaces.KnowledgeRepository, chunkRepo interfaces.ChunkRepository, + audit interfaces.AuditLogService, ) interfaces.KBShareService { return &kbShareService{ shareRepo: shareRepo, @@ -55,6 +57,7 @@ func NewKBShareService( kbRepo: kbRepo, kgRepo: kgRepo, chunkRepo: chunkRepo, + audit: audit, } } @@ -129,12 +132,18 @@ func (s *kbShareService) ShareKnowledgeBase(ctx context.Context, kbID string, or if err := s.shareRepo.Update(ctx, existingShare); err != nil { return nil, err } + recordKBActivity(ctx, s.audit, kb.TenantID, kb.ID, types.AuditActionKBSharePermissionChanged, + "knowledge_base_share", existingShare.ID, types.AuditOutcomeSuccess, + map[string]any{"organization_id": orgID, "permission": permission}) return existingShare, nil } return nil, err } logger.Infof(ctx, "Knowledge base %s shared successfully to organization %s", kbID, orgID) + recordKBActivity(ctx, s.audit, kb.TenantID, kb.ID, types.AuditActionKBShareAdded, + "knowledge_base_share", share.ID, types.AuditOutcomeSuccess, + map[string]any{"organization_id": orgID, "permission": permission}) return share, nil } @@ -169,7 +178,13 @@ func (s *kbShareService) UpdateSharePermission(ctx context.Context, shareID stri share.Permission = permission share.UpdatedAt = time.Now() - return s.shareRepo.Update(ctx, share) + if err := s.shareRepo.Update(ctx, share); err != nil { + return err + } + recordKBActivity(ctx, s.audit, share.SourceTenantID, share.KnowledgeBaseID, types.AuditActionKBSharePermissionChanged, + "knowledge_base_share", share.ID, types.AuditOutcomeSuccess, + map[string]any{"organization_id": share.OrganizationID, "permission": permission}) + return nil } // RemoveShare removes a share. @@ -184,7 +199,13 @@ func (s *kbShareService) RemoveShare(ctx context.Context, shareID string, userID } if s.callerCanManageShare(ctx, share.SharedByUserID, share.SourceTenantID, share.OrganizationID, userID, tenantID) { - return s.shareRepo.Delete(ctx, shareID) + if err := s.shareRepo.Delete(ctx, shareID); err != nil { + return err + } + recordKBActivity(ctx, s.audit, share.SourceTenantID, share.KnowledgeBaseID, types.AuditActionKBShareRemoved, + "knowledge_base_share", share.ID, types.AuditOutcomeSuccess, + map[string]any{"organization_id": share.OrganizationID, "permission": share.Permission}) + return nil } return ErrSharePermissionDenied diff --git a/internal/application/service/knowledge.go b/internal/application/service/knowledge.go index d28493c9..2d6a00e8 100644 --- a/internal/application/service/knowledge.go +++ b/internal/application/service/knowledge.go @@ -77,6 +77,7 @@ type knowledgeService struct { // handled because the public surface is the SpanTracker interface, // which has a no-op fallback. See knowledge_span_tracker.go. spanTracker SpanTracker + audit interfaces.AuditLogService } const ( @@ -113,6 +114,7 @@ func NewKnowledgeService( wikiService interfaces.WikiPageService, taskPendingRepo interfaces.TaskPendingOpsRepository, spanTracker SpanTracker, + audit interfaces.AuditLogService, ) (interfaces.KnowledgeService, error) { return &knowledgeService{ config: config, @@ -141,6 +143,7 @@ func NewKnowledgeService( wikiService: wikiService, taskPendingRepo: taskPendingRepo, spanTracker: spanTracker, + audit: audit, }, nil } diff --git a/internal/application/service/knowledge_clone_move.go b/internal/application/service/knowledge_clone_move.go index d4d7c640..54e4c79d 100644 --- a/internal/application/service/knowledge_clone_move.go +++ b/internal/application/service/knowledge_clone_move.go @@ -459,6 +459,8 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) er if err := json.Unmarshal(t.Payload(), &payload); err != nil { return fmt.Errorf("failed to unmarshal KB clone payload: %w", err) } + ctx = payload.Initiator.Apply(ctx) + ctx = withKBActivityTask(ctx, payload.TaskID, "user") // Add tenant ID to context ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID) @@ -487,6 +489,9 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) er progress.Message = message progress.UpdatedAt = time.Now().Unix() _ = s.saveKBCloneProgress(ctx, progress) + recordKBActivity(ctx, s.audit, payload.TenantID, payload.TargetID, types.AuditActionKBCloneFailed, + "knowledge_base", payload.TargetID, types.AuditOutcomeFailed, + map[string]any{"source_kb_id": payload.SourceID, "task_id": payload.TaskID}) } } @@ -511,10 +516,21 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) er handleError(progress, err, "Failed to copy knowledge base configuration") return err } + if retryCount == 0 { + recordKBActivity(ctx, s.audit, payload.TenantID, payload.TargetID, types.AuditActionKBCloneStarted, + "knowledge_base", payload.TargetID, types.AuditOutcomeAccepted, + map[string]any{"source_kb_id": payload.SourceID, "task_id": payload.TaskID}) + } // Use different sync strategies based on knowledge base type if srcKB.Type == types.KnowledgeBaseTypeFAQ { - return s.cloneFAQKnowledgeBase(ctx, srcKB, dstKB, progress, handleError) + if err := s.cloneFAQKnowledgeBase(ctx, srcKB, dstKB, progress, handleError); err != nil { + return err + } + recordKBActivity(ctx, s.audit, payload.TenantID, payload.TargetID, types.AuditActionKBCloneCompleted, + "knowledge_base", payload.TargetID, types.AuditOutcomeSuccess, + map[string]any{"source_kb_id": payload.SourceID, "task_id": payload.TaskID, "total": progress.Total}) + return nil } // Document type: use Knowledge-level diff based on file_hash @@ -616,6 +632,9 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) er } logger.Infof(ctx, "KB clone task completed: %s", payload.TaskID) + recordKBActivity(ctx, s.audit, payload.TenantID, payload.TargetID, types.AuditActionKBCloneCompleted, + "knowledge_base", payload.TargetID, types.AuditOutcomeSuccess, + map[string]any{"source_kb_id": payload.SourceID, "task_id": payload.TaskID, "total": totalOperations}) return nil } @@ -975,6 +994,8 @@ func (s *knowledgeService) ProcessKnowledgeMove(ctx context.Context, t *asynq.Ta if err := json.Unmarshal(t.Payload(), &payload); err != nil { return fmt.Errorf("failed to unmarshal knowledge move payload: %w", err) } + ctx = payload.Initiator.Apply(ctx) + ctx = withKBActivityTask(ctx, payload.TaskID, "user") // Add tenant ID to context ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID) @@ -1003,6 +1024,20 @@ func (s *knowledgeService) ProcessKnowledgeMove(ctx context.Context, t *asynq.Ta progress.Message = message progress.UpdatedAt = time.Now().Unix() _ = s.saveKnowledgeMoveProgress(ctx, progress) + for _, kbID := range []string{payload.SourceKBID, payload.TargetKBID} { + recordKBActivity(ctx, s.audit, payload.TenantID, kbID, types.AuditActionKnowledgeMoveFailed, + "knowledge_move", payload.TaskID, types.AuditOutcomeFailed, + map[string]any{"source_kb_id": payload.SourceKBID, "target_kb_id": payload.TargetKBID, + "task_id": payload.TaskID, "count": len(payload.KnowledgeIDs), "mode": payload.Mode}) + } + } + } + if retryCount == 0 { + for _, kbID := range []string{payload.SourceKBID, payload.TargetKBID} { + recordKBActivity(ctx, s.audit, payload.TenantID, kbID, types.AuditActionKnowledgeMoveStarted, + "knowledge_move", payload.TaskID, types.AuditOutcomeAccepted, + map[string]any{"source_kb_id": payload.SourceKBID, "target_kb_id": payload.TargetKBID, + "task_id": payload.TaskID, "count": len(payload.KnowledgeIDs), "mode": payload.Mode}) } } @@ -1072,6 +1107,20 @@ func (s *knowledgeService) ProcessKnowledgeMove(ctx context.Context, t *asynq.Ta _ = s.saveKnowledgeMoveProgress(ctx, progress) logger.Infof(ctx, "ProcessKnowledgeMove: task=%s completed, processed=%d, failed=%d", payload.TaskID, progress.Processed, progress.Failed) + outcome := types.AuditOutcomeSuccess + action := types.AuditActionKnowledgeMoveCompleted + if progress.Failed == progress.Total && progress.Total > 0 { + outcome = types.AuditOutcomeFailed + action = types.AuditActionKnowledgeMoveFailed + } else if progress.Failed > 0 { + outcome = types.AuditOutcomePartial + } + for _, kbID := range []string{payload.SourceKBID, payload.TargetKBID} { + recordKBActivity(ctx, s.audit, payload.TenantID, kbID, action, + "knowledge_move", payload.TaskID, outcome, + map[string]any{"source_kb_id": payload.SourceKBID, "target_kb_id": payload.TargetKBID, + "task_id": payload.TaskID, "count": progress.Total, "failed": progress.Failed, "mode": payload.Mode}) + } return nil } diff --git a/internal/application/service/knowledge_create.go b/internal/application/service/knowledge_create.go index 07d922d9..84f5393c 100644 --- a/internal/application/service/knowledge_create.go +++ b/internal/application/service/knowledge_create.go @@ -232,7 +232,6 @@ func (s *knowledgeService) CreateKnowledgeFromFile(ctx context.Context, } return nil, err } - // Set tag relations if err := s.setAndAttachKnowledgeTags(ctx, tenantID, kbID, knowledge, tagIDs); err != nil { logger.Errorf(ctx, "Failed to set knowledge tags, knowledge ID: %s, error: %v", knowledge.ID, err) @@ -267,6 +266,12 @@ func (s *knowledgeService) CreateKnowledgeFromFile(ctx context.Context, payloadBytes, err := json.Marshal(taskPayload) if err != nil { logger.Errorf(ctx, "Failed to marshal document process task payload: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "file", "file_type": knowledge.FileType, + "processing_status": "failed", "failure_stage": "enqueue", + }) // 即使入队失败,也返回knowledge,因为文件已保存 return knowledge, nil } @@ -279,9 +284,20 @@ func (s *knowledgeService) CreateKnowledgeFromFile(ctx context.Context, info, err := s.task.Enqueue(task) if err != nil { logger.Errorf(ctx, "Failed to enqueue document process task: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "file", "file_type": knowledge.FileType, + "processing_status": "failed", "failure_stage": "enqueue", + }) // 即使入队失败,也返回knowledge,因为文件已保存 return knowledge, nil } + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeAccepted, map[string]any{ + "title": knowledge.Title, "source_type": "file", "file_type": knowledge.FileType, + "processing_status": "pending", "task_id": info.ID, "trigger": kbActivityTrigger(ctx), + }) logger.Infof( ctx, "Enqueued document process task: id=%s queue=%s knowledge_id=%s", @@ -417,7 +433,6 @@ func (s *knowledgeService) CreateKnowledgeFromURL(ctx context.Context, logger.Errorf(ctx, "Failed to create knowledge record: %v", err) return nil, err } - // Set tag relations if err := s.setAndAttachKnowledgeTags(ctx, tenantID, kbID, knowledge, tagIDs); err != nil { logger.Errorf(ctx, "Failed to set knowledge tags, knowledge ID: %s, error: %v", knowledge.ID, err) @@ -449,6 +464,12 @@ func (s *knowledgeService) CreateKnowledgeFromURL(ctx context.Context, payloadBytes, err := json.Marshal(taskPayload) if err != nil { logger.Errorf(ctx, "Failed to marshal URL process task payload: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "url", "file_type": knowledge.FileType, + "processing_status": "failed", "failure_stage": "enqueue", + }) return knowledge, nil } @@ -460,8 +481,19 @@ func (s *knowledgeService) CreateKnowledgeFromURL(ctx context.Context, info, err := s.task.Enqueue(task) if err != nil { logger.Errorf(ctx, "Failed to enqueue URL process task: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "url", "file_type": knowledge.FileType, + "processing_status": "failed", "failure_stage": "enqueue", + }) return knowledge, nil } + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeAccepted, map[string]any{ + "title": knowledge.Title, "source_type": "url", "file_type": knowledge.FileType, + "processing_status": "pending", "task_id": info.ID, "trigger": kbActivityTrigger(ctx), + }) logger.Infof(ctx, "Enqueued URL process task: id=%s queue=%s knowledge_id=%s", info.ID, info.Queue, knowledge.ID) logger.Infof(ctx, "Knowledge from URL created successfully, ID: %s", knowledge.ID) @@ -655,7 +687,6 @@ func (s *knowledgeService) createKnowledgeFromFileURL( logger.Errorf(ctx, "Failed to create knowledge record: %v", err) return nil, err } - // Set tag relations if err := s.setAndAttachKnowledgeTags(ctx, tenantID, kbID, knowledge, tagIDs); err != nil { logger.Errorf(ctx, "Failed to set knowledge tags, knowledge ID: %s, error: %v", knowledge.ID, err) @@ -688,6 +719,12 @@ func (s *knowledgeService) createKnowledgeFromFileURL( payloadBytes, err := json.Marshal(taskPayload) if err != nil { logger.Errorf(ctx, "Failed to marshal file URL process task payload: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "file_url", "file_type": knowledge.FileType, + "processing_status": "failed", "failure_stage": "enqueue", + }) return knowledge, nil } @@ -699,8 +736,19 @@ func (s *knowledgeService) createKnowledgeFromFileURL( info, err := s.task.Enqueue(task) if err != nil { logger.Errorf(ctx, "Failed to enqueue file URL process task: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "file_url", "file_type": knowledge.FileType, + "processing_status": "failed", "failure_stage": "enqueue", + }) return knowledge, nil } + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeAccepted, map[string]any{ + "title": knowledge.Title, "source_type": "file_url", "file_type": knowledge.FileType, + "processing_status": "pending", "task_id": info.ID, "trigger": kbActivityTrigger(ctx), + }) logger.Infof(ctx, "Enqueued file URL process task: id=%s queue=%s knowledge_id=%s", info.ID, info.Queue, knowledge.ID) logger.Infof(ctx, "Knowledge from file URL created successfully, ID: %s", knowledge.ID) @@ -808,7 +856,6 @@ func (s *knowledgeService) CreateKnowledgeFromManual(ctx context.Context, logger.Errorf(ctx, "Failed to create manual knowledge record: %v", err) return nil, err } - // Set tag relations if err := s.setAndAttachKnowledgeTags(ctx, tenantID, kbID, knowledge, payload.TagIDs); err != nil { logger.Errorf(ctx, "Failed to set knowledge tags, knowledge ID: %s, error: %v", knowledge.ID, err) @@ -817,13 +864,30 @@ func (s *knowledgeService) CreateKnowledgeFromManual(ctx context.Context, if status == types.ManualKnowledgeStatusPublish { logger.Infof(ctx, "Manual knowledge created, enqueuing async processing task, ID: %s", knowledge.ID) - if err := s.enqueueManualProcessing(ctx, knowledge, cleanContent, false); err != nil { + taskID, err := s.enqueueManualProcessing(ctx, knowledge, cleanContent, false) + if err != nil { logger.Errorf(ctx, "Failed to enqueue manual processing task for new knowledge: %v", err) // Non-fatal: mark as failed so user can retry knowledge.ParseStatus = "failed" knowledge.ErrorMessage = "Failed to enqueue processing task" s.repo.UpdateKnowledge(ctx, knowledge) + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "manual", "status": status, + "processing_status": "failed", "failure_stage": "enqueue", + }) + } else { + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeAccepted, map[string]any{ + "title": knowledge.Title, "source_type": "manual", "status": status, + "processing_status": "pending", "task_id": taskID, "trigger": kbActivityTrigger(ctx), + }) } + } else { + recordKBActivity(ctx, s.audit, tenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeSuccess, map[string]any{ + "title": knowledge.Title, "source_type": "manual", "status": status, + }) } return knowledge, nil @@ -885,11 +949,14 @@ func (s *knowledgeService) createKnowledgeFromPassageInternal(ctx context.Contex logger.Errorf(ctx, "Failed to create knowledge record: %v", err) return nil, err } - // Process passages if syncMode { logger.Info(ctx, "Processing passage synchronously") s.processDocumentFromPassage(ctx, kb, knowledge, safePassages) + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeSuccess, map[string]any{ + "title": knowledge.Title, "source_type": "passage", "processing_status": knowledge.ParseStatus, + }) logger.Infof(ctx, "Knowledge from passage created successfully (sync), ID: %s", knowledge.ID) } else { // Enqueue passage processing task to Asynq @@ -922,6 +989,12 @@ func (s *knowledgeService) createKnowledgeFromPassageInternal(ctx context.Contex payloadBytes, err := json.Marshal(taskPayload) if err != nil { logger.Errorf(ctx, "Failed to marshal passage process task payload: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "passage", + "processing_status": "failed", "failure_stage": "enqueue", + }) // 即使入队失败,也返回knowledge return knowledge, nil } @@ -934,8 +1007,19 @@ func (s *knowledgeService) createKnowledgeFromPassageInternal(ctx context.Contex info, err := s.task.Enqueue(task) if err != nil { logger.Errorf(ctx, "Failed to enqueue passage process task: %v", err) + s.markKnowledgeEnqueueFailed(ctx, knowledge) + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeFailed, map[string]any{ + "title": knowledge.Title, "source_type": "passage", + "processing_status": "failed", "failure_stage": "enqueue", + }) return knowledge, nil } + recordKBActivity(ctx, s.audit, knowledge.TenantID, kbID, types.AuditActionKnowledgeCreated, + "knowledge", knowledge.ID, types.AuditOutcomeAccepted, map[string]any{ + "title": knowledge.Title, "source_type": "passage", "processing_status": "pending", + "task_id": info.ID, "trigger": kbActivityTrigger(ctx), + }) logger.Infof(ctx, "Enqueued passage process task: id=%s queue=%s knowledge_id=%s", info.ID, info.Queue, knowledge.ID) logger.Infof(ctx, "Knowledge from passage created successfully, ID: %s", knowledge.ID) } @@ -1025,6 +1109,10 @@ func (s *knowledgeService) UpdateManualKnowledge(ctx context.Context, logger.Errorf(ctx, "Failed to persist manual draft: %v", err) return nil, err } + recordKBActivity(ctx, s.audit, tenantID, existing.KnowledgeBaseID, types.AuditActionKnowledgeUpdated, + "knowledge", existing.ID, types.AuditOutcomeSuccess, map[string]any{ + "title": existing.Title, "status": status, + }) return existing, nil } @@ -1043,21 +1131,32 @@ func (s *knowledgeService) UpdateManualKnowledge(ctx context.Context, } logger.Infof(ctx, "Manual knowledge updated, enqueuing async processing task, ID: %s", existing.ID) - if err := s.enqueueManualProcessing(ctx, existing, cleanContent, true); err != nil { + taskID, err := s.enqueueManualProcessing(ctx, existing, cleanContent, true) + if err != nil { logger.Errorf(ctx, "Failed to enqueue manual processing task: %v", err) // Non-fatal: mark as failed so user can retry existing.ParseStatus = "failed" existing.ErrorMessage = "Failed to enqueue processing task" s.repo.UpdateKnowledge(ctx, existing) + recordKBActivity(ctx, s.audit, tenantID, existing.KnowledgeBaseID, types.AuditActionKnowledgeUpdated, + "knowledge", existing.ID, types.AuditOutcomeFailed, map[string]any{ + "title": existing.Title, "status": status, + "processing_status": "failed", "failure_stage": "enqueue", + }) return nil, werrors.NewInternalServerError("Failed to submit processing task") } + recordKBActivity(ctx, s.audit, tenantID, existing.KnowledgeBaseID, types.AuditActionKnowledgeUpdated, + "knowledge", existing.ID, types.AuditOutcomeAccepted, map[string]any{ + "title": existing.Title, "status": status, "processing_status": "pending", + "task_id": taskID, "trigger": kbActivityTrigger(ctx), + }) return existing, nil } // enqueueManualProcessing enqueues a manual:process Asynq task for async cleanup + re-indexing. func (s *knowledgeService) enqueueManualProcessing(ctx context.Context, knowledge *types.Knowledge, content string, needCleanup bool, -) error { +) (string, error) { requestID, _ := types.RequestIDFromContext(ctx) payload := types.ManualProcessPayload{ RequestId: requestID, @@ -1070,17 +1169,31 @@ func (s *knowledgeService) enqueueManualProcessing(ctx context.Context, langfuse.InjectTracing(ctx, &payload) payloadBytes, err := json.Marshal(payload) if err != nil { - return fmt.Errorf("failed to marshal manual process payload: %w", err) + return "", fmt.Errorf("failed to marshal manual process payload: %w", err) } task := asynq.NewTask(types.TypeManualProcess, payloadBytes, asynq.Queue(types.QueueDefault), asynq.MaxRetry(3), asynq.Timeout(30*time.Minute)) info, err := s.task.Enqueue(task) if err != nil { - return fmt.Errorf("failed to enqueue manual process task: %w", err) + return "", fmt.Errorf("failed to enqueue manual process task: %w", err) } logger.Infof(ctx, "Enqueued manual process task: knowledge_id=%s, asynq_id=%s", knowledge.ID, info.ID) - return nil + return info.ID, nil +} + +// markKnowledgeEnqueueFailed prevents a durable knowledge row from remaining +// indefinitely "pending" when its background processing task was never +// created. The API may still return the row so callers can retry it. +func (s *knowledgeService) markKnowledgeEnqueueFailed(ctx context.Context, knowledge *types.Knowledge) { + if knowledge == nil { + return + } + knowledge.ParseStatus = "failed" + knowledge.ErrorMessage = "Failed to enqueue processing task" + if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil { + logger.Errorf(ctx, "Failed to mark knowledge as failed after enqueue error: %v", err) + } } func ensureManualFileName(title string) string { diff --git a/internal/application/service/knowledge_delete.go b/internal/application/service/knowledge_delete.go index d7518ebc..3af84cb9 100644 --- a/internal/application/service/knowledge_delete.go +++ b/internal/application/service/knowledge_delete.go @@ -197,6 +197,9 @@ func (s *knowledgeService) DeleteKnowledge(ctx context.Context, id string) error if err := s.tenantRepo.AdjustStorageUsed(ctx, tenantInfo.ID, -knowledge.StorageSize); err != nil { logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge update tenant storage used failed") } + recordKBActivity(ctx, s.audit, tenantID, knowledge.KnowledgeBaseID, types.AuditActionKnowledgeDeleted, + "knowledge", knowledge.ID, types.AuditOutcomeSuccess, + map[string]any{"title": knowledge.Title, "type": knowledge.Type}) return nil } @@ -626,6 +629,18 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []string if err := s.tenantRepo.AdjustStorageUsed(ctx, tenantInfo.ID, storageAdjust); err != nil { logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge update tenant storage used failed") } + byKB := make(map[string][]string) + for _, knowledge := range knowledgeList { + byKB[knowledge.KnowledgeBaseID] = append(byKB[knowledge.KnowledgeBaseID], knowledge.ID) + } + for kbID, knowledgeIDs := range byKB { + details := map[string]any{"count": len(knowledgeIDs)} + if len(knowledgeIDs) <= 20 { + details["knowledge_ids"] = knowledgeIDs + } + recordKBActivity(ctx, s.audit, tenantInfo.ID, kbID, types.AuditActionKnowledgeBatchDeleted, + "knowledge", "", types.AuditOutcomeSuccess, details) + } return nil } @@ -723,6 +738,9 @@ func (s *knowledgeService) ProcessKnowledgeListDelete(ctx context.Context, t *as logger.Errorf(ctx, "Failed to unmarshal knowledge list delete payload: %v", err) return err } + ctx = payload.Initiator.Apply(ctx) + taskID, _ := asynq.GetTaskID(ctx) + ctx = withKBActivityTask(ctx, taskID, "user") logger.Infof(ctx, "Processing knowledge list delete task for %d knowledge items", len(payload.KnowledgeIDs)) diff --git a/internal/application/service/knowledge_faq.go b/internal/application/service/knowledge_faq.go index 364770a5..8859aac6 100644 --- a/internal/application/service/knowledge_faq.go +++ b/internal/application/service/knowledge_faq.go @@ -245,6 +245,9 @@ func (s *knowledgeService) CreateFAQEntry(ctx context.Context, entry.TagName = tag.Name } } + recordKBActivity(ctx, s.audit, tenantID, kb.ID, types.AuditActionKnowledgeCreated, + "faq_entry", chunk.ID, types.AuditOutcomeSuccess, + map[string]any{"entry_id": chunk.SeqID, "source_type": "faq"}) return entry, nil } @@ -303,7 +306,6 @@ func (s *knowledgeService) GetFAQEntry(ctx context.Context, entry.TagName = tag.Name } } - return entry, nil } @@ -466,6 +468,9 @@ func (s *knowledgeService) UpdateFAQEntry(ctx context.Context, entry.TagName = tag.Name } } + recordKBActivity(ctx, s.audit, tenantID, kb.ID, types.AuditActionKnowledgeUpdated, + "faq_entry", chunk.ID, types.AuditOutcomeSuccess, + map[string]any{"entry_id": chunk.SeqID, "source_type": "faq"}) return entry, nil } @@ -655,6 +660,9 @@ func (s *knowledgeService) UpdateFAQEntryStatus(ctx context.Context, if err := retrieveEngine.BatchUpdateChunkEnabledStatus(ctx, chunkStatusMap); err != nil { return err } + recordKBActivity(ctx, s.audit, tenantID, kb.ID, types.AuditActionKnowledgeUpdated, + "faq_entry", chunk.ID, types.AuditOutcomeSuccess, + map[string]any{"entry_id": chunk.SeqID, "changed_fields": []string{"enabled"}}) return nil } @@ -857,6 +865,9 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context, } } } + recordKBActivity(ctx, s.audit, tenantID, kb.ID, types.AuditActionKnowledgeUpdated, + "faq_entry", "", types.AuditOutcomeSuccess, + map[string]any{"count": len(req.ByID), "tag_groups": len(req.ByTag), "batch": true}) return nil } @@ -1387,6 +1398,9 @@ func (s *knowledgeService) DeleteFAQEntries(ctx context.Context, return err } } + recordKBActivity(ctx, s.audit, tenantID, kb.ID, types.AuditActionKnowledgeBatchDeleted, + "faq_entry", "", types.AuditOutcomeSuccess, + map[string]any{"count": len(chunksToRemove), "source_type": "faq"}) return nil } diff --git a/internal/application/service/knowledge_process.go b/internal/application/service/knowledge_process.go index b109b9af..a624a71b 100644 --- a/internal/application/service/knowledge_process.go +++ b/internal/application/service/knowledge_process.go @@ -903,7 +903,6 @@ func (s *knowledgeService) ProcessSummaryGeneration(ctx context.Context, t *asyn logger.Errorf(ctx, "Failed to unmarshal summary generation payload: %v", err) return nil // Don't retry on unmarshal error } - logger.Infof(ctx, "Processing summary generation for knowledge: %s", payload.KnowledgeID) // Set tenant and language context @@ -2030,6 +2029,11 @@ func (s *knowledgeService) ReparseKnowledge( if kb != nil && kb.IsWikiEnabled() { s.prepareWikiForReparse(ctx, existing) } + recordReparseStarted := func() { + recordKBActivity(ctx, s.audit, tenantID, existing.KnowledgeBaseID, types.AuditActionKnowledgeReparseStarted, + "knowledge", existing.ID, types.AuditOutcomeAccepted, + map[string]any{"title": existing.Title, "type": existing.Type, "attempt": reparseAttempt}) + } // For manual knowledge, use async manual processing (cleanup + re-indexing in worker) if existing.IsManual() { @@ -2061,11 +2065,13 @@ func (s *knowledgeService) ReparseKnowledge( return nil, err } - if err := s.enqueueManualProcessing(ctx, existing, meta.Content, true); err != nil { + if _, err := s.enqueueManualProcessing(ctx, existing, meta.Content, true); err != nil { logger.Errorf(ctx, "Failed to enqueue manual reparse task: %v", err) existing.ParseStatus = "failed" existing.ErrorMessage = "Failed to enqueue processing task" s.repo.UpdateKnowledge(ctx, existing) + } else { + recordReparseStarted() } return existing, nil } @@ -2148,6 +2154,7 @@ func (s *knowledgeService) ReparseKnowledge( return existing, nil } logger.Infof(ctx, "Enqueued reparse task: id=%s queue=%s knowledge_id=%s", info.ID, info.Queue, existing.ID) + recordReparseStarted() // For data tables (csv, xlsx, xls), also enqueue summary task if slices.Contains([]string{"csv", "xlsx", "xls"}, getFileType(existing.FileName)) { @@ -2201,6 +2208,7 @@ func (s *knowledgeService) ReparseKnowledge( return existing, nil } logger.Infof(ctx, "Enqueued file URL reparse task: id=%s queue=%s knowledge_id=%s", info.ID, info.Queue, existing.ID) + recordReparseStarted() return existing, nil } @@ -2247,6 +2255,7 @@ func (s *knowledgeService) ReparseKnowledge( return existing, nil } logger.Infof(ctx, "Enqueued URL reparse task: id=%s queue=%s knowledge_id=%s", info.ID, info.Queue, existing.ID) + recordReparseStarted() return existing, nil } @@ -2351,6 +2360,9 @@ func (s *knowledgeService) CancelKnowledgeParse( // at isWikiKnowledgeAborted anyway, but scrubbing avoids waking the // batch in the first place. s.scrubWikiPendingIngest(ctx, existing.KnowledgeBaseID, knowledgeID, "cancel") + recordKBActivity(ctx, s.audit, tenantID, existing.KnowledgeBaseID, types.AuditActionKnowledgeParseCanceled, + "knowledge", existing.ID, types.AuditOutcomeCanceled, + map[string]any{"title": existing.Title, "type": existing.Type}) return existing, nil } @@ -3405,6 +3417,9 @@ func (s *knowledgeService) ProcessKnowledgeListReparse(ctx context.Context, t *a logger.Errorf(ctx, "Failed to unmarshal knowledge list reparse payload: %v", err) return err } + ctx = payload.Initiator.Apply(ctx) + taskID, _ := asynq.GetTaskID(ctx) + ctx = withKBActivityTask(ctx, taskID, "user") logger.Infof(ctx, "Processing knowledge list reparse task for %d knowledge items", len(payload.KnowledgeIDs)) diff --git a/internal/application/service/knowledgebase.go b/internal/application/service/knowledgebase.go index 88ca3d77..183b02eb 100644 --- a/internal/application/service/knowledgebase.go +++ b/internal/application/service/knowledgebase.go @@ -43,6 +43,7 @@ type knowledgeBaseService struct { dsRepo interfaces.DataSourceRepository syncLogRepo interfaces.SyncLogRepository dsScheduler *datasource.Scheduler + audit interfaces.AuditLogService } // NewKnowledgeBaseService creates a new knowledge base service @@ -62,6 +63,7 @@ func NewKnowledgeBaseService(repo interfaces.KnowledgeBaseRepository, dsRepo interfaces.DataSourceRepository, syncLogRepo interfaces.SyncLogRepository, dsScheduler *datasource.Scheduler, + audit interfaces.AuditLogService, ) interfaces.KnowledgeBaseService { return &knowledgeBaseService{ repo: repo, @@ -80,6 +82,7 @@ func NewKnowledgeBaseService(repo interfaces.KnowledgeBaseRepository, dsRepo: dsRepo, syncLogRepo: syncLogRepo, dsScheduler: dsScheduler, + audit: audit, } } @@ -151,6 +154,10 @@ func (s *knowledgeBaseService) CreateKnowledgeBase(ctx context.Context, }) return nil, err } + recordKBActivity(ctx, s.audit, kb.TenantID, kb.ID, types.AuditActionKBCreated, + "knowledge_base", kb.ID, types.AuditOutcomeSuccess, map[string]any{ + "name": kb.Name, "type": kb.Type, + }) logger.Infof(ctx, "Knowledge base created successfully, ID: %s, name: %s", kb.ID, kb.Name) return kb, nil @@ -485,6 +492,17 @@ func (s *knowledgeBaseService) UpdateKnowledgeBase(ctx context.Context, return nil, err } + changedFields := make([]string, 0, 3) + if kb.Name != name { + changedFields = append(changedFields, "name") + } + if kb.Description != description { + changedFields = append(changedFields, "description") + } + if config != nil { + changedFields = append(changedFields, "config") + } + // Update the knowledge base properties kb.Name = name kb.Description = description @@ -526,6 +544,10 @@ func (s *knowledgeBaseService) UpdateKnowledgeBase(ctx context.Context, }) return nil, err } + recordKBActivity(ctx, s.audit, kb.TenantID, kb.ID, types.AuditActionKBUpdated, + "knowledge_base", kb.ID, types.AuditOutcomeSuccess, map[string]any{ + "name": kb.Name, "changed_fields": changedFields, + }) logger.Infof(ctx, "Knowledge base updated successfully, ID: %s, name: %s", kb.ID, kb.Name) return kb, nil @@ -691,6 +713,12 @@ func (s *knowledgeBaseService) DeleteKnowledgeBase(ctx context.Context, id strin }) return err } + deletedName := "" + if kb != nil { + deletedName = kb.Name + } + recordKBActivity(ctx, s.audit, tenantID, id, types.AuditActionKBDeleted, + "knowledge_base", id, types.AuditOutcomeSuccess, map[string]any{"name": deletedName}) // Step 1b: Remove all organization shares for this KB so org settings no longer show them if s.shareRepo != nil { @@ -1127,6 +1155,10 @@ func (s *knowledgeBaseService) DuplicateKnowledgeBase( if err := s.repo.CreateKnowledgeBase(ctx, targetKB); err != nil { return nil, err } + recordKBActivity(ctx, s.audit, tenantID, targetKB.ID, types.AuditActionKBDuplicated, + "knowledge_base", targetKB.ID, types.AuditOutcomeSuccess, map[string]any{ + "source_kb_id": sourceKB.ID, "name": targetKB.Name, + }) return targetKB, nil } diff --git a/internal/application/service/tag.go b/internal/application/service/tag.go index d47d0d88..be2b889e 100644 --- a/internal/application/service/tag.go +++ b/internal/application/service/tag.go @@ -29,6 +29,7 @@ type knowledgeTagService struct { modelService interfaces.ModelService task interfaces.TaskEnqueuer kbShareService interfaces.KBShareService + audit interfaces.AuditLogService } // NewKnowledgeTagService creates a new tag service. @@ -42,6 +43,7 @@ func NewKnowledgeTagService( modelService interfaces.ModelService, task interfaces.TaskEnqueuer, kbShareService interfaces.KBShareService, + audit interfaces.AuditLogService, ) (interfaces.KnowledgeTagService, error) { return &knowledgeTagService{ kbService: kbService, @@ -53,6 +55,7 @@ func NewKnowledgeTagService( modelService: modelService, task: task, kbShareService: kbShareService, + audit: audit, }, nil } @@ -183,6 +186,8 @@ func (s *knowledgeTagService) CreateTag( if err := s.repo.Create(ctx, tag); err != nil { return nil, err } + recordKBActivity(ctx, s.audit, tag.TenantID, tag.KnowledgeBaseID, types.AuditActionTagCreated, + "knowledge_tag", tag.ID, types.AuditOutcomeSuccess, map[string]any{"name": tag.Name}) return tag, nil } @@ -220,6 +225,8 @@ func (s *knowledgeTagService) UpdateTag( if err := s.repo.Update(ctx, tag); err != nil { return nil, err } + recordKBActivity(ctx, s.audit, tag.TenantID, tag.KnowledgeBaseID, types.AuditActionTagUpdated, + "knowledge_tag", tag.ID, types.AuditOutcomeSuccess, map[string]any{"name": tag.Name}) return tag, nil } @@ -286,6 +293,7 @@ func (s *knowledgeTagService) DeleteTag(ctx context.Context, id string, force bo payload := types.KnowledgeListDeletePayload{ TenantID: tenantID, KnowledgeIDs: knowledgeIDs, + Initiator: types.TaskInitiatorFromContext(ctx), } langfuse.InjectTracing(ctx, &payload) payloadBytes, err := json.Marshal(payload) @@ -317,6 +325,9 @@ func (s *knowledgeTagService) DeleteTag(ctx context.Context, id string, force bo return err } } + recordKBActivity(ctx, s.audit, tenantID, tag.KnowledgeBaseID, types.AuditActionTagUpdated, + "knowledge_tag", tag.ID, types.AuditOutcomeSuccess, + map[string]any{"name": tag.Name, "content_cleared": true, "excluded_count": len(excludeIDs)}) return nil } @@ -341,9 +352,18 @@ func (s *knowledgeTagService) DeleteTag(ctx context.Context, id string, force bo // If there are excludeIDs, we cannot delete the tag itself as it still has content if len(excludeIDs) > 0 { + recordKBActivity(ctx, s.audit, tenantID, tag.KnowledgeBaseID, types.AuditActionTagUpdated, + "knowledge_tag", tag.ID, types.AuditOutcomeSuccess, + map[string]any{"name": tag.Name, "content_cleared": true, "excluded_count": len(excludeIDs)}) return nil } - return s.repo.Delete(ctx, tenantID, id) + if err := s.repo.Delete(ctx, tenantID, id); err != nil { + return err + } + recordKBActivity(ctx, s.audit, tenantID, tag.KnowledgeBaseID, types.AuditActionTagDeleted, + "knowledge_tag", tag.ID, types.AuditOutcomeSuccess, + map[string]any{"name": tag.Name, "force": force}) + return nil } // enqueueIndexDeleteTask enqueues an async task for index deletion (low priority). diff --git a/internal/application/service/wiki_log_entry.go b/internal/application/service/wiki_log_entry.go index f2d18a35..2ee9e6b8 100644 --- a/internal/application/service/wiki_log_entry.go +++ b/internal/application/service/wiki_log_entry.go @@ -7,24 +7,52 @@ import ( "github.com/Tencent/WeKnora/internal/types/interfaces" ) -// wikiLogEntryService is a thin wrapper over WikiLogEntryRepository. The -// event layer carries no business rules today, so the service just -// forwards to the repo — the indirection exists so handlers / ingest -// batch code depend on an interface rather than a concrete repo type. +// wikiLogEntryService persists the detailed Wiki feed and projects a bounded +// summary into the generic per-KB activity timeline. type wikiLogEntryService struct { - repo interfaces.WikiLogEntryRepository + repo interfaces.WikiLogEntryRepository + audit interfaces.AuditLogService } // NewWikiLogEntryService constructs a WikiLogEntryService backed by the // given repository. -func NewWikiLogEntryService(repo interfaces.WikiLogEntryRepository) interfaces.WikiLogEntryService { - return &wikiLogEntryService{repo: repo} +func NewWikiLogEntryService( + repo interfaces.WikiLogEntryRepository, + audit interfaces.AuditLogService, +) interfaces.WikiLogEntryService { + return &wikiLogEntryService{repo: repo, audit: audit} } // AppendBatch records the given events in one database round trip. Empty // batches are a no-op (the repo handles that). func (s *wikiLogEntryService) AppendBatch(ctx context.Context, entries []*types.WikiLogEntry) error { - return s.repo.AppendBatch(ctx, entries) + if err := s.repo.AppendBatch(ctx, entries); err != nil { + return err + } + type summary struct { + tenantID uint64 + count int + actions map[string]int + } + byKB := make(map[string]*summary) + for _, entry := range entries { + if entry == nil || entry.KnowledgeBaseID == "" { + continue + } + item := byKB[entry.KnowledgeBaseID] + if item == nil { + item = &summary{tenantID: entry.TenantID, actions: make(map[string]int)} + byKB[entry.KnowledgeBaseID] = item + } + item.count++ + item.actions[entry.Action]++ + } + for kbID, item := range byKB { + recordKBActivity(ctx, s.audit, item.tenantID, kbID, types.AuditActionWikiContentChanged, + "wiki", kbID, types.AuditOutcomeSuccess, + map[string]any{"count": item.count, "actions": item.actions}) + } + return nil } // List paginates the per-KB event feed. See repo.List for cursor semantics. diff --git a/internal/datasource/scheduler.go b/internal/datasource/scheduler.go index 999732fd..196327fe 100644 --- a/internal/datasource/scheduler.go +++ b/internal/datasource/scheduler.go @@ -168,6 +168,7 @@ func (s *Scheduler) triggerSync(dataSourceID string, tenantID uint64) { TenantID: tenantID, SyncLogID: syncLog.ID, ForceFull: false, + Trigger: "schedule", } langfuse.InjectTracing(ctx, payload) payloadJSON, _ := json.Marshal(payload) diff --git a/internal/handler/audit_log.go b/internal/handler/audit_log.go index 5e47309f..db26cca4 100644 --- a/internal/handler/audit_log.go +++ b/internal/handler/audit_log.go @@ -6,6 +6,7 @@ import ( "github.com/Tencent/WeKnora/internal/errors" "github.com/Tencent/WeKnora/internal/logger" + "github.com/Tencent/WeKnora/internal/middleware" "github.com/Tencent/WeKnora/internal/types" "github.com/Tencent/WeKnora/internal/types/interfaces" "github.com/gin-gonic/gin" @@ -76,11 +77,12 @@ func (h *AuditLogHandler) ListTenantAuditLog(c *gin.Context) { } q := &interfaces.AuditLogQuery{ - AfterID: afterID, - Limit: limit, - Action: types.AuditAction(c.Query("action")), - Outcome: types.AuditOutcome(c.Query("outcome")), - ActorUserID: c.Query("actor"), + AfterID: afterID, + Limit: limit, + Action: types.AuditAction(c.Query("action")), + Outcome: types.AuditOutcome(c.Query("outcome")), + ActorUserID: c.Query("actor"), + UnscopedOnly: true, } entries, err := h.auditService.List(ctx, tenantID, q) @@ -105,6 +107,85 @@ func (h *AuditLogHandler) ListTenantAuditLog(c *gin.Context) { }) } +// ListKnowledgeBaseActivity returns the durable activity projection for one +// knowledge base. The route has already resolved KB access; this handler adds +// an owner-tenant check so organization-shared consumers cannot inspect source +// workspace actors or configuration history. +// @Summary 获取知识库活动记录 +// @Description 返回知识库的重要变更与后台任务入口。仅知识库创建者或所属空间管理员可读,共享空间不可读。 +// @Tags 知识库 +// @Produce json +// @Param id path string true "知识库ID" +// @Param after_id query int false "游标:返回 id 小于此值的记录" +// @Param limit query int false "页大小,1-100,默认 50" +// @Param action query string false "按 action 精确过滤" +// @Param outcome query string false "按 outcome 精确过滤" +// @Param actor query string false "按 actor_user_id 精确过滤" +// @Success 200 {object} auditLogListResponse +// @Failure 403 {object} errors.AppError +// @Security Bearer +// @Router /knowledge-bases/{id}/activity [get] +func (h *AuditLogHandler) ListKnowledgeBaseActivity(c *gin.Context) { + ctx := c.Request.Context() + kbID := c.Param("id") + access, ok := middleware.KBAccessFromContext(c) + if !ok || access == nil || access.KnowledgeBase == nil || access.KnowledgeBase.ID != kbID { + c.Error(errors.NewNotFoundError("knowledge base not found")) + return + } + callerTenantID := c.GetUint64(types.TenantIDContextKey.String()) + if callerTenantID == 0 || access.KnowledgeBase.TenantID != callerTenantID { + c.Error(errors.NewForbiddenError("knowledge base activity is only available in the owner workspace")) + return + } + actorID, _ := types.UserIDFromContext(ctx) + role := types.TenantRoleFromContext(ctx) + if access.KnowledgeBase.CreatorID != actorID && !role.HasPermission(types.TenantRoleAdmin) { + c.Error(errors.NewForbiddenError("knowledge base activity requires creator or admin access")) + return + } + + afterID, limit := parseAuditCursor(c) + q := &interfaces.AuditLogQuery{ + AfterID: afterID, + Limit: limit, + Action: types.AuditAction(c.Query("action")), + Outcome: types.AuditOutcome(c.Query("outcome")), + ActorUserID: c.Query("actor"), + ScopeType: "knowledge_base", + ScopeID: kbID, + } + entries, err := h.auditService.List(ctx, access.KnowledgeBase.TenantID, q) + if err != nil { + logger.ErrorWithFields(ctx, err, map[string]interface{}{"knowledge_base_id": kbID}) + c.Error(errors.NewInternalServerError(err.Error())) + return + } + var nextCursor uint64 + if n := len(entries); n > 0 { + nextCursor = entries[n-1].ID + } + c.JSON(http.StatusOK, auditLogListResponse{ + Success: true, Data: entries, NextCursor: nextCursor, + }) +} + +func parseAuditCursor(c *gin.Context) (uint64, int) { + var afterID uint64 + if raw := c.Query("after_id"); raw != "" { + if v, err := strconv.ParseUint(raw, 10, 64); err == nil { + afterID = v + } + } + limit := 0 + if raw := c.Query("limit"); raw != "" { + if v, err := strconv.Atoi(raw); err == nil && v > 0 { + limit = v + } + } + return afterID, limit +} + // ListSystemAuditLog godoc // @Summary 获取平台审计日志 // @Description 返回 system-scope(tenant_id=0)的审计事件,覆盖 system.setting_changed / system.admin_promoted / system.admin_revoked 等 SystemAdmin 操作。按 id 倒序的游标分页。 diff --git a/internal/handler/audit_log_test.go b/internal/handler/audit_log_test.go index d9ef3524..e9604fe5 100644 --- a/internal/handler/audit_log_test.go +++ b/internal/handler/audit_log_test.go @@ -100,6 +100,9 @@ func TestAuditLogHandler_PassesQueryFiltersThrough(t *testing.T) { if q.ActorUserID != "u-probing" { t.Fatalf("expected actor=u-probing, got %q", q.ActorUserID) } + if !q.UnscopedOnly { + t.Fatalf("tenant audit feed must exclude resource-scoped activity rows") + } return nil, nil }, } @@ -154,6 +157,81 @@ func TestAuditLogHandler_InvalidTenantIDReturns400(t *testing.T) { } } +func newKBActivityHandlerTestRouter( + t *testing.T, + svc interfaces.AuditLogService, + callerTenantID uint64, + kb *types.KnowledgeBase, + userID string, + role types.TenantRole, +) *gin.Engine { + t.Helper() + gin.SetMode(gin.TestMode) + r := gin.New() + r.Use(middleware.ErrorHandler()) + r.Use(func(c *gin.Context) { + c.Set(types.TenantIDContextKey.String(), callerTenantID) + c.Set(middleware.KBAccessContextKey, &middleware.KBAccess{KnowledgeBase: kb}) + ctx := context.WithValue(c.Request.Context(), types.UserIDContextKey, userID) + ctx = context.WithValue(ctx, types.TenantRoleContextKey, role) + c.Request = c.Request.WithContext(ctx) + c.Next() + }) + h := NewAuditLogHandler(svc) + r.GET("/knowledge-bases/:id/activity", h.ListKnowledgeBaseActivity) + return r +} + +func TestKnowledgeBaseActivityHandler_UsesKBScope(t *testing.T) { + svc := &stubAuditService{list: func(_ context.Context, tenantID uint64, q *interfaces.AuditLogQuery) ([]*types.AuditLog, error) { + if tenantID != 7 || q.ScopeType != "knowledge_base" || q.ScopeID != "kb-1" { + t.Fatalf("unexpected scope: tenant=%d type=%q id=%q", tenantID, q.ScopeType, q.ScopeID) + } + if q.AfterID != 30 || q.Limit != 10 || q.Outcome != types.AuditOutcomePartial { + t.Fatalf("unexpected filters: %+v", q) + } + return []*types.AuditLog{{ID: 21, TenantID: 7, ScopeType: q.ScopeType, ScopeID: q.ScopeID}}, nil + }} + w := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodGet, "/knowledge-bases/kb-1/activity?after_id=30&limit=10&outcome=partial", nil) + newKBActivityHandlerTestRouter(t, svc, 7, + &types.KnowledgeBase{ID: "kb-1", TenantID: 7, CreatorID: "creator"}, + "creator", types.TenantRoleViewer).ServeHTTP(w, req) + if w.Code != http.StatusOK { + t.Fatalf("expected 200, got %d body=%s", w.Code, w.Body.String()) + } +} + +func TestKnowledgeBaseActivityHandler_BlocksSharedWorkspace(t *testing.T) { + svc := &stubAuditService{list: func(_ context.Context, _ uint64, _ *interfaces.AuditLogQuery) ([]*types.AuditLog, error) { + t.Fatal("audit list must not be called for a shared workspace") + return nil, nil + }} + w := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodGet, "/knowledge-bases/kb-1/activity", nil) + newKBActivityHandlerTestRouter(t, svc, 8, + &types.KnowledgeBase{ID: "kb-1", TenantID: 7, CreatorID: "creator"}, + "creator", types.TenantRoleOwner).ServeHTTP(w, req) + if w.Code != http.StatusForbidden { + t.Fatalf("expected 403, got %d body=%s", w.Code, w.Body.String()) + } +} + +func TestKnowledgeBaseActivityHandler_RequiresCreatorOrAdmin(t *testing.T) { + svc := &stubAuditService{list: func(_ context.Context, _ uint64, _ *interfaces.AuditLogQuery) ([]*types.AuditLog, error) { + t.Fatal("audit list must not be called for ordinary members") + return nil, nil + }} + w := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodGet, "/knowledge-bases/kb-1/activity", nil) + newKBActivityHandlerTestRouter(t, svc, 7, + &types.KnowledgeBase{ID: "kb-1", TenantID: 7, CreatorID: "creator"}, + "other", types.TenantRoleContributor).ServeHTTP(w, req) + if w.Code != http.StatusForbidden { + t.Fatalf("expected 403, got %d body=%s", w.Code, w.Body.String()) + } +} + // ---- ListSystemAuditLog (platform / system-scope feed) ---------------- // // Mirrors the per-tenant suite above but covers the new diff --git a/internal/handler/knowledge.go b/internal/handler/knowledge.go index da43e962..6fd32ea4 100644 --- a/internal/handler/knowledge.go +++ b/internal/handler/knowledge.go @@ -249,6 +249,7 @@ func (h *KnowledgeHandler) enqueueKnowledgeListDelete( payload := types.KnowledgeListDeletePayload{ TenantID: tenantID, KnowledgeIDs: ids, + Initiator: types.TaskInitiatorFromContext(ctx), } langfuse.InjectTracing(ctx, &payload) payloadBytes, err := json.Marshal(payload) @@ -273,6 +274,7 @@ func (h *KnowledgeHandler) enqueueKnowledgeListReparse( TenantID: tenantID, KnowledgeIDs: ids, ProcessConfig: processConfig, + Initiator: types.TaskInitiatorFromContext(ctx), } langfuse.InjectTracing(ctx, &payload) payloadBytes, err := json.Marshal(payload) @@ -2219,6 +2221,7 @@ func (h *KnowledgeHandler) MoveKnowledge(c *gin.Context) { SourceKBID: req.SourceKBID, TargetKBID: req.TargetKBID, Mode: req.Mode, + Initiator: types.TaskInitiatorFromContext(ctx), } langfuse.InjectTracing(ctx, &payload) diff --git a/internal/handler/knowledgebase.go b/internal/handler/knowledgebase.go index 9fbf2759..fef0f3db 100644 --- a/internal/handler/knowledgebase.go +++ b/internal/handler/knowledgebase.go @@ -1081,10 +1081,11 @@ func (h *KnowledgeBaseHandler) CopyKnowledgeBase(c *gin.Context) { // Create KB clone payload payload := types.KBClonePayload{ - TenantID: tenantID.(uint64), - TaskID: taskID, - SourceID: req.SourceID, - TargetID: req.TargetID, + TenantID: tenantID.(uint64), + TaskID: taskID, + SourceID: req.SourceID, + TargetID: req.TargetID, + Initiator: types.TaskInitiatorFromContext(ctx), } langfuse.InjectTracing(ctx, &payload) diff --git a/internal/router/router.go b/internal/router/router.go index 0de4bebb..568ba260 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -230,6 +230,7 @@ func NewRouter(params RouterParams) *gin.Engine { RegisterTenantRoutes(v1, params.TenantHandler, params.TenantMemberHandler, params.TenantInvitationHandler, params.AuditLogHandler, rbacGuards) RegisterMyInvitationRoutes(v1, params.TenantInvitationHandler) RegisterKnowledgeBaseRoutes(v1, params.KBHandler, rbacGuards) + RegisterKnowledgeBaseActivityRoutes(v1, params.AuditLogHandler, rbacGuards) // KB-scoped image proxy: lets tenants render images embedded in // org-shared / agent-visible KB content, which the tenant-scoped // /files route cannot serve because it enforces same-tenant paths. @@ -502,6 +503,17 @@ func RegisterKnowledgeBaseRoutes(r *gin.RouterGroup, handler *handler.KnowledgeB } } +// RegisterKnowledgeBaseActivityRoutes exposes the read-only per-KB activity +// feed. It intentionally stays JWT-only: audit history is a sensitive owner +// surface and no existing workspace API-key capability grants audit access. +func RegisterKnowledgeBaseActivityRoutes(r *gin.RouterGroup, auditHandler *handler.AuditLogHandler, g *rbacGuards) { + if auditHandler == nil { + return + } + r.GET("/knowledge-bases/:id/activity", + g.OwnedKBOrAdmin(), g.KBAccessRead("id"), auditHandler.ListKnowledgeBaseActivity) +} + // RegisterKnowledgeTagRoutes 注册知识库标签相关路由。 // // Tags are KB metadata: Viewer reads, Contributor writes. Per-KB diff --git a/internal/types/audit_log.go b/internal/types/audit_log.go index 7ffc89c3..e20fb571 100644 --- a/internal/types/audit_log.go +++ b/internal/types/audit_log.go @@ -131,32 +131,81 @@ const ( AuditActionSystemQueueTaskDeleted AuditAction = "system.queue_task_deleted" AuditActionSystemQueueTaskRunNow AuditAction = "system.queue_task_run_now" AuditActionSystemQueueTaskCancelled AuditAction = "system.queue_task_cancelled" + + // Knowledge-base activity actions. These rows use scope_type=knowledge_base + // and scope_id=; TargetType/TargetID identify the concrete child + // resource when the operation is about a document, tag, data source, or share. + AuditActionKBCreated AuditAction = "kb.created" + AuditActionKBUpdated AuditAction = "kb.updated" + AuditActionKBDeleted AuditAction = "kb.deleted" + AuditActionKBDuplicated AuditAction = "kb.duplicated" + AuditActionKBCloneStarted AuditAction = "kb.clone_started" + AuditActionKBCloneCompleted AuditAction = "kb.clone_completed" + AuditActionKBCloneFailed AuditAction = "kb.clone_failed" + + AuditActionKnowledgeCreated AuditAction = "knowledge.created" + AuditActionKnowledgeUpdated AuditAction = "knowledge.updated" + AuditActionKnowledgeDeleted AuditAction = "knowledge.deleted" + AuditActionKnowledgeBatchDeleted AuditAction = "knowledge.batch_deleted" + AuditActionKnowledgeReparseStarted AuditAction = "knowledge.reparse_started" + AuditActionKnowledgeParseCanceled AuditAction = "knowledge.parse_canceled" + AuditActionKnowledgeMoveStarted AuditAction = "knowledge.move_started" + AuditActionKnowledgeMoveCompleted AuditAction = "knowledge.move_completed" + AuditActionKnowledgeMoveFailed AuditAction = "knowledge.move_failed" + + AuditActionTagCreated AuditAction = "tag.created" + AuditActionTagUpdated AuditAction = "tag.updated" + AuditActionTagDeleted AuditAction = "tag.deleted" + + AuditActionDataSourceCreated AuditAction = "datasource.created" + AuditActionDataSourceUpdated AuditAction = "datasource.updated" + AuditActionDataSourceDeleted AuditAction = "datasource.deleted" + AuditActionDataSourceSyncStarted AuditAction = "datasource.sync_started" + AuditActionDataSourceSyncCompleted AuditAction = "datasource.sync_completed" + AuditActionDataSourceSyncFailed AuditAction = "datasource.sync_failed" + AuditActionDataSourcePaused AuditAction = "datasource.paused" + AuditActionDataSourceResumed AuditAction = "datasource.resumed" + + AuditActionKBShareAdded AuditAction = "kb.share_added" + AuditActionKBSharePermissionChanged AuditAction = "kb.share_permission_changed" + AuditActionKBShareRemoved AuditAction = "kb.share_removed" + AuditActionWikiContentChanged AuditAction = "wiki.content_changed" ) -// AuditOutcome distinguishes successful mutations from middleware-level -// rejections. The split lets the audit-log UI highlight denials in red -// without needing to enumerate every action class. +// AuditOutcome separates asynchronous acceptance from terminal business +// results and middleware-level rejections. The UI can therefore avoid +// presenting a queued operation as already completed. type AuditOutcome string const ( AuditOutcomeSuccess AuditOutcome = "success" - AuditOutcomeDenied AuditOutcome = "denied" + // Accepted means the durable request was created and asynchronous work was + // submitted, but the background operation has not reached a terminal state. + AuditOutcomeAccepted AuditOutcome = "accepted" + AuditOutcomeDenied AuditOutcome = "denied" + AuditOutcomeFailed AuditOutcome = "failed" + AuditOutcomePartial AuditOutcome = "partial" + AuditOutcomeCanceled AuditOutcome = "canceled" ) // AuditLog is a single immutable audit event. The schema is intentionally // generic: PR 6 wires only RBAC events, but TargetType / TargetID / // Details are set up to absorb KB / agent / datasource events in -// follow-up PRs without another migration. +// follow-up PRs without another migration. Knowledge-base task events use a +// bounded convention inside Details: task_id, trigger, processing_status, +// source/target ids, aggregate counts, and operation-specific mode/attempt. // // Rows are append-only — no UpdatedAt, no soft-delete column. The // monotonic ID acts as both primary key and pagination cursor (newest- // first is `WHERE id < AfterID ORDER BY id DESC`). type AuditLog struct { - ID uint64 `json:"id" gorm:"primaryKey;autoIncrement"` - TenantID uint64 `json:"tenant_id" gorm:"not null;index:idx_audit_logs_tenant_id_desc,priority:1;index:idx_audit_logs_tenant_action,priority:1"` + ID uint64 `json:"id" gorm:"primaryKey;autoIncrement;index:idx_audit_logs_tenant_scope_desc,priority:4,sort:desc"` + TenantID uint64 `json:"tenant_id" gorm:"not null;index:idx_audit_logs_tenant_id_desc,priority:1;index:idx_audit_logs_tenant_action,priority:1;index:idx_audit_logs_tenant_scope_desc,priority:1"` ActorUserID string `json:"actor_user_id" gorm:"type:varchar(36);default:'';index:idx_audit_logs_actor"` ActorRole string `json:"actor_role" gorm:"type:varchar(32);default:''"` Action AuditAction `json:"action" gorm:"type:varchar(64);not null;index:idx_audit_logs_tenant_action,priority:2"` + ScopeType string `json:"scope_type" gorm:"type:varchar(32);default:'';index:idx_audit_logs_tenant_scope_desc,priority:2"` + ScopeID string `json:"scope_id" gorm:"type:varchar(64);default:'';index:idx_audit_logs_tenant_scope_desc,priority:3"` TargetType string `json:"target_type" gorm:"type:varchar(32);default:''"` TargetID string `json:"target_id" gorm:"type:varchar(64);default:''"` TargetUserID string `json:"target_user_id" gorm:"type:varchar(36);default:''"` diff --git a/internal/types/context_helpers.go b/internal/types/context_helpers.go index 65d483c9..9a7b2f28 100644 --- a/internal/types/context_helpers.go +++ b/internal/types/context_helpers.go @@ -54,6 +54,39 @@ func UserIDFromContext(ctx context.Context) (string, bool) { return v, ok && v != "" } +// TaskInitiator is the authenticated caller that submitted an asynchronous +// task. Workers restore it into their context so audit entries describe who +// initiated the operation, while tasks created by schedulers remain +// attributable to the system. +type TaskInitiator struct { + UserID string `json:"user_id,omitempty"` + Role TenantRole `json:"role,omitempty"` +} + +// TaskInitiatorFromContext snapshots the real caller identity for a task +// payload. Synthetic API-key users are service identities, not people, and are +// intentionally left empty so the activity feed presents them as system work. +func TaskInitiatorFromContext(ctx context.Context) TaskInitiator { + userID, ok := UserIDFromContext(ctx) + if !ok || IsSyntheticUserID(userID) { + return TaskInitiator{} + } + return TaskInitiator{UserID: userID, Role: TenantRoleFromContext(ctx)} +} + +// Apply restores a captured task initiator onto a worker context. Empty or +// legacy payloads are a no-op and therefore retain the system-task fallback. +func (i TaskInitiator) Apply(ctx context.Context) context.Context { + if i.UserID == "" { + return ctx + } + ctx = context.WithValue(ctx, UserIDContextKey, i.UserID) + if i.Role.IsValid() { + ctx = context.WithValue(ctx, TenantRoleContextKey, i.Role) + } + return ctx +} + // IsSyntheticUserID reports whether id refers to the synthetic system // user that the X-API-Key auth path attaches to each tenant // (User.ID = "system-"). These users have no real human diff --git a/internal/types/datasource.go b/internal/types/datasource.go index 693542bb..8b9f7ed2 100644 --- a/internal/types/datasource.go +++ b/internal/types/datasource.go @@ -415,6 +415,9 @@ func (e *SyncItemError) UnmarshalJSON(b []byte) error { // DataSourceSyncPayload represents the asynq task payload for data source sync type DataSourceSyncPayload struct { TracingContext + Initiator TaskInitiator `json:"initiator,omitempty"` + // Trigger distinguishes a user-requested run from a scheduler-created run. + Trigger string `json:"trigger,omitempty"` // Data source ID to sync DataSourceID string `json:"data_source_id"` diff --git a/internal/types/interfaces/audit_log.go b/internal/types/interfaces/audit_log.go index c308f7f2..369ec12c 100644 --- a/internal/types/interfaces/audit_log.go +++ b/internal/types/interfaces/audit_log.go @@ -14,11 +14,14 @@ import ( // Limit is capped at 100 inside the repository regardless of caller // input — keeps unbounded scans off the table. type AuditLogQuery struct { - AfterID uint64 - Limit int - Action types.AuditAction - Outcome types.AuditOutcome - ActorUserID string + AfterID uint64 + Limit int + Action types.AuditAction + Outcome types.AuditOutcome + ActorUserID string + ScopeType string + ScopeID string + UnscopedOnly bool } // AuditLogRepository is the storage primitive for the audit table. diff --git a/internal/types/task.go b/internal/types/task.go index a3cab477..eb84aa03 100644 --- a/internal/types/task.go +++ b/internal/types/task.go @@ -29,19 +29,19 @@ const ( // name "low" so tasks enqueued by older releases remain consumable during a // rolling deployment. New code uses the business-semantic constant. const ( - QueueDefault = "default" + QueueDefault = "default" // QueueChatAttachment carries session-scoped chat attachment parsing. It // lives in the core pool but with a higher weight than QueueDefault so // interactive chat uploads are not starved by knowledge-base batch imports. QueueChatAttachment = "chat_attachment" QueuePostProcess = "postprocess" - QueueSummary = "summary" - QueueMultimodal = "multimodal" - QueueGraph = "graph" - QueueQuestion = "question" - QueueSync = "sync" - QueueMaintenance = "low" - QueueWiki = "wiki" + QueueSummary = "summary" + QueueMultimodal = "multimodal" + QueueGraph = "graph" + QueueQuestion = "question" + QueueSync = "sync" + QueueMaintenance = "low" + QueueWiki = "wiki" ) // QueueDefinition is the single source of truth for queue topology. Worker @@ -367,10 +367,11 @@ type SummaryGenerationPayload struct { // KBClonePayload represents the knowledge base clone task payload type KBClonePayload struct { TracingContext - TenantID uint64 `json:"tenant_id"` - TaskID string `json:"task_id"` - SourceID string `json:"source_id"` - TargetID string `json:"target_id"` + TenantID uint64 `json:"tenant_id"` + TaskID string `json:"task_id"` + SourceID string `json:"source_id"` + TargetID string `json:"target_id"` + Initiator TaskInitiator `json:"initiator,omitempty"` } // IndexDeletePayload represents the index delete task payload @@ -403,8 +404,9 @@ type KBDeletePayload struct { // KnowledgeListDeletePayload represents the batch knowledge delete task payload type KnowledgeListDeletePayload struct { TracingContext - TenantID uint64 `json:"tenant_id"` - KnowledgeIDs []string `json:"knowledge_ids"` + TenantID uint64 `json:"tenant_id"` + KnowledgeIDs []string `json:"knowledge_ids"` + Initiator TaskInitiator `json:"initiator,omitempty"` } // KnowledgeListReparsePayload represents the batch knowledge reparse task payload @@ -413,17 +415,19 @@ type KnowledgeListReparsePayload struct { TenantID uint64 `json:"tenant_id"` KnowledgeIDs []string `json:"knowledge_ids"` ProcessConfig *KnowledgeProcessOverrides `json:"process_config,omitempty"` + Initiator TaskInitiator `json:"initiator,omitempty"` } // KnowledgeMovePayload represents the knowledge move task payload type KnowledgeMovePayload struct { TracingContext - TenantID uint64 `json:"tenant_id"` - TaskID string `json:"task_id"` - KnowledgeIDs []string `json:"knowledge_ids"` - SourceKBID string `json:"source_kb_id"` - TargetKBID string `json:"target_kb_id"` - Mode string `json:"mode"` // "reuse_vectors" or "reparse" + TenantID uint64 `json:"tenant_id"` + TaskID string `json:"task_id"` + KnowledgeIDs []string `json:"knowledge_ids"` + SourceKBID string `json:"source_kb_id"` + TargetKBID string `json:"target_kb_id"` + Mode string `json:"mode"` // "reuse_vectors" or "reparse" + Initiator TaskInitiator `json:"initiator,omitempty"` } // KnowledgeMoveProgress represents the progress of a knowledge move task diff --git a/internal/types/task_initiator_test.go b/internal/types/task_initiator_test.go new file mode 100644 index 00000000..f2ac06f9 --- /dev/null +++ b/internal/types/task_initiator_test.go @@ -0,0 +1,36 @@ +package types + +import ( + "context" + "testing" +) + +func TestTaskInitiatorRoundTrip(t *testing.T) { + requestCtx := context.WithValue(context.Background(), UserIDContextKey, "user-1") + requestCtx = context.WithValue(requestCtx, TenantRoleContextKey, TenantRoleAdmin) + + initiator := TaskInitiatorFromContext(requestCtx) + if initiator.UserID != "user-1" || initiator.Role != TenantRoleAdmin { + t.Fatalf("TaskInitiatorFromContext() = %#v", initiator) + } + + workerCtx := initiator.Apply(context.Background()) + if userID, ok := UserIDFromContext(workerCtx); !ok || userID != "user-1" { + t.Fatalf("restored user = %q, %v", userID, ok) + } + if role := TenantRoleFromContext(workerCtx); role != TenantRoleAdmin { + t.Fatalf("restored role = %q", role) + } +} + +func TestTaskInitiatorOmitsSyntheticAndLegacyActors(t *testing.T) { + synthetic := context.WithValue(context.Background(), UserIDContextKey, "system-42") + if got := TaskInitiatorFromContext(synthetic); got.UserID != "" { + t.Fatalf("synthetic initiator = %#v", got) + } + + legacyCtx := (TaskInitiator{}).Apply(context.Background()) + if userID, ok := UserIDFromContext(legacyCtx); ok || userID != "" { + t.Fatalf("legacy user = %q, %v", userID, ok) + } +} diff --git a/migrations/sqlite/000001_kb_activity_scope.down.sql b/migrations/sqlite/000001_kb_activity_scope.down.sql new file mode 100644 index 00000000..545d925c --- /dev/null +++ b/migrations/sqlite/000001_kb_activity_scope.down.sql @@ -0,0 +1,4 @@ +DROP INDEX IF EXISTS idx_audit_logs_tenant_scope_desc; + +ALTER TABLE audit_logs DROP COLUMN scope_id; +ALTER TABLE audit_logs DROP COLUMN scope_type; diff --git a/migrations/sqlite/000001_kb_activity_scope.up.sql b/migrations/sqlite/000001_kb_activity_scope.up.sql new file mode 100644 index 00000000..7b2ab303 --- /dev/null +++ b/migrations/sqlite/000001_kb_activity_scope.up.sql @@ -0,0 +1,5 @@ +ALTER TABLE audit_logs ADD COLUMN scope_type VARCHAR(32) NOT NULL DEFAULT ''; +ALTER TABLE audit_logs ADD COLUMN scope_id VARCHAR(64) NOT NULL DEFAULT ''; + +CREATE INDEX IF NOT EXISTS idx_audit_logs_tenant_scope_desc + ON audit_logs(tenant_id, scope_type, scope_id, id DESC); diff --git a/migrations/versioned/000073_kb_activity_scope.down.sql b/migrations/versioned/000073_kb_activity_scope.down.sql new file mode 100644 index 00000000..1e764fa8 --- /dev/null +++ b/migrations/versioned/000073_kb_activity_scope.down.sql @@ -0,0 +1,5 @@ +DROP INDEX IF EXISTS idx_audit_logs_tenant_scope_desc; + +ALTER TABLE audit_logs + DROP COLUMN IF EXISTS scope_id, + DROP COLUMN IF EXISTS scope_type; diff --git a/migrations/versioned/000073_kb_activity_scope.up.sql b/migrations/versioned/000073_kb_activity_scope.up.sql new file mode 100644 index 00000000..9d4273d1 --- /dev/null +++ b/migrations/versioned/000073_kb_activity_scope.up.sql @@ -0,0 +1,8 @@ +-- Add a generic parent scope to audit rows so one immutable audit stream can +-- project resource-specific activity feeds without one log table per feature. +ALTER TABLE audit_logs + ADD COLUMN IF NOT EXISTS scope_type VARCHAR(32) NOT NULL DEFAULT '', + ADD COLUMN IF NOT EXISTS scope_id VARCHAR(64) NOT NULL DEFAULT ''; + +CREATE INDEX IF NOT EXISTS idx_audit_logs_tenant_scope_desc + ON audit_logs (tenant_id, scope_type, scope_id, id DESC);