572 lines
22 KiB
Go
572 lines
22 KiB
Go
package app
|
||
|
||
import (
|
||
"archive/zip"
|
||
"bytes"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"net/url"
|
||
"strings"
|
||
"time"
|
||
|
||
"yingce/backend/internal/model"
|
||
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
const (
|
||
diagnosticSchemaVersion = 1
|
||
diagnosticRedactionVersion = 1
|
||
diagnosticMaxWindow = 24 * time.Hour
|
||
diagnosticMaxClientEvents = 500
|
||
diagnosticMaxBundleBytes = 10 << 20
|
||
diagnosticMaxDescription = 1000
|
||
diagnosticMaxEventText = 4000
|
||
)
|
||
|
||
type DiagnosticClientEvent struct {
|
||
ID string `json:"id"`
|
||
Timestamp string `json:"timestamp"`
|
||
Level string `json:"level"`
|
||
Category string `json:"category"`
|
||
Code string `json:"code,omitempty"`
|
||
Message string `json:"message"`
|
||
Route string `json:"route,omitempty"`
|
||
DurationMs int64 `json:"durationMs,omitempty"`
|
||
HTTPStatus int `json:"httpStatus,omitempty"`
|
||
RequestID string `json:"requestId,omitempty"`
|
||
TraceID string `json:"traceId,omitempty"`
|
||
TaskID string `json:"taskId,omitempty"`
|
||
ProjectID string `json:"projectId,omitempty"`
|
||
CanvasID string `json:"canvasId,omitempty"`
|
||
Stack string `json:"stack,omitempty"`
|
||
}
|
||
|
||
type DiagnosticRuntime struct {
|
||
AppVersion string `json:"appVersion,omitempty"`
|
||
BuildCommit string `json:"buildCommit,omitempty"`
|
||
Browser string `json:"browser,omitempty"`
|
||
OS string `json:"os,omitempty"`
|
||
Timezone string `json:"timezone,omitempty"`
|
||
}
|
||
|
||
type DiagnosticExportRequest struct {
|
||
From string `json:"from"`
|
||
To string `json:"to"`
|
||
TaskID string `json:"taskId,omitempty"`
|
||
ProjectID string `json:"projectId,omitempty"`
|
||
Description string `json:"description,omitempty"`
|
||
Runtime DiagnosticRuntime `json:"runtime"`
|
||
ClientEvents []DiagnosticClientEvent `json:"clientEvents"`
|
||
}
|
||
|
||
type DiagnosticPreview struct {
|
||
ClientEventLimit int `json:"clientEventLimit"`
|
||
TaskCount int `json:"taskCount"`
|
||
TaskLogCount int `json:"taskLogCount"`
|
||
APICallCount int `json:"apiCallCount"`
|
||
EstimatedBytes int64 `json:"estimatedBytes"`
|
||
WillTruncate bool `json:"willTruncate"`
|
||
}
|
||
|
||
type DiagnosticBundle struct {
|
||
BundleID string
|
||
FileName string
|
||
Data []byte
|
||
}
|
||
|
||
type diagnosticWindow struct {
|
||
From time.Time
|
||
To time.Time
|
||
}
|
||
|
||
type diagnosticCollection struct {
|
||
Window diagnosticWindow
|
||
Description string
|
||
TaskID string
|
||
ProjectID string
|
||
Runtime diagnosticRuntimeRecord
|
||
ClientEvents []diagnosticClientEventRecord
|
||
Tasks []diagnosticTaskRecord
|
||
TaskLogs []diagnosticTaskLogRecord
|
||
APICalls []diagnosticAPICallRecord
|
||
Truncated bool
|
||
}
|
||
|
||
type diagnosticRuntimeRecord struct {
|
||
AppVersion string `json:"appVersion,omitempty"`
|
||
BuildCommit string `json:"buildCommit,omitempty"`
|
||
Browser string `json:"browser,omitempty"`
|
||
OS string `json:"os,omitempty"`
|
||
Timezone string `json:"timezone,omitempty"`
|
||
}
|
||
|
||
type diagnosticClientEventRecord struct {
|
||
ID string `json:"id,omitempty"`
|
||
Timestamp string `json:"timestamp,omitempty"`
|
||
Level string `json:"level,omitempty"`
|
||
Category string `json:"category,omitempty"`
|
||
Code string `json:"code,omitempty"`
|
||
Message string `json:"message,omitempty"`
|
||
Route string `json:"route,omitempty"`
|
||
DurationMs int64 `json:"durationMs,omitempty"`
|
||
HTTPStatus int `json:"httpStatus,omitempty"`
|
||
RequestID string `json:"requestId,omitempty"`
|
||
TraceID string `json:"traceId,omitempty"`
|
||
TaskID string `json:"taskId,omitempty"`
|
||
ProjectID string `json:"projectId,omitempty"`
|
||
CanvasID string `json:"canvasId,omitempty"`
|
||
Stack string `json:"stack,omitempty"`
|
||
}
|
||
|
||
type diagnosticTaskRecord struct {
|
||
ID string `json:"id"`
|
||
TraceID string `json:"traceId,omitempty"`
|
||
RequestID string `json:"requestId,omitempty"`
|
||
ProjectID string `json:"projectId,omitempty"`
|
||
Type string `json:"type,omitempty"`
|
||
Status string `json:"status,omitempty"`
|
||
Stage string `json:"stage,omitempty"`
|
||
Progress int `json:"progress,omitempty"`
|
||
Operation string `json:"operation,omitempty"`
|
||
Provider string `json:"provider,omitempty"`
|
||
Model string `json:"model,omitempty"`
|
||
LogicalModelID string `json:"logicalModelId,omitempty"`
|
||
ProviderRequestID string `json:"providerRequestId,omitempty"`
|
||
Error string `json:"error,omitempty"`
|
||
Attempts int `json:"attempts,omitempty"`
|
||
StartedAt *time.Time `json:"startedAt,omitempty"`
|
||
CompletedAt *time.Time `json:"completedAt,omitempty"`
|
||
CreatedAt time.Time `json:"createdAt"`
|
||
UpdatedAt time.Time `json:"updatedAt"`
|
||
}
|
||
|
||
type diagnosticTaskLogRecord struct {
|
||
ID string `json:"id"`
|
||
TaskID string `json:"taskId,omitempty"`
|
||
TraceID string `json:"traceId,omitempty"`
|
||
RequestID string `json:"requestId,omitempty"`
|
||
Level string `json:"level,omitempty"`
|
||
Message string `json:"message,omitempty"`
|
||
Payload string `json:"payload,omitempty"`
|
||
CreatedAt time.Time `json:"createdAt"`
|
||
}
|
||
|
||
type diagnosticAPICallRecord struct {
|
||
ID string `json:"id"`
|
||
TraceID string `json:"traceId,omitempty"`
|
||
RequestID string `json:"requestId,omitempty"`
|
||
ChannelID string `json:"channelId,omitempty"`
|
||
TaskID string `json:"taskId,omitempty"`
|
||
Source string `json:"source,omitempty"`
|
||
Capability string `json:"capability,omitempty"`
|
||
Operation string `json:"operation,omitempty"`
|
||
RequestKind string `json:"requestKind,omitempty"`
|
||
APIFormat string `json:"apiFormat,omitempty"`
|
||
Method string `json:"method,omitempty"`
|
||
Path string `json:"path,omitempty"`
|
||
Model string `json:"model,omitempty"`
|
||
Status string `json:"status,omitempty"`
|
||
StatusCode int `json:"statusCode,omitempty"`
|
||
DurationMs int64 `json:"durationMs,omitempty"`
|
||
PollCount int `json:"pollCount,omitempty"`
|
||
ProviderStatus string `json:"providerStatus,omitempty"`
|
||
ProviderRequestID string `json:"providerRequestId,omitempty"`
|
||
ErrorCode string `json:"errorCode,omitempty"`
|
||
Error string `json:"error,omitempty"`
|
||
StartedAt time.Time `json:"startedAt"`
|
||
CreatedAt time.Time `json:"createdAt"`
|
||
}
|
||
|
||
type diagnosticManifest struct {
|
||
SchemaVersion int `json:"schemaVersion"`
|
||
BundleID string `json:"bundleId"`
|
||
GeneratedAt time.Time `json:"generatedAt"`
|
||
AppVersion string `json:"appVersion,omitempty"`
|
||
BuildCommit string `json:"buildCommit,omitempty"`
|
||
TimeRange diagnosticTimeRange `json:"timeRange"`
|
||
TaskID string `json:"taskId,omitempty"`
|
||
ProjectID string `json:"projectId,omitempty"`
|
||
Description string `json:"description,omitempty"`
|
||
RedactionVersion int `json:"redactionVersion"`
|
||
Truncated bool `json:"truncated,omitempty"`
|
||
Counts diagnosticCounts `json:"counts"`
|
||
}
|
||
|
||
type diagnosticTimeRange struct {
|
||
From time.Time `json:"from"`
|
||
To time.Time `json:"to"`
|
||
}
|
||
|
||
type diagnosticCounts struct {
|
||
ClientEvents int `json:"clientEvents"`
|
||
Tasks int `json:"tasks"`
|
||
TaskLogs int `json:"taskLogs"`
|
||
APICalls int `json:"upstreamCalls"`
|
||
}
|
||
|
||
func (s *Service) PreviewDiagnosticBundle(userID string, req DiagnosticExportRequest) (*DiagnosticPreview, error) {
|
||
collection, err := s.collectDiagnosticData(userID, req)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &DiagnosticPreview{
|
||
ClientEventLimit: diagnosticMaxClientEvents,
|
||
TaskCount: len(collection.Tasks), TaskLogCount: len(collection.TaskLogs), APICallCount: len(collection.APICalls),
|
||
EstimatedBytes: int64(2048 + len(collection.ClientEvents)*420 + len(collection.Tasks)*620 + len(collection.TaskLogs)*700 + len(collection.APICalls)*520),
|
||
WillTruncate: collection.Truncated,
|
||
}, nil
|
||
}
|
||
|
||
func (s *Service) ExportDiagnosticBundle(userID string, req DiagnosticExportRequest) (*DiagnosticBundle, error) {
|
||
collection, err := s.collectDiagnosticData(userID, req)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
bundleID := "DIAG_" + strings.ToUpper(newID()[:8])
|
||
manifest := diagnosticManifest{
|
||
SchemaVersion: diagnosticSchemaVersion, BundleID: bundleID, GeneratedAt: time.Now().UTC(),
|
||
AppVersion: collection.Runtime.AppVersion, BuildCommit: collection.Runtime.BuildCommit,
|
||
TimeRange: diagnosticTimeRange{From: collection.Window.From, To: collection.Window.To},
|
||
TaskID: collection.TaskID, ProjectID: collection.ProjectID, Description: collection.Description,
|
||
RedactionVersion: diagnosticRedactionVersion, Truncated: collection.Truncated,
|
||
Counts: diagnosticCounts{ClientEvents: len(collection.ClientEvents), Tasks: len(collection.Tasks), TaskLogs: len(collection.TaskLogs), APICalls: len(collection.APICalls)},
|
||
}
|
||
brandName, brandSlug := s.appearanceIdentity()
|
||
data, err := buildDiagnosticZIP(brandName, bundleID, manifest, collection)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if len(data) > diagnosticMaxBundleBytes {
|
||
return nil, BadAuthRequest("诊断包超过 10 MB，请缩短时间范围后重试")
|
||
}
|
||
fileName := fmt.Sprintf("%s-diagnostics-%s-%s.zip", brandSlug, time.Now().UTC().Format("20060102-150405"), bundleID)
|
||
return &DiagnosticBundle{BundleID: bundleID, FileName: fileName, Data: data}, nil
|
||
}
|
||
|
||
func (s *Service) collectDiagnosticData(userID string, req DiagnosticExportRequest) (*diagnosticCollection, error) {
|
||
window, err := normalizeDiagnosticWindow(req.From, req.To)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
taskID := strings.TrimSpace(req.TaskID)
|
||
projectID := strings.TrimSpace(req.ProjectID)
|
||
if len(taskID) > 96 || len(projectID) > 96 {
|
||
return nil, BadAuthRequest("诊断上下文无效")
|
||
}
|
||
if taskID != "" {
|
||
task, taskErr := s.repo.TaskForUser(userID, taskID)
|
||
if errors.Is(taskErr, gorm.ErrRecordNotFound) {
|
||
return nil, BadAuthRequest("任务不存在或无权访问")
|
||
}
|
||
if taskErr != nil {
|
||
return nil, taskErr
|
||
}
|
||
if projectID != "" && task.ProjectID != projectID {
|
||
return nil, BadAuthRequest("任务不属于当前项目")
|
||
}
|
||
if projectID == "" {
|
||
projectID = task.ProjectID
|
||
}
|
||
}
|
||
tasks, err := s.repo.DiagnosticTasks(userID, window.From, window.To, taskID, projectID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
taskLogs, err := s.repo.DiagnosticTaskLogs(userID, window.From, window.To, taskID, projectID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
apiCalls, err := s.repo.DiagnosticAPICallLogs(userID, window.From, window.To, taskID, projectID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
clientEvents := req.ClientEvents
|
||
truncated := false
|
||
if len(clientEvents) > diagnosticMaxClientEvents {
|
||
clientEvents = clientEvents[len(clientEvents)-diagnosticMaxClientEvents:]
|
||
truncated = true
|
||
}
|
||
collection := &diagnosticCollection{
|
||
Window: window, Description: redactDiagnosticText(req.Description, diagnosticMaxDescription), TaskID: taskID, ProjectID: projectID, Truncated: truncated,
|
||
Runtime: diagnosticRuntimeRecord{
|
||
AppVersion: redactDiagnosticText(req.Runtime.AppVersion, 120), BuildCommit: redactDiagnosticText(req.Runtime.BuildCommit, 120),
|
||
Browser: redactDiagnosticText(req.Runtime.Browser, 240), OS: redactDiagnosticText(req.Runtime.OS, 120), Timezone: redactDiagnosticText(req.Runtime.Timezone, 80),
|
||
},
|
||
}
|
||
for _, event := range clientEvents {
|
||
collection.ClientEvents = append(collection.ClientEvents, sanitizeDiagnosticClientEvent(event))
|
||
}
|
||
for _, task := range tasks {
|
||
collection.Tasks = append(collection.Tasks, sanitizeDiagnosticTask(task))
|
||
}
|
||
for _, taskLog := range taskLogs {
|
||
collection.TaskLogs = append(collection.TaskLogs, sanitizeDiagnosticTaskLog(taskLog))
|
||
}
|
||
for _, apiCall := range apiCalls {
|
||
collection.APICalls = append(collection.APICalls, sanitizeDiagnosticAPICall(apiCall))
|
||
}
|
||
return collection, nil
|
||
}
|
||
|
||
func normalizeDiagnosticWindow(fromRaw string, toRaw string) (diagnosticWindow, error) {
|
||
now := time.Now().UTC()
|
||
from, to := now.Add(-30*time.Minute), now
|
||
var err error
|
||
if strings.TrimSpace(fromRaw) != "" {
|
||
from, err = time.Parse(time.RFC3339Nano, strings.TrimSpace(fromRaw))
|
||
if err != nil {
|
||
return diagnosticWindow{}, BadAuthRequest("诊断开始时间格式无效")
|
||
}
|
||
}
|
||
if strings.TrimSpace(toRaw) != "" {
|
||
to, err = time.Parse(time.RFC3339Nano, strings.TrimSpace(toRaw))
|
||
if err != nil {
|
||
return diagnosticWindow{}, BadAuthRequest("诊断结束时间格式无效")
|
||
}
|
||
}
|
||
from, to = from.UTC(), to.UTC()
|
||
if to.After(now) {
|
||
to = now
|
||
}
|
||
if !to.After(from) {
|
||
return diagnosticWindow{}, BadAuthRequest("诊断时间范围无效")
|
||
}
|
||
if to.Sub(from) > diagnosticMaxWindow {
|
||
return diagnosticWindow{}, BadAuthRequest("诊断时间范围不能超过 24 小时")
|
||
}
|
||
return diagnosticWindow{From: from, To: to}, nil
|
||
}
|
||
|
||
func sanitizeDiagnosticClientEvent(event DiagnosticClientEvent) diagnosticClientEventRecord {
|
||
return diagnosticClientEventRecord{
|
||
ID: sanitizeDiagnosticIdentifier(event.ID), Timestamp: redactDiagnosticText(event.Timestamp, 80), Level: redactDiagnosticText(event.Level, 24), Category: redactDiagnosticText(event.Category, 32),
|
||
Code: redactDiagnosticText(event.Code, 120), Message: redactDiagnosticText(event.Message, diagnosticMaxEventText), Route: sanitizeDiagnosticPath(event.Route),
|
||
DurationMs: boundedDiagnosticInt64(event.DurationMs, 0, 86_400_000), HTTPStatus: boundedDiagnosticInt(event.HTTPStatus, 0, 599),
|
||
RequestID: sanitizeDiagnosticIdentifier(event.RequestID), TraceID: sanitizeDiagnosticIdentifier(event.TraceID), TaskID: sanitizeDiagnosticIdentifier(event.TaskID), ProjectID: sanitizeDiagnosticIdentifier(event.ProjectID), CanvasID: sanitizeDiagnosticIdentifier(event.CanvasID),
|
||
Stack: redactDiagnosticText(event.Stack, diagnosticMaxEventText),
|
||
}
|
||
}
|
||
|
||
func sanitizeDiagnosticTask(task model.Task) diagnosticTaskRecord {
|
||
return diagnosticTaskRecord{
|
||
ID: task.ID, TraceID: sanitizeDiagnosticIdentifier(task.TraceID), RequestID: sanitizeDiagnosticIdentifier(task.RequestID), ProjectID: sanitizeDiagnosticIdentifier(task.ProjectID),
|
||
Type: redactDiagnosticText(task.Type, 80), Status: redactDiagnosticText(string(task.Status), 32), Stage: redactDiagnosticText(task.Stage, 160), Progress: boundedDiagnosticInt(task.Progress, 0, 100),
|
||
Operation: redactDiagnosticText(task.Operation, 120), Provider: redactDiagnosticText(task.Provider, 120), Model: redactDiagnosticText(task.Model, 160), LogicalModelID: sanitizeDiagnosticIdentifier(task.LogicalModelID),
|
||
ProviderRequestID: sanitizeDiagnosticIdentifier(task.ProviderRequestID), Error: redactDiagnosticText(task.Error, diagnosticMaxEventText), Attempts: boundedDiagnosticInt(task.Attempts, 0, 100),
|
||
StartedAt: task.StartedAt, CompletedAt: task.CompletedAt, CreatedAt: task.CreatedAt, UpdatedAt: task.UpdatedAt,
|
||
}
|
||
}
|
||
|
||
func sanitizeDiagnosticTaskLog(taskLog model.TaskLog) diagnosticTaskLogRecord {
|
||
return diagnosticTaskLogRecord{ID: taskLog.ID, TaskID: sanitizeDiagnosticIdentifier(taskLog.TaskID), TraceID: sanitizeDiagnosticIdentifier(taskLog.TraceID), RequestID: sanitizeDiagnosticIdentifier(taskLog.RequestID), Level: redactDiagnosticText(taskLog.Level, 24), Message: redactDiagnosticText(taskLog.Message, diagnosticMaxEventText), Payload: redactDiagnosticText(taskLog.Payload, diagnosticMaxEventText), CreatedAt: taskLog.CreatedAt}
|
||
}
|
||
|
||
func sanitizeDiagnosticAPICall(log model.ApiCallLog) diagnosticAPICallRecord {
|
||
return diagnosticAPICallRecord{
|
||
ID: log.ID, TraceID: sanitizeDiagnosticIdentifier(log.TraceID), RequestID: sanitizeDiagnosticIdentifier(log.RequestID), ChannelID: sanitizeDiagnosticIdentifier(log.ChannelID), TaskID: sanitizeDiagnosticIdentifier(log.TaskID),
|
||
Source: redactDiagnosticText(log.Source, 80), Capability: redactDiagnosticText(log.Capability, 48), Operation: redactDiagnosticText(log.Operation, 120), RequestKind: redactDiagnosticText(log.RequestKind, 48), APIFormat: redactDiagnosticText(log.APIFormat, 48),
|
||
Method: redactDiagnosticText(log.Method, 16), Path: sanitizeDiagnosticPath(log.Path), Model: redactDiagnosticText(log.Model, 160), Status: redactDiagnosticText(string(log.Status), 32), StatusCode: boundedDiagnosticInt(log.StatusCode, 0, 599),
|
||
DurationMs: boundedDiagnosticInt64(log.DurationMs, 0, 86_400_000), PollCount: boundedDiagnosticInt(log.PollCount, 0, 10000), ProviderStatus: redactDiagnosticText(log.ProviderStatus, 80),
|
||
ProviderRequestID: sanitizeDiagnosticIdentifier(log.ProviderRequestID), ErrorCode: redactDiagnosticText(log.ErrorCode, 120), Error: redactDiagnosticText(log.Error, diagnosticMaxEventText), StartedAt: log.StartedAt, CreatedAt: log.CreatedAt,
|
||
}
|
||
}
|
||
|
||
func buildDiagnosticZIP(brandName string, bundleID string, manifest diagnosticManifest, collection *diagnosticCollection) ([]byte, error) {
|
||
var buffer bytes.Buffer
|
||
archive := zip.NewWriter(&buffer)
|
||
manifestData, err := json.MarshalIndent(manifest, "", " ")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeDiagnosticZipFile(archive, "manifest.json", append(manifestData, byte(10))); err != nil {
|
||
return nil, err
|
||
}
|
||
newline := string(rune(10))
|
||
readme := fmt.Sprintf("%s 用户诊断包%s%s诊断编号：%s%s时间范围：%s 至 %s%s%s该文件由用户主动导出，仅包含有限时间范围内的脱敏诊断摘要。%s", brandName, newline, newline, bundleID, newline, collection.Window.From.Format(time.RFC3339), collection.Window.To.Format(time.RFC3339), newline, newline, newline)
|
||
if err := writeDiagnosticZipFile(archive, "README.txt", []byte(readme)); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeDiagnosticJSONL(archive, "client/events.jsonl", collection.ClientEvents); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeDiagnosticJSONL(archive, "backend/tasks.jsonl", collection.Tasks); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeDiagnosticJSONL(archive, "backend/task-logs.jsonl", collection.TaskLogs); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeDiagnosticJSONL(archive, "backend/upstream-calls.jsonl", collection.APICalls); err != nil {
|
||
return nil, err
|
||
}
|
||
runtimeData, err := json.MarshalIndent(collection.Runtime, "", " ")
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := writeDiagnosticZipFile(archive, "context/runtime.json", append(runtimeData, byte(10))); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := archive.Close(); err != nil {
|
||
return nil, err
|
||
}
|
||
return buffer.Bytes(), nil
|
||
}
|
||
|
||
func writeDiagnosticJSONL[T any](archive *zip.Writer, name string, records []T) error {
|
||
var data bytes.Buffer
|
||
for _, record := range records {
|
||
encoded, err := json.Marshal(record)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
data.Write(encoded)
|
||
data.WriteByte(10)
|
||
}
|
||
return writeDiagnosticZipFile(archive, name, data.Bytes())
|
||
}
|
||
|
||
func writeDiagnosticZipFile(archive *zip.Writer, name string, data []byte) error {
|
||
file, err := archive.Create(name)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
_, err = file.Write(data)
|
||
return err
|
||
}
|
||
|
||
func sanitizeDiagnosticIdentifier(value string) string {
|
||
value = strings.TrimSpace(value)
|
||
if value == "" || len(value) > 96 {
|
||
return ""
|
||
}
|
||
for _, char := range value {
|
||
if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9') || strings.ContainsRune("._:-", char) {
|
||
continue
|
||
}
|
||
return ""
|
||
}
|
||
return value
|
||
}
|
||
|
||
func sanitizeDiagnosticPath(value string) string {
|
||
value = strings.TrimSpace(value)
|
||
if value == "" {
|
||
return ""
|
||
}
|
||
if index := strings.IndexAny(value, "?#"); index >= 0 {
|
||
value = value[:index]
|
||
}
|
||
return redactDiagnosticText(value, 300)
|
||
}
|
||
|
||
func redactDiagnosticText(value string, limit int) string {
|
||
value = strings.TrimSpace(value)
|
||
if value == "" {
|
||
return ""
|
||
}
|
||
for _, marker := range []string{"authorization", "cookie", "set-cookie", "x-goog-api-key", "x-canvas-upstream-headers", "api_key", "api-key", "apikey", "access_key", "access-key", "secret_key", "secret-key", "password", "token="} {
|
||
value = redactDiagnosticMarker(value, marker)
|
||
}
|
||
return truncateRunes(redactDiagnosticURLs(value), limit)
|
||
}
|
||
|
||
func redactDiagnosticMarker(value string, marker string) string {
|
||
searchFrom := 0
|
||
for searchFrom < len(value) {
|
||
lower := strings.ToLower(value)
|
||
index := strings.Index(lower[searchFrom:], strings.ToLower(marker))
|
||
if index < 0 {
|
||
break
|
||
}
|
||
index += searchFrom
|
||
end := index + len(marker)
|
||
for end < len(value) && isDiagnosticSeparator(value[end]) {
|
||
end++
|
||
}
|
||
valueEnd := end
|
||
for valueEnd < len(value) && !isDiagnosticValueDelimiter(value[valueEnd]) {
|
||
valueEnd++
|
||
}
|
||
if valueEnd == end {
|
||
searchFrom = end
|
||
continue
|
||
}
|
||
value = value[:end] + "[REDACTED]" + value[valueEnd:]
|
||
searchFrom = end + len("[REDACTED]")
|
||
}
|
||
return value
|
||
}
|
||
|
||
func redactDiagnosticURLs(value string) string {
|
||
searchFrom := 0
|
||
for searchFrom < len(value) {
|
||
startHTTP := strings.Index(value[searchFrom:], "http://")
|
||
startHTTPS := strings.Index(value[searchFrom:], "https://")
|
||
start := -1
|
||
if startHTTP >= 0 {
|
||
start = startHTTP
|
||
}
|
||
if startHTTPS >= 0 && (start < 0 || startHTTPS < start) {
|
||
start = startHTTPS
|
||
}
|
||
if start < 0 {
|
||
break
|
||
}
|
||
start += searchFrom
|
||
end := start
|
||
for end < len(value) && !isDiagnosticURLDelimiter(value[end]) {
|
||
end++
|
||
}
|
||
raw := value[start:end]
|
||
parsed, err := url.Parse(raw)
|
||
if err != nil {
|
||
searchFrom = end
|
||
continue
|
||
}
|
||
parsed.RawQuery = ""
|
||
parsed.Fragment = ""
|
||
safe := parsed.String()
|
||
value = value[:start] + safe + value[end:]
|
||
searchFrom = start + len(safe)
|
||
}
|
||
return value
|
||
}
|
||
|
||
func isDiagnosticSeparator(value byte) bool {
|
||
return value == ' ' || value == 9 || value == ':' || value == '='
|
||
}
|
||
|
||
func isDiagnosticValueDelimiter(value byte) bool {
|
||
switch value {
|
||
case ' ', 9, 13, 10, ',', ';', '"', 39, '<', '>', '}', ']':
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func isDiagnosticURLDelimiter(value byte) bool {
|
||
return value == ' ' || value == 9 || value == 13 || value == 10 || value == '"' || value == 39 || value == '<' || value == '>'
|
||
}
|
||
|
||
func boundedDiagnosticInt(value int, min int, max int) int {
|
||
if value < min {
|
||
return min
|
||
}
|
||
if value > max {
|
||
return max
|
||
}
|
||
return value
|
||
}
|
||
|
||
func boundedDiagnosticInt64(value int64, min int64, max int64) int64 {
|
||
if value < min {
|
||
return min
|
||
}
|
||
if value > max {
|
||
return max
|
||
}
|
||
return value
|
||
}
|