astra/owpengram-server
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

translated all logs to english

Browse source
This commit is contained in:
onysd 2026-07-25 07:31:27 +03:00
parent e2e6f54ce6
commit 0e5da4c8aa
13 changed files with 277 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

4
internal/adminapi/server.go
View file

@ -95,9 +95,9 @@ func Start(ctx context.Context, cfg Config, svc Service, log *zap.Logger) (*http
ReadHeaderTimeout: 5 * time.Second,
}
go func() {
log.Info("Admin API 已启用", zap.String("addr", cfg.Addr))
log.Info("Admin API enabled", zap.String("addr", cfg.Addr))
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Warn("Admin API 退出", zap.Error(err))
log.Warn("Admin API exited", zap.Error(err))
}
}()
go func() {

4
internal/app/files/seed.go
View file

@ -49,7 +49,7 @@ func (s *Service) SeedMedia(ctx context.Context, root string, maxRegularSets int
// 不存在 → 静默不导入贴纸/reaction」会被埋没（DB 已有旧数据时尤其隐蔽，表现为客户端反复
// 拉取未 seed 的集）。配置 TELESRV_STICKER_SEED_DIR 指向真实导出目录即可。
if s.log != nil {
s.log.Warn("sticker/reaction seed 目录不存在，跳过媒体种子导入（配置 TELESRV_STICKER_SEED_DIR）",
s.log.Warn("sticker/reaction seed directory does not exist, skipping media seed import (set TELESRV_STICKER_SEED_DIR)",
zap.String("dir", root), zap.Error(err))
}
stats.Skipped = true
@ -121,7 +121,7 @@ func (s *Service) logSeedPhase(phase string, started time.Time, before, after Se
if s.log == nil {
return
}
s.log.Info("媒体种子阶段完成",
s.log.Info("media seed phase complete",
zap.String("phase", phase),
zap.Duration("elapsed", time.Since(started)),
zap.Int("reactions", after.Reactions-before.Reactions),

4
internal/app/files/upload_gc.go
View file

@ -58,10 +58,10 @@ func (w *UploadPartGCWorker) runOnce(ctx context.Context) {
}
deleted, err := w.files.DeleteExpiredUploadParts(ctx, time.Now().Add(-w.ttl), w.batch)
if err != nil {
w.logger.Warn("清理过期 upload_parts 失败", zap.Error(err))
w.logger.Warn("expired upload_parts cleanup failed", zap.Error(err))
return
}
if deleted > 0 {
w.logger.Info("清理过期 upload_parts 完成", zap.Int64("deleted", deleted))
w.logger.Info("expired upload_parts cleanup complete", zap.Int64("deleted", deleted))
}
}

44
internal/app/maintenance/retention.go
View file

@ -241,15 +241,16 @@ func (w *RetentionWorker) runOutboxPoisonOnce(ctx context.Context) {
}
outboxDeleted, err := w.outbox.DeleteFailed(ctx, w.outboxPoisonRetention, w.batch)
if err != nil {
w.logger.Error("清理 terminal failed dispatch_outbox 失败",
w.logger.Error("cleaning up terminal-failed dispatch_outbox rows failed",
zap.String("signal", "dispatch_outbox_poison_cleanup_failed"),
zap.Duration("quarantine", w.outboxPoisonRetention),
zap.Error(err),
)
} else if outboxDeleted > 0 {
// Error 级结构化信号刻意保留：发生 terminal failed 代表确定性编码、事件缺失
// 或其它不可自动重试故障。任务删除只解冻在线 lane，不会删除 durable event。
w.logger.Error("terminal failed dispatch_outbox 已结束隔离并释放用户 lane",
// The Error level is intentionally kept: a terminal failure means deterministic
// encoding, a missing event, or some other non-retryable fault. Deleting the row
// only unfreezes the online lane — it does not delete the durable event.
w.logger.Error("terminal-failed dispatch_outbox rows released from quarantine and unfroze their user lane",
zap.String("signal", "dispatch_outbox_poison_released"),
zap.Int("deleted", outboxDeleted),
zap.Duration("quarantine", w.outboxPoisonRetention),
@ -261,26 +262,26 @@ func (w *RetentionWorker) runRetentionOnce(ctx context.Context) {
if w.authKeySessionLayers != nil {
deleted, err := w.authKeySessionLayers.DeleteExpiredSessionLayers(ctx, w.batch)
if err != nil {
w.logger.Warn("回收过期 auth-key session Layer 证据失败", zap.Error(err))
w.logger.Warn("expired auth-key session layer evidence cleanup failed", zap.Error(err))
} else if deleted > 0 {
w.logger.Info("回收过期 auth-key session Layer 证据完成", zap.Int("deleted", deleted))
w.logger.Info("expired auth-key session layer evidence cleanup complete", zap.Int("deleted", deleted))
}
}
if w.loginCodeDeliveries != nil {
deleted, err := w.loginCodeDeliveries.DeleteExpiredLoginCodeDeliveries(ctx, time.Now(), w.batch)
if err != nil {
w.logger.Warn("回收过期 login-code delivery 回执失败", zap.Error(err))
w.logger.Warn("expired login-code delivery receipt cleanup failed", zap.Error(err))
} else if deleted > 0 {
w.logger.Info("回收过期 login-code delivery 回执完成", zap.Int("deleted", deleted))
w.logger.Info("expired login-code delivery receipt cleanup complete", zap.Int("deleted", deleted))
}
}
if w.tempKeys != nil {
expiredBefore := time.Now().Add(-tempAuthKeyExpiryGrace).Unix()
tempDeleted, err := w.tempKeys.DeleteExpired(ctx, expiredBefore, w.batch)
if err != nil {
w.logger.Warn("回收过期 temp auth key 绑定失败", zap.Error(err))
w.logger.Warn("expired temp auth key binding cleanup failed", zap.Error(err))
} else if tempDeleted > 0 {
w.logger.Info("回收过期 temp auth key 绑定完成", zap.Int("deleted", tempDeleted))
w.logger.Info("expired temp auth key binding cleanup complete", zap.Int("deleted", tempDeleted))
}
}
if w.orphanAuthKeys != nil && w.orphanRetention > 0 {
@ -295,39 +296,40 @@ func (w *RetentionWorker) runRetentionOnce(ctx context.Context) {
} else {
orphanDeleted, err := w.orphanAuthKeys.DeleteOrphaned(ctx, w.orphanRetention, w.batch, protected)
if err != nil {
w.logger.Warn("回收未授权 orphan auth key 失败", zap.Error(err))
w.logger.Warn("unauthorized orphan auth key cleanup failed", zap.Error(err))
} else if orphanDeleted > 0 {
w.logger.Info("回收未授权 orphan auth key 完成", zap.Int("deleted", orphanDeleted))
w.logger.Info("unauthorized orphan auth key cleanup complete", zap.Int("deleted", orphanDeleted))
}
}
}
if w.botAPIUpdates != nil {
botAPIDeleted, err := w.botAPIUpdates.DeleteDeliveredOrExpired(ctx, botAPIConfirmedGrace, w.botAPIRetention, w.batch)
if err != nil {
w.logger.Warn("回收 bot_api_updates 队列失败", zap.Error(err))
w.logger.Warn("bot_api_updates queue cleanup failed", zap.Error(err))
} else if botAPIDeleted > 0 {
w.logger.Info("回收 bot_api_updates 队列完成", zap.Int("deleted", botAPIDeleted))
w.logger.Info("bot_api_updates queue cleanup complete", zap.Int("deleted", botAPIDeleted))
}
}
if w.userUpdates != nil {
userDeleted, err := w.userUpdates.DeleteConfirmedPrefix(ctx, w.retention, w.batch)
if err != nil {
w.logger.Warn("回收已共同确认的 user_update_events 前缀失败", zap.Error(err))
w.logger.Warn("jointly-confirmed user_update_events prefix cleanup failed", zap.Error(err))
} else if userDeleted > 0 {
w.logger.Info("回收已共同确认的 user_update_events 前缀完成", zap.Int("deleted", userDeleted))
w.logger.Info("jointly-confirmed user_update_events prefix cleanup complete", zap.Int("deleted", userDeleted))
}
}
if w.channelUpdates != nil {
channelDeleted, err := w.channelUpdates.DeleteExpiredChannelUpdateEvents(ctx, w.retention, w.batch)
if err != nil {
// store 会逐频道隔离坏 gap 后继续本轮；deleted 可能非零，必须同时记录，
// 既不能把全局 pass 伪装成完全失败，也不能吞掉不变量错误。
w.logger.Warn("回收过期 channel_update_events 存在隔离频道",
// The store quarantines bad gaps per-channel and keeps going for the rest of this
// pass; deleted can be non-zero, so it must be logged alongside the error — the pass
// must not look like a total failure, nor should the invariant error get swallowed.
w.logger.Warn("expired channel_update_events cleanup hit quarantined channels",
zap.Int("deleted", channelDeleted),
zap.Error(err),
)
} else if channelDeleted > 0 {
w.logger.Info("回收过期 channel_update_events 连续前缀完成", zap.Int("deleted", channelDeleted))
w.logger.Info("expired channel_update_events contiguous-prefix cleanup complete", zap.Int("deleted", channelDeleted))
}
}
}
@ -360,7 +362,7 @@ func (w *RetentionWorker) touchActiveAuthKeys(ctx context.Context, protected [][
return true
}
if err := w.activeAuthKeyHeartbeat.TouchActiveRawAuthKeys(ctx, protected); err != nil {
w.logger.Error("刷新 active raw auth key heartbeat 失败，本轮跳过 orphan GC",
w.logger.Error("refreshing active raw auth key heartbeat failed, skipping orphan GC this round",
zap.String("signal", "auth_key_heartbeat_failed"),
zap.Int("active_keys", len(protected)),
zap.Error(err),

4
internal/botapi/server.go
View file

@ -108,9 +108,9 @@ func Start(ctx context.Context, addr string, bots BotsService, users UsersServic
return nil, err
}
go func() {
logger.Info("Bot API 网关已启用", zap.String("addr", addr))
logger.Info("Bot API gateway enabled", zap.String("addr", addr))
if err := srv.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
logger.Warn("Bot API 网关退出", zap.Error(err))
logger.Warn("Bot API gateway exited", zap.Error(err))
}
}()
if webhooks, ok := gateway.(GatewayWebhookControl); ok {

2
internal/sfu/pion.go
View file

@ -175,7 +175,7 @@ func NewPion(cfg PionConfig) (Service, error) {
zap.Int("udp_port", cfg.UDPPort),
zap.String("advertise_ip", cfg.AdvertiseIP))
if cfg.AdvertiseIP == "127.0.0.1" {
s.log.Warn("TELESRV_SFU_ADVERTISE_IP 为 127.0.0.1：真机 ICE 将无法连接（纯媒体面静默失败），多设备联调必须设为宿主机 LAN IP")
s.log.Warn("TELESRV_SFU_ADVERTISE_IP is 127.0.0.1: real devices' ICE won't be able to connect (media-only silent failure); multi-device testing requires the host's LAN IP")
}
return s, nil
}

2
internal/turnsrv/turnsrv.go
View file

@ -139,7 +139,7 @@ func New(cfg Config) (Service, error) {
zap.Int("relay_min_port", cfg.RelayMinPort),
zap.Int("relay_max_port", cfg.RelayMaxPort))
if cfg.AdvertiseIP == "127.0.0.1" {
cfg.Logger.Warn("TELESRV_TURN_ADVERTISE_IP 为 127.0.0.1：真机拿到的 relay candidate 不可达（跨网媒体面静默失败），跨设备通话必须设为客户端可达 IP")
cfg.Logger.Warn("TELESRV_TURN_ADVERTISE_IP is 127.0.0.1: real devices get an unreachable relay candidate (cross-network media silently fails); cross-device calls require a client-reachable IP")
}
return &pionTURN{cfg: cfg, server: server}, nil
}