前端Sentry团队协作与工作流集成：构建高效的问题解决体系

在现代软件开发中，有效的团队协作和工作流集成是确保产品质量和开发效率的关键因素。Sentry作为一个强大的错误监控和性能分析平台，不仅能够帮助我们发现和诊断问题，更重要的是能够与团队的工作流程深度集成，构建一个高效的问题解决体系。本文将深入探讨如何利用Sentry实现团队协作优化和工作流集成。

1. Sentry团队协作基础架构

1.1 团队组织结构设计

// 团队协作管理器
class SentryTeamCollaborationManager {
  constructor(options = {}) {
    this.options = {
      organizationSlug: options.organizationSlug,
      authToken: options.authToken,
      baseUrl: 'https://sentry.io/api/0',
      ...options
    };
    
    this.teams = new Map();
    this.projects = new Map();
    this.members = new Map();
    this.workflows = new Map();
    
    this.init();
  }
  
  // 初始化团队协作系统
  async init() {
    try {
      await this.loadTeamStructure();
      await this.setupWorkflows();
      await this.initializeNotifications();
      
      console.log('团队协作系统初始化完成');
    } catch (error) {
      console.error('团队协作系统初始化失败:', error);
    }
  }
  
  // 加载团队结构
  async loadTeamStructure() {
    const teams = await this.fetchTeams();
    const projects = await this.fetchProjects();
    const members = await this.fetchMembers();
    
    // 构建团队映射
    teams.forEach(team => {
      this.teams.set(team.slug, {
        ...team,
        projects: projects.filter(p => p.teams.includes(team.slug)),
        members: members.filter(m => m.teams.includes(team.slug))
      });
    });
    
    // 构建项目映射
    projects.forEach(project => {
      this.projects.set(project.slug, {
        ...project,
        team: teams.find(t => project.teams.includes(t.slug)),
        assignedMembers: this.getProjectMembers(project.slug)
      });
    });
    
    // 构建成员映射
    members.forEach(member => {
      this.members.set(member.email, {
        ...member,
        teams: teams.filter(t => member.teams.includes(t.slug)),
        projects: projects.filter(p => this.isProjectMember(p.slug, member.email))
      });
    });
  }
  
  // 获取团队列表
  async fetchTeams() {
    const response = await fetch(`${this.options.baseUrl}/organizations/${this.options.organizationSlug}/teams/`, {
      headers: {
        'Authorization': `Bearer ${this.options.authToken}`,
        'Content-Type': 'application/json'
      }
    });
    
    if (!response.ok) {
      throw new Error(`获取团队列表失败: ${response.statusText}`);
    }
    
    return await response.json();
  }
  
  // 获取项目列表
  async fetchProjects() {
    const response = await fetch(`${this.options.baseUrl}/organizations/${this.options.organizationSlug}/projects/`, {
      headers: {
        'Authorization': `Bearer ${this.options.authToken}`,
        'Content-Type': 'application/json'
      }
    });
    
    if (!response.ok) {
      throw new Error(`获取项目列表失败: ${response.statusText}`);
    }
    
    return await response.json();
  }
  
  // 获取成员列表
  async fetchMembers() {
    const response = await fetch(`${this.options.baseUrl}/organizations/${this.options.organizationSlug}/members/`, {
      headers: {
        'Authorization': `Bearer ${this.options.authToken}`,
        'Content-Type': 'application/json'
      }
    });
    
    if (!response.ok) {
      throw new Error(`获取成员列表失败: ${response.statusText}`);
    }
    
    return await response.json();
  }
  
  // 获取项目成员
  getProjectMembers(projectSlug) {
    const project = this.projects.get(projectSlug);
    if (!project) return [];
    
    return Array.from(this.members.values()).filter(member => 
      member.projects.some(p => p.slug === projectSlug)
    );
  }
  
  // 检查是否为项目成员
  isProjectMember(projectSlug, memberEmail) {
    const project = this.projects.get(projectSlug);
    const member = this.members.get(memberEmail);
    
    if (!project || !member) return false;
    
    return project.teams.some(teamSlug => 
      member.teams.some(team => team.slug === teamSlug)
    );
  }
  
  // 设置工作流
  async setupWorkflows() {
    // 问题分配工作流
    this.workflows.set('issue_assignment', new IssueAssignmentWorkflow(this));
    
    // 问题升级工作流
    this.workflows.set('issue_escalation', new IssueEscalationWorkflow(this));
    
    // 发布通知工作流
    this.workflows.set('release_notification', new ReleaseNotificationWorkflow(this));
    
    // 性能告警工作流
    this.workflows.set('performance_alert', new PerformanceAlertWorkflow(this));
    
    // 初始化所有工作流
    for (const [name, workflow] of this.workflows) {
      await workflow.initialize();
      console.log(`工作流 ${name} 初始化完成`);
    }
  }
  
  // 初始化通知系统
  async initializeNotifications() {
    this.notificationManager = new NotificationManager({
      slack: {
        webhookUrl: this.options.slackWebhookUrl,
        channels: this.options.slackChannels
      },
      email: {
        smtpConfig: this.options.emailConfig
      },
      teams: {
        webhookUrl: this.options.teamsWebhookUrl
      }
    });
    
    await this.notificationManager.initialize();
  }
  
  // 处理Sentry事件
  async handleSentryEvent(event) {
    try {
      // 确定负责团队和成员
      const assignment = await this.determineAssignment(event);
      
      // 执行相关工作流
      await this.executeWorkflows(event, assignment);
      
      // 发送通知
      await this.sendNotifications(event, assignment);
      
      console.log(`事件 ${event.id} 处理完成`);
    } catch (error) {
      console.error(`处理事件 ${event.id} 失败:`, error);
    }
  }
  
  // 确定问题分配
  async determineAssignment(event) {
    const project = this.projects.get(event.project.slug);
    if (!project) {
      throw new Error(`未找到项目: ${event.project.slug}`);
    }
    
    // 基于规则确定分配
    const assignmentRules = [
      this.assignByCodeOwnership.bind(this),
      this.assignByErrorType.bind(this),
      this.assignByTeamRotation.bind(this),
      this.assignByDefault.bind(this)
    ];
    
    for (const rule of assignmentRules) {
      const assignment = await rule(event, project);
      if (assignment) {
        return assignment;
      }
    }
    
    throw new Error('无法确定问题分配');
  }
  
  // 基于代码所有权分配
  async assignByCodeOwnership(event, project) {
    if (!event.culprit) return null;
    
    // 解析文件路径
    const filePath = this.extractFilePath(event.culprit);
    if (!filePath) return null;
    
    // 查找代码所有者
    const owner = await this.findCodeOwner(project.slug, filePath);
    if (!owner) return null;
    
    return {
      type: 'code_ownership',
      assignee: owner,
      team: this.getTeamByMember(owner),
      reason: `代码所有者: ${filePath}`
    };
  }
  
  // 基于错误类型分配
  async assignByErrorType(event, project) {
    const errorType = this.categorizeError(event);
    const specialist = this.getErrorTypeSpecialist(project.slug, errorType);
    
    if (!specialist) return null;
    
    return {
      type: 'error_type',
      assignee: specialist,
      team: this.getTeamByMember(specialist),
      reason: `错误类型专家: ${errorType}`
    };
  }
  
  // 基于团队轮换分配
  async assignByTeamRotation(event, project) {
    const team = project.team;
    if (!team) return null;
    
    const onCallMember = await this.getOnCallMember(team.slug);
    if (!onCallMember) return null;
    
    return {
      type: 'team_rotation',
      assignee: onCallMember,
      team: team,
      reason: '团队值班轮换'
    };
  }
  
  // 默认分配
  async assignByDefault(event, project) {
    const teamLead = await this.getTeamLead(project.team.slug);
    
    return {
      type: 'default',
      assignee: teamLead,
      team: project.team,
      reason: '默认分配给团队负责人'
    };
  }
  
  // 执行工作流
  async executeWorkflows(event, assignment) {
    const relevantWorkflows = this.getRelevantWorkflows(event, assignment);
    
    for (const workflow of relevantWorkflows) {
      try {
        await workflow.execute(event, assignment);
      } catch (error) {
        console.error(`工作流 ${workflow.name} 执行失败:`, error);
      }
    }
  }
  
  // 获取相关工作流
  getRelevantWorkflows(event, assignment) {
    const workflows = [];
    
    // 问题分配工作流
    workflows.push(this.workflows.get('issue_assignment'));
    
    // 根据严重程度决定是否需要升级
    if (this.shouldEscalate(event)) {
      workflows.push(this.workflows.get('issue_escalation'));
    }
    
    // 性能相关事件
    if (event.type === 'transaction') {
      workflows.push(this.workflows.get('performance_alert'));
    }
    
    return workflows;
  }
  
  // 发送通知
  async sendNotifications(event, assignment) {
    const notifications = this.buildNotifications(event, assignment);
    
    for (const notification of notifications) {
      try {
        await this.notificationManager.send(notification);
      } catch (error) {
        console.error('发送通知失败:', error);
      }
    }
  }
  
  // 构建通知内容
  buildNotifications(event, assignment) {
    const notifications = [];
    
    // 分配给负责人的通知
    notifications.push({
      type: 'assignment',
      recipient: assignment.assignee,
      channel: 'email',
      subject: `新问题分配: ${event.title}`,
      content: this.buildAssignmentNotification(event, assignment)
    });
    
    // 团队Slack通知
    if (assignment.team.slackChannel) {
      notifications.push({
        type: 'team_alert',
        recipient: assignment.team.slackChannel,
        channel: 'slack',
        content: this.buildSlackNotification(event, assignment)
      });
    }
    
    // 高优先级问题的升级通知
    if (this.isHighPriority(event)) {
      notifications.push({
        type: 'escalation',
        recipient: this.getEscalationContacts(assignment.team),
        channel: 'multiple',
        content: this.buildEscalationNotification(event, assignment)
      });
    }
    
    return notifications;
  }
  
  // 辅助方法
  extractFilePath(culprit) {
    // 从错误堆栈中提取文件路径
    const match = culprit.match(/([^/\\]+\.(js|ts|jsx|tsx))/);
    return match ? match[1] : null;
  }
  
  async findCodeOwner(projectSlug, filePath) {
    // 查找代码所有者（可以集成CODEOWNERS文件）
    // 这里简化实现
    return null;
  }
  
  getTeamByMember(memberEmail) {
    const member = this.members.get(memberEmail);
    return member ? member.teams[0] : null;
  }
  
  categorizeError(event) {
    // 错误分类逻辑
    if (event.exception) {
      return event.exception.values[0].type;
    }
    return 'unknown';
  }
  
  getErrorTypeSpecialist(projectSlug, errorType) {
    // 获取错误类型专家
    // 这里可以配置不同错误类型的专家
    return null;
  }
  
  async getOnCallMember(teamSlug) {
    // 获取当前值班成员
    // 可以集成PagerDuty等值班系统
    const team = this.teams.get(teamSlug);
    return team ? team.members[0]?.email : null;
  }
  
  async getTeamLead(teamSlug) {
    // 获取团队负责人
    const team = this.teams.get(teamSlug);
    return team ? team.members.find(m => m.role === 'admin')?.email : team.members[0]?.email;
  }
  
  shouldEscalate(event) {
    // 判断是否需要升级
    return event.level === 'error' && event.count > 100;
  }
  
  isHighPriority(event) {
    // 判断是否为高优先级
    return event.level === 'error' || event.count > 50;
  }
  
  getEscalationContacts(team) {
    // 获取升级联系人
    return team.members.filter(m => m.role === 'admin').map(m => m.email);
  }
  
  buildAssignmentNotification(event, assignment) {
    return `
      您有一个新的问题需要处理：
      
      问题标题: ${event.title}
      项目: ${event.project.name}
      分配原因: ${assignment.reason}
      严重程度: ${event.level}
      发生次数: ${event.count}
      
      查看详情: ${event.permalink}
    `;
  }
  
  buildSlackNotification(event, assignment) {
    return {
      text: `新问题分配给 ${assignment.assignee}`,
      attachments: [{
        color: event.level === 'error' ? 'danger' : 'warning',
        title: event.title,
        title_link: event.permalink,
        fields: [
          { title: '项目', value: event.project.name, short: true },
          { title: '负责人', value: assignment.assignee, short: true },
          { title: '严重程度', value: event.level, short: true },
          { title: '发生次数', value: event.count, short: true }
        ]
      }]
    };
  }
  
  buildEscalationNotification(event, assignment) {
    return `
      高优先级问题需要关注：
      
      问题标题: ${event.title}
      项目: ${event.project.name}
      当前负责人: ${assignment.assignee}
      严重程度: ${event.level}
      发生次数: ${event.count}
      
      这是一个高优先级问题，请及时关注处理进度。
      
      查看详情: ${event.permalink}
    `;
  }
}

1.2 问题分配工作流

// 问题分配工作流
class IssueAssignmentWorkflow {
  constructor(collaborationManager) {
    this.collaborationManager = collaborationManager;
    this.name = 'issue_assignment';
    this.rules = new Map();
  }
  
  async initialize() {
    // 加载分配规则
    await this.loadAssignmentRules();
    
    // 设置自动分配
    this.setupAutoAssignment();
  }
  
  async loadAssignmentRules() {
    // 基于文件路径的分配规则
    this.rules.set('file_path', {
      priority: 1,
      matcher: (event) => event.culprit,
      resolver: async (event) => {
        const filePath = this.extractFilePath(event.culprit);
        return await this.findOwnerByFilePath(filePath);
      }
    });
    
    // 基于错误类型的分配规则
    this.rules.set('error_type', {
      priority: 2,
      matcher: (event) => event.exception,
      resolver: async (event) => {
        const errorType = this.getErrorType(event);
        return await this.findOwnerByErrorType(errorType);
      }
    });
    
    // 基于标签的分配规则
    this.rules.set('tags', {
      priority: 3,
      matcher: (event) => event.tags,
      resolver: async (event) => {
        return await this.findOwnerByTags(event.tags);
      }
    });
    
    // 基于用户的分配规则
    this.rules.set('user', {
      priority: 4,
      matcher: (event) => event.user,
      resolver: async (event) => {
        return await this.findOwnerByUser(event.user);
      }
    });
  }
  
  setupAutoAssignment() {
    // 监听Sentry事件
    this.collaborationManager.on('issue_created', async (event) => {
      await this.execute(event);
    });
    
    this.collaborationManager.on('issue_updated', async (event) => {
      if (this.shouldReassign(event)) {
        await this.execute(event);
      }
    });
  }
  
  async execute(event, assignment = null) {
    try {
      // 如果没有提供分配信息，则自动确定
      if (!assignment) {
        assignment = await this.determineAssignment(event);
      }
      
      // 执行分配
      await this.assignIssue(event, assignment);
      
      // 记录分配历史
      await this.recordAssignmentHistory(event, assignment);
      
      // 发送分配通知
      await this.sendAssignmentNotification(event, assignment);
      
      console.log(`问题 ${event.id} 已分配给 ${assignment.assignee}`);
    } catch (error) {
      console.error(`问题分配失败:`, error);
      throw error;
    }
  }
  
  async determineAssignment(event) {
    // 按优先级应用分配规则
    const sortedRules = Array.from(this.rules.entries())
      .sort(([, a], [, b]) => a.priority - b.priority);
    
    for (const [name, rule] of sortedRules) {
      if (rule.matcher(event)) {
        const owner = await rule.resolver(event);
        if (owner) {
          return {
            assignee: owner,
            rule: name,
            reason: `匹配规则: ${name}`
          };
        }
      }
    }
    
    // 如果没有匹配的规则，使用默认分配
    return await this.getDefaultAssignment(event);
  }
  
  async assignIssue(event, assignment) {
    // 调用Sentry API分配问题
    const response = await fetch(`${this.collaborationManager.options.baseUrl}/issues/${event.id}/`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${this.collaborationManager.options.authToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        assignedTo: assignment.assignee,
        status: 'unresolved'
      })
    });
    
    if (!response.ok) {
      throw new Error(`分配问题失败: ${response.statusText}`);
    }
  }
  
  async recordAssignmentHistory(event, assignment) {
    // 记录分配历史到数据库或日志系统
    const historyRecord = {
      issueId: event.id,
      assignee: assignment.assignee,
      rule: assignment.rule,
      reason: assignment.reason,
      timestamp: new Date().toISOString(),
      project: event.project.slug
    };
    
    // 这里可以保存到数据库
    console.log('分配历史记录:', historyRecord);
  }
  
  async sendAssignmentNotification(event, assignment) {
    const notification = {
      type: 'assignment',
      recipient: assignment.assignee,
      subject: `新问题分配: ${event.title}`,
      content: this.buildAssignmentMessage(event, assignment),
      priority: this.getNotificationPriority(event)
    };
    
    await this.collaborationManager.notificationManager.send(notification);
  }
  
  shouldReassign(event) {
    // 判断是否需要重新分配
    return (
      !event.assignedTo || // 未分配
      event.count > event.previousCount * 2 || // 错误数量激增
      this.isStaleAssignment(event) // 分配过期
    );
  }
  
  isStaleAssignment(event) {
    // 检查分配是否过期（例如，分配后24小时未处理）
    if (!event.assignedTo || !event.assignedAt) return false;
    
    const assignedTime = new Date(event.assignedAt);
    const now = new Date();
    const hoursSinceAssigned = (now - assignedTime) / (1000 * 60 * 60);
    
    return hoursSinceAssigned > 24 && event.status === 'unresolved';
  }
  
  async getDefaultAssignment(event) {
    // 获取项目的默认负责人
    const project = this.collaborationManager.projects.get(event.project.slug);
    const teamLead = await this.collaborationManager.getTeamLead(project.team.slug);
    
    return {
      assignee: teamLead,
      rule: 'default',
      reason: '默认分配给团队负责人'
    };
  }
  
  extractFilePath(culprit) {
    if (!culprit) return null;
    
    // 提取文件路径
    const match = culprit.match(/([^/\\]+\.(js|ts|jsx|tsx|vue|py|java|go|rb))/);
    return match ? match[1] : null;
  }
  
  async findOwnerByFilePath(filePath) {
    if (!filePath) return null;
    
    // 这里可以集成CODEOWNERS文件或其他代码所有权系统
    const codeOwners = await this.loadCodeOwners();
    return codeOwners[filePath] || null;
  }
  
  getErrorType(event) {
    if (event.exception && event.exception.values.length > 0) {
      return event.exception.values[0].type;
    }
    return 'unknown';
  }
  
  async findOwnerByErrorType(errorType) {
    // 基于错误类型查找专家
    const specialists = {
      'TypeError': 'frontend-team@company.com',
      'ReferenceError': 'frontend-team@company.com',
      'NetworkError': 'backend-team@company.com',
      'DatabaseError': 'backend-team@company.com',
      'AuthenticationError': 'security-team@company.com'
    };
    
    return specialists[errorType] || null;
  }
  
  async findOwnerByTags(tags) {
    if (!tags || Object.keys(tags).length === 0) return null;
    
    // 基于标签查找负责人
    const tagOwners = {
      'component.payment': 'payment-team@company.com',
      'component.auth': 'auth-team@company.com',
      'component.ui': 'frontend-team@company.com',
      'environment.production': 'devops-team@company.com'
    };
    
    for (const [key, value] of Object.entries(tags)) {
      const tagKey = `${key}.${value}`;
      if (tagOwners[tagKey]) {
        return tagOwners[tagKey];
      }
    }
    
    return null;
  }
  
  async findOwnerByUser(user) {
    if (!user || !user.email) return null;
    
    // 基于用户信息查找负责人
    // 例如，VIP用户的问题分配给高级工程师
    if (user.isVip) {
      return 'senior-engineer@company.com';
    }
    
    return null;
  }
  
  async loadCodeOwners() {
    // 加载CODEOWNERS文件或其他代码所有权配置
    // 这里返回一个简化的映射
    return {
      'app.js': 'frontend-lead@company.com',
      'api.js': 'backend-lead@company.com',
      'auth.js': 'security-team@company.com'
    };
  }
  
  buildAssignmentMessage(event, assignment) {
    return `
      您有一个新的问题需要处理：
      
      问题: ${event.title}
      项目: ${event.project.name}
      分配规则: ${assignment.rule}
      分配原因: ${assignment.reason}
      严重程度: ${event.level}
      发生次数: ${event.count}
      首次发生: ${event.firstSeen}
      最后发生: ${event.lastSeen}
      
      问题详情:
      ${event.culprit}
      
      查看完整信息: ${event.permalink}
      
      请及时处理此问题。如有疑问，请联系团队负责人。
    `;
  }
  
  getNotificationPriority(event) {
    if (event.level === 'error' && event.count > 100) {
      return 'high';
    } else if (event.level === 'error' || event.count > 50) {
      return 'medium';
    }
    return 'low';
  }
}

2. 工作流集成系统

2.1 问题升级工作流

// 问题升级工作流
class IssueEscalationWorkflow {
  constructor(collaborationManager) {
    this.collaborationManager = collaborationManager;
    this.name = 'issue_escalation';
    this.escalationRules = new Map();
    this.escalationTimers = new Map();
  }
  
  async initialize() {
    await this.loadEscalationRules();
    this.setupEscalationMonitoring();
  }
  
  async loadEscalationRules() {
    // 基于时间的升级规则
    this.escalationRules.set('time_based', {
      condition: (event) => this.isTimeBasedEscalation(event),
      action: async (event) => await this.performTimeBasedEscalation(event),
      priority: 1
    });
    
    // 基于频率的升级规则
    this.escalationRules.set('frequency_based', {
      condition: (event) => this.isFrequencyBasedEscalation(event),
      action: async (event) => await this.performFrequencyBasedEscalation(event),
      priority: 2
    });
    
    // 基于严重程度的升级规则
    this.escalationRules.set('severity_based', {
      condition: (event) => this.isSeverityBasedEscalation(event),
      action: async (event) => await this.performSeverityBasedEscalation(event),
      priority: 3
    });
    
    // 基于用户影响的升级规则
    this.escalationRules.set('user_impact_based', {
      condition: (event) => this.isUserImpactBasedEscalation(event),
      action: async (event) => await this.performUserImpactBasedEscalation(event),
      priority: 4
    });
  }
  
  setupEscalationMonitoring() {
    // 定期检查需要升级的问题
    setInterval(async () => {
      await this.checkPendingEscalations();
    }, 5 * 60 * 1000); // 每5分钟检查一次
  }
  
  async execute(event, assignment) {
    try {
      // 检查是否需要升级
      const escalationNeeded = await this.shouldEscalate(event);
      
      if (escalationNeeded) {
        await this.performEscalation(event, assignment);
      } else {
        // 设置升级定时器
        await this.scheduleEscalation(event, assignment);
      }
    } catch (error) {
      console.error('升级工作流执行失败:', error);
    }
  }
  
  async shouldEscalate(event) {
    // 检查所有升级规则
    for (const [name, rule] of this.escalationRules) {
      if (rule.condition(event)) {
        console.log(`触发升级规则: ${name}`);
        return true;
      }
    }
    return false;
  }
  
  async performEscalation(event, assignment) {
    // 执行升级操作
    const escalationLevel = this.determineEscalationLevel(event);
    const escalationContacts = await this.getEscalationContacts(escalationLevel, assignment);
    
    // 更新问题优先级
    await this.updateIssuePriority(event, escalationLevel);
    
    // 发送升级通知
    await this.sendEscalationNotifications(event, escalationLevel, escalationContacts);
    
    // 记录升级历史
    await this.recordEscalation(event, escalationLevel, escalationContacts);
    
    console.log(`问题 ${event.id} 已升级到级别 ${escalationLevel}`);
  }
  
  async scheduleEscalation(event, assignment) {
    // 计算升级时间
    const escalationTime = this.calculateEscalationTime(event);
    
    // 设置定时器
    const timerId = setTimeout(async () => {
      await this.performScheduledEscalation(event, assignment);
    }, escalationTime);
    
    // 保存定时器引用
    this.escalationTimers.set(event.id, {
      timerId,
      scheduledTime: Date.now() + escalationTime,
      event,
      assignment
    });
  }
  
  async performScheduledEscalation(event, assignment) {
    // 检查问题是否已解决
    const currentStatus = await this.getIssueStatus(event.id);
    if (currentStatus === 'resolved') {
      console.log(`问题 ${event.id} 已解决，取消升级`);
      return;
    }
    
    // 执行升级
    await this.performEscalation(event, assignment);
    
    // 清理定时器
    this.escalationTimers.delete(event.id);
  }
  
  async checkPendingEscalations() {
    // 检查所有待升级的问题
    for (const [issueId, escalation] of this.escalationTimers) {
      try {
        const currentStatus = await this.getIssueStatus(issueId);
        
        if (currentStatus === 'resolved') {
          // 问题已解决，取消升级
          clearTimeout(escalation.timerId);
          this.escalationTimers.delete(issueId);
          console.log(`问题 ${issueId} 已解决，取消升级`);
        }
      } catch (error) {
        console.error(`检查问题 ${issueId} 状态失败:`, error);
      }
    }
  }
  
  // 升级条件检查方法
  isTimeBasedEscalation(event) {
    if (!event.assignedAt) return false;
    
    const assignedTime = new Date(event.assignedAt);
    const now = new Date();
    const hoursSinceAssigned = (now - assignedTime) / (1000 * 60 * 60);
    
    // 根据严重程度设置不同的时间阈值
    const thresholds = {
      'error': 2,    // 2小时
      'warning': 8,  // 8小时
      'info': 24     // 24小时
    };
    
    return hoursSinceAssigned > (thresholds[event.level] || 24);
  }
  
  isFrequencyBasedEscalation(event) {
    // 基于错误频率的升级
    const recentCount = this.getRecentErrorCount(event, 1); // 最近1小时
    const threshold = event.level === 'error' ? 50 : 100;
    
    return recentCount > threshold;
  }
  
  isSeverityBasedEscalation(event) {
    // 基于严重程度的立即升级
    return event.level === 'error' && event.count > 1000;
  }
  
  isUserImpactBasedEscalation(event) {
    // 基于用户影响的升级
    const affectedUsers = this.getAffectedUsersCount(event);
    return affectedUsers > 100; // 影响超过100个用户
  }
  
  // 升级操作方法
  async performTimeBasedEscalation(event) {
    return await this.escalateToNextLevel(event, 'time_based');
  }
  
  async performFrequencyBasedEscalation(event) {
    return await this.escalateToNextLevel(event, 'frequency_based');
  }
  
  async performSeverityBasedEscalation(event) {
    return await this.escalateToHighestLevel(event, 'severity_based');
  }
  
  async performUserImpactBasedEscalation(event) {
    return await this.escalateToHighestLevel(event, 'user_impact_based');
  }
  
  async escalateToNextLevel(event, reason) {
    const currentLevel = event.escalationLevel || 0;
    const nextLevel = Math.min(currentLevel + 1, 3); // 最高级别为3
    
    return await this.escalateToLevel(event, nextLevel, reason);
  }
  
  async escalateToHighestLevel(event, reason) {
    return await this.escalateToLevel(event, 3, reason);
  }
  
  async escalateToLevel(event, level, reason) {
    // 更新升级级别
    await this.updateEscalationLevel(event, level);
    
    // 获取升级联系人
    const contacts = await this.getEscalationContacts(level);
    
    // 发送升级通知
    await this.sendEscalationNotifications(event, level, contacts, reason);
    
    return { level, contacts, reason };
  }
  
  determineEscalationLevel(event) {
    if (event.level === 'error' && event.count > 1000) {
      return 3; // 最高级别
    } else if (event.level === 'error' && event.count > 100) {
      return 2; // 高级别
    } else if (event.level === 'error' || event.count > 50) {
      return 1; // 中级别
    }
    return 0; // 基础级别
  }
  
  async getEscalationContacts(level, assignment = null) {
    const contacts = [];
    
    switch (level) {
      case 0:
        // 基础级别：分配给的开发者
        if (assignment && assignment.assignee) {
          contacts.push(assignment.assignee);
        }
        break;
        
      case 1:
        // 中级别：团队负责人
        if (assignment && assignment.team) {
          const teamLead = await this.collaborationManager.getTeamLead(assignment.team.slug);
          contacts.push(teamLead);
        }
        break;
        
      case 2:
        // 高级别：技术负责人
        contacts.push('tech-lead@company.com');
        break;
        
      case 3:
        // 最高级别：CTO和运维团队
        contacts.push('cto@company.com', 'devops-team@company.com');
        break;
    }
    
    return contacts;
  }
  
  async updateIssuePriority(event, escalationLevel) {
    const priority = this.mapEscalationLevelToPriority(escalationLevel);
    
    const response = await fetch(`${this.collaborationManager.options.baseUrl}/issues/${event.id}/`, {
      method: 'PUT',
      headers: {
        'Authorization': `Bearer ${this.collaborationManager.options.authToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        priority: priority,
        escalationLevel: escalationLevel
      })
    });
    
    if (!response.ok) {
      throw new Error(`更新问题优先级失败: ${response.statusText}`);
    }
  }
  
  async sendEscalationNotifications(event, level, contacts, reason = '') {
    const notifications = contacts.map(contact => ({
      type: 'escalation',
      recipient: contact,
      subject: `问题升级通知 - 级别 ${level}: ${event.title}`,
      content: this.buildEscalationMessage(event, level, reason),
      priority: 'high',
      channel: level >= 2 ? 'multiple' : 'email' // 高级别使用多渠道通知
    }));
    
    for (const notification of notifications) {
      await this.collaborationManager.notificationManager.send(notification);
    }
  }
  
  async recordEscalation(event, level, contacts) {
    const escalationRecord = {
      issueId: event.id,
      escalationLevel: level,
      escalatedTo: contacts,
      timestamp: new Date().toISOString(),
      reason: this.getEscalationReason(event, level)
    };
    
    // 保存升级记录
    console.log('升级记录:', escalationRecord);
  }
  
  // 辅助方法
  calculateEscalationTime(event) {
    // 根据问题严重程度计算升级时间
    const baseTimes = {
      'error': 2 * 60 * 60 * 1000,    // 2小时
      'warning': 8 * 60 * 60 * 1000,  // 8小时
      'info': 24 * 60 * 60 * 1000     // 24小时
    };
    
    return baseTimes[event.level] || baseTimes['info'];
  }
  
  async getIssueStatus(issueId) {
    const response = await fetch(`${this.collaborationManager.options.baseUrl}/issues/${issueId}/`, {
      headers: {
        'Authorization': `Bearer ${this.collaborationManager.options.authToken}`,
        'Content-Type': 'application/json'
      }
    });
    
    if (!response.ok) {
      throw new Error(`获取问题状态失败: ${response.statusText}`);
    }
    
    const issue = await response.json();
    return issue.status;
  }
  
  getRecentErrorCount(event, hours) {
    // 获取最近指定小时内的错误数量
    // 这里简化实现，实际应该查询Sentry API
    return event.count || 0;
  }
  
  getAffectedUsersCount(event) {
    // 获取受影响的用户数量
    return event.userCount || 0;
  }
  
  async updateEscalationLevel(event, level) {
    // 更新事件的升级级别
    event.escalationLevel = level;
  }
  
  mapEscalationLevelToPriority(level) {
    const mapping = {
      0: 'low',
      1: 'medium',
      2: 'high',
      3: 'critical'
    };
    return mapping[level] || 'low';
  }
  
  buildEscalationMessage(event, level, reason) {
    const levelNames = {
      0: '基础',
      1: '中等',
      2: '高',
      3: '紧急'
    };
    
    return `
      问题已升级到 ${levelNames[level]} 级别
      
      问题: ${event.title}
      项目: ${event.project.name}
      升级级别: ${level} (${levelNames[level]})
      升级原因: ${reason}
      
      问题详情:
      - 严重程度: ${event.level}
      - 发生次数: ${event.count}
      - 首次发生: ${event.firstSeen}
      - 最后发生: ${event.lastSeen}
      - 受影响用户: ${this.getAffectedUsersCount(event)}
      
      错误信息:
      ${event.culprit}
      
      查看详情: ${event.permalink}
      
      请立即处理此问题！
    `;
  }
  
  getEscalationReason(event, level) {
    // 根据升级级别和事件信息生成升级原因
    const reasons = [];
    
    if (this.isTimeBasedEscalation(event)) {
      reasons.push('超时未处理');
    }
    
    if (this.isFrequencyBasedEscalation(event)) {
      reasons.push('错误频率过高');
    }
    
    if (this.isSeverityBasedEscalation(event)) {
      reasons.push('严重程度过高');
    }
    
    if (this.isUserImpactBasedEscalation(event)) {
      reasons.push('用户影响范围过大');
    }
    
    return reasons.join(', ') || '自动升级';
  }
}

2.2 通知管理系统

// 通知管理器
class NotificationManager {
  constructor(options = {}) {
    this.options = options;
    this.channels = new Map();
    this.templates = new Map();
    this.queue = [];
    this.processing = false;
  }
  
  async initialize() {
    // 初始化通知渠道
    await this.initializeChannels();
    
    // 加载通知模板
    await this.loadTemplates();
    
    // 启动队列处理
    this.startQueueProcessor();
  }
  
  async initializeChannels() {
    // Slack通知渠道
    if (this.options.slack) {
      this.channels.set('slack', new SlackNotificationChannel(this.options.slack));
    }
    
    // 邮件通知渠道
    if (this.options.email) {
      this.channels.set('email', new EmailNotificationChannel(this.options.email));
    }
    
    // Microsoft Teams通知渠道
    if (this.options.teams) {
      this.channels.set('teams', new TeamsNotificationChannel(this.options.teams));
    }
    
    // 短信通知渠道
    if (this.options.sms) {
      this.channels.set('sms', new SMSNotificationChannel(this.options.sms));
    }
    
    // 初始化所有渠道
    for (const [name, channel] of this.channels) {
      try {
        await channel.initialize();
        console.log(`通知渠道 ${name} 初始化成功`);
      } catch (error) {
        console.error(`通知渠道 ${name} 初始化失败:`, error);
      }
    }
  }
  
  async loadTemplates() {
    // 问题分配模板
    this.templates.set('assignment', {
      subject: '新问题分配: {{title}}',
      content: `
        您有一个新的问题需要处理：
        
        问题: {{title}}
        项目: {{project}}
        分配原因: {{reason}}
        严重程度: {{level}}
        发生次数: {{count}}
        
        查看详情: {{permalink}}
      `
    });
    
    // 问题升级模板
    this.templates.set('escalation', {
      subject: '问题升级通知 - 级别 {{level}}: {{title}}',
      content: `
        问题已升级到 {{levelName}} 级别
        
        问题: {{title}}
        项目: {{project}}
        升级级别: {{level}} ({{levelName}})
        升级原因: {{reason}}
        
        请立即处理此问题！
        
        查看详情: {{permalink}}
      `
    });
    
    // 问题解决模板
    this.templates.set('resolution', {
      subject: '问题已解决: {{title}}',
      content: `
        问题已成功解决：
        
        问题: {{title}}
        项目: {{project}}
        解决者: {{resolver}}
        解决时间: {{resolvedAt}}
        
        感谢您的及时处理！
      `
    });
    
    // 性能告警模板
    this.templates.set('performance_alert', {
      subject: '性能告警: {{metric}} 超过阈值',
      content: `
        检测到性能问题：
        
        指标: {{metric}}
        当前值: {{currentValue}}
        阈值: {{threshold}}
        项目: {{project}}
        
        请检查应用性能并进行优化。
        
        查看详情: {{permalink}}
      `
    });
  }
  
  async send(notification) {
    // 添加到队列
    this.queue.push({
      ...notification,
      id: this.generateNotificationId(),
      timestamp: Date.now(),
      retries: 0
    });
    
    // 如果队列处理器未运行，启动它
    if (!this.processing) {
      this.startQueueProcessor();
    }
  }
  
  startQueueProcessor() {
    if (this.processing) return;
    
    this.processing = true;
    
    const processQueue = async () => {
      while (this.queue.length > 0) {
        const notification = this.queue.shift();
        
        try {
          await this.processNotification(notification);
        } catch (error) {
          console.error(`处理通知失败:`, error);
          
          // 重试逻辑
          if (notification.retries < 3) {
            notification.retries++;
            this.queue.push(notification);
          } else {
            console.error(`通知 ${notification.id} 重试次数超限，丢弃`);
          }
        }
        
        // 避免过于频繁的发送
        await this.delay(100);
      }
      
      this.processing = false;
    };
    
    processQueue();
  }
  
  async processNotification(notification) {
    // 渲染通知内容
    const renderedNotification = await this.renderNotification(notification);
    
    // 确定发送渠道
    const channels = this.determineChannels(notification);
    
    // 发送到各个渠道
    const sendPromises = channels.map(async (channelName) => {
      const channel = this.channels.get(channelName);
      if (!channel) {
        throw new Error(`未找到通知渠道: ${channelName}`);
      }
      
      return await channel.send(renderedNotification);
    });
    
    await Promise.all(sendPromises);
    
    console.log(`通知 ${notification.id} 发送成功`);
  }
  
  async renderNotification(notification) {
    // 获取模板
    const template = this.templates.get(notification.type);
    if (!template) {
      throw new Error(`未找到通知模板: ${notification.type}`);
    }
    
    // 渲染主题和内容
    const subject = this.renderTemplate(template.subject, notification.data || {});
    const content = this.renderTemplate(template.content, notification.data || {});
    
    return {
      ...notification,
      subject,
      content
    };
  }
  
  renderTemplate(template, data) {
    return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
      return data[key] || match;
    });
  }
  
  determineChannels(notification) {
    const channels = [];
    
    // 根据通知类型和优先级确定渠道
    switch (notification.channel) {
      case 'email':
        channels.push('email');
        break;
        
      case 'slack':
        channels.push('slack');
        break;
        
      case 'teams':
        channels.push('teams');
        break;
        
      case 'sms':
        channels.push('sms');
        break;
        
      case 'multiple':
        // 高优先级使用多渠道
        if (notification.priority === 'high' || notification.priority === 'critical') {
          channels.push('email', 'slack');
          
          if (notification.priority === 'critical') {
            channels.push('sms');
          }
        } else {
          channels.push('email');
        }
        break;
        
      default:
        channels.push('email'); // 默认使用邮件
    }
    
    // 过滤可用的渠道
    return channels.filter(channel => this.channels.has(channel));
  }
  
  generateNotificationId() {
    return `notif_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
  
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Slack通知渠道
class SlackNotificationChannel {
  constructor(options) {
    this.options = options;
    this.webhookUrl = options.webhookUrl;
    this.channels = options.channels || {};
  }
  
  async initialize() {
    // 测试Slack连接
    if (this.webhookUrl) {
      await this.testConnection();
    }
  }
  
  async testConnection() {
    const response = await fetch(this.webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        text: 'Sentry通知系统测试连接',
        username: 'Sentry Bot'
      })
    });
    
    if (!response.ok) {
      throw new Error(`Slack连接测试失败: ${response.statusText}`);
    }
  }
  
  async send(notification) {
    const slackMessage = this.formatSlackMessage(notification);
    
    const response = await fetch(this.webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(slackMessage)
    });
    
    if (!response.ok) {
      throw new Error(`Slack消息发送失败: ${response.statusText}`);
    }
  }
  
  formatSlackMessage(notification) {
    const color = this.getColorByPriority(notification.priority);
    
    return {
      username: 'Sentry Bot',
      icon_emoji: ':warning:',
      text: notification.subject,
      attachments: [{
        color: color,
        title: notification.subject,
        text: notification.content,
        footer: 'Sentry',
        ts: Math.floor(notification.timestamp / 1000)
      }]
    };
  }
  
  getColorByPriority(priority) {
    const colors = {
      'low': 'good',
      'medium': 'warning',
      'high': 'danger',
      'critical': '#ff0000'
    };
    return colors[priority] || 'good';
  }
}

// 邮件通知渠道
class EmailNotificationChannel {
  constructor(options) {
    this.options = options;
    this.smtpConfig = options.smtpConfig;
  }
  
  async initialize() {
    // 初始化SMTP连接
    if (this.smtpConfig) {
      // 这里可以初始化nodemailer或其他邮件库
      console.log('邮件通知渠道初始化完成');
    }
  }
  
  async send(notification) {
    // 发送邮件
    const emailOptions = {
      from: this.smtpConfig.from,
      to: notification.recipient,
      subject: notification.subject,
      html: this.formatEmailContent(notification.content),
      priority: this.mapPriorityToEmail(notification.priority)
    };
    
    // 这里使用实际的邮件发送库
    console.log('发送邮件:', emailOptions);
    // await this.transporter.sendMail(emailOptions);
  }
  
  formatEmailContent(content) {
    // 将纯文本转换为HTML格式
    return content
      .replace(/\n/g, '<br>')
      .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
      .replace(/\*(.*?)\*/g, '<em>$1</em>');
  }
  
  mapPriorityToEmail(priority) {
    const mapping = {
      'low': 'normal',
      'medium': 'normal',
      'high': 'high',
      'critical': 'high'
    };
    return mapping[priority] || 'normal';
  }
}

// Microsoft Teams通知渠道
class TeamsNotificationChannel {
  constructor(options) {
    this.options = options;
    this.webhookUrl = options.webhookUrl;
  }
  
  async initialize() {
    if (this.webhookUrl) {
      await this.testConnection();
    }
  }
  
  async testConnection() {
    const response = await fetch(this.webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        text: 'Sentry通知系统测试连接'
      })
    });
    
    if (!response.ok) {
      throw new Error(`Teams连接测试失败: ${response.statusText}`);
    }
  }
  
  async send(notification) {
    const teamsMessage = this.formatTeamsMessage(notification);
    
    const response = await fetch(this.webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(teamsMessage)
    });
    
    if (!response.ok) {
      throw new Error(`Teams消息发送失败: ${response.statusText}`);
    }
  }
  
  formatTeamsMessage(notification) {
    const color = this.getColorByPriority(notification.priority);
    
    return {
      '@type': 'MessageCard',
      '@context': 'http://schema.org/extensions',
      themeColor: color,
      summary: notification.subject,
      sections: [{
        activityTitle: notification.subject,
        activitySubtitle: 'Sentry通知',
        text: notification.content,
        markdown: true
      }]
    };
  }
  
  getColorByPriority(priority) {
    const colors = {
      'low': '00FF00',
      'medium': 'FFA500',
      'high': 'FF0000',
      'critical': '8B0000'
    };
    return colors[priority] || '00FF00';
  }
}

// 短信通知渠道
class SMSNotificationChannel {
  constructor(options) {
    this.options = options;
    this.apiKey = options.apiKey;
    this.apiUrl = options.apiUrl;
  }
  
  async initialize() {
    console.log('短信通知渠道初始化完成');
  }
  
  async send(notification) {
    const smsContent = this.formatSMSContent(notification);
    
    // 这里使用实际的短信API
    console.log('发送短信:', {
      to: notification.recipient,
      content: smsContent
    });
  }
  
  formatSMSContent(notification) {
    // 短信内容需要简洁
    return `Sentry告警: ${notification.subject.substring(0, 50)}...`;
  }
}

3. 外部系统集成

3.1 JIRA集成

// JIRA集成管理器
class JiraIntegrationManager {
  constructor(options = {}) {
    this.options = {
      baseUrl: options.baseUrl,
      username: options.username,
      apiToken: options.apiToken,
      projectKey: options.projectKey,
      ...options
    };
    
    this.issueTypeMapping = new Map();
    this.priorityMapping = new Map();
    this.statusMapping = new Map();
  }
  
  async initialize() {
    await this.setupMappings();
    await this.testConnection();
  }
  
  async setupMappings() {
    // 问题类型映射
    this.issueTypeMapping.set('error', 'Bug');
    this.issueTypeMapping.set('warning', 'Task');
    this.issueTypeMapping.set('info', 'Task');
    
    // 优先级映射
    this.priorityMapping.set('critical', 'Highest');
    this.priorityMapping.set('high', 'High');
    this.priorityMapping.set('medium', 'Medium');
    this.priorityMapping.set('low', 'Low');
    
    // 状态映射
    this.statusMapping.set('unresolved', 'Open');
    this.statusMapping.set('resolved', 'Done');
    this.statusMapping.set('ignored', 'Closed');
  }
  
  async testConnection() {
    const response = await this.makeJiraRequest('/rest/api/2/myself', 'GET');
    if (!response.ok) {
      throw new Error('JIRA连接测试失败');
    }
    console.log('JIRA连接测试成功');
  }
  
  async createIssueFromSentryEvent(sentryEvent) {
    try {
      const jiraIssue = await this.convertSentryEventToJiraIssue(sentryEvent);
      const createdIssue = await this.createJiraIssue(jiraIssue);
      
      // 在Sentry中添加JIRA链接
      await this.linkSentryToJira(sentryEvent.id, createdIssue.key);
      
      console.log(`为Sentry事件 ${sentryEvent.id} 创建了JIRA问题 ${createdIssue.key}`);
      return createdIssue;
    } catch (error) {
      console.error('创建JIRA问题失败:', error);
      throw error;
    }
  }
  
  async convertSentryEventToJiraIssue(sentryEvent) {
    const issueType = this.issueTypeMapping.get(sentryEvent.level) || 'Task';
    const priority = this.priorityMapping.get(sentryEvent.priority) || 'Medium';
    
    return {
      fields: {
        project: {
          key: this.options.projectKey
        },
        summary: `[Sentry] ${sentryEvent.title}`,
        description: this.buildJiraDescription(sentryEvent),
        issuetype: {
          name: issueType
        },
        priority: {
          name: priority
        },
        labels: this.buildJiraLabels(sentryEvent),
        customfield_10001: sentryEvent.permalink // Sentry链接自定义字段
      }
    };
  }
  
  buildJiraDescription(sentryEvent) {
    return `
      h3. Sentry错误详情
      
      *项目:* ${sentryEvent.project.name}
      *环境:* ${sentryEvent.environment || 'unknown'}
      *发生次数:* ${sentryEvent.count}
      *首次发生:* ${sentryEvent.firstSeen}
      *最后发生:* ${sentryEvent.lastSeen}
      *受影响用户:* ${sentryEvent.userCount || 0}
      
      h3. 错误信息
      {code}
      ${sentryEvent.culprit}
      {code}
      
      h3. 堆栈跟踪
      {code}
      ${this.getStackTrace(sentryEvent)}
      {code}
      
      h3. 用户上下文
      ${this.getUserContext(sentryEvent)}
      
      h3. 标签
      ${this.getTagsInfo(sentryEvent)}
      
      [查看Sentry详情|${sentryEvent.permalink}]
    `;
  }
  
  buildJiraLabels(sentryEvent) {
    const labels = ['sentry', sentryEvent.level];
    
    if (sentryEvent.environment) {
      labels.push(`env-${sentryEvent.environment}`);
    }
    
    if (sentryEvent.release) {
      labels.push(`release-${sentryEvent.release.version}`);
    }
    
    return labels;
  }
  
  async createJiraIssue(issueData) {
    const response = await this.makeJiraRequest('/rest/api/2/issue', 'POST', issueData);
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(`创建JIRA问题失败: ${JSON.stringify(error)}`);
    }
    
    return await response.json();
  }
  
  async updateJiraIssue(issueKey, updateData) {
    const response = await this.makeJiraRequest(`/rest/api/2/issue/${issueKey}`, 'PUT', updateData);
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(`更新JIRA问题失败: ${JSON.stringify(error)}`);
    }
  }
  
  async linkSentryToJira(sentryIssueId, jiraIssueKey) {
    // 在Sentry中添加JIRA链接
    // 这需要使用Sentry的API来添加外部链接
    console.log(`链接Sentry问题 ${sentryIssueId} 到JIRA问题 ${jiraIssueKey}`);
  }
  
  async syncIssueStatus(sentryEvent, jiraIssueKey) {
    try {
      // 获取JIRA问题状态
      const jiraIssue = await this.getJiraIssue(jiraIssueKey);
      const jiraStatus = jiraIssue.fields.status.name;
      
      // 映射到Sentry状态
      const sentryStatus = this.mapJiraStatusToSentry(jiraStatus);
      
      if (sentryStatus) {
        await this.updateSentryIssueStatus(sentryEvent.id, sentryStatus);
        console.log(`同步状态: JIRA ${jiraStatus} -> Sentry ${sentryStatus}`);
      }
    } catch (error) {
      console.error('同步问题状态失败:', error);
    }
  }
  
  async getJiraIssue(issueKey) {
    const response = await this.makeJiraRequest(`/rest/api/2/issue/${issueKey}`, 'GET');
    
    if (!response.ok) {
      throw new Error(`获取JIRA问题失败: ${response.statusText}`);
    }
    
    return await response.json();
  }
  
  mapJiraStatusToSentry(jiraStatus) {
    const mapping = {
      'Done': 'resolved',
      'Closed': 'ignored',
      'Resolved': 'resolved',
      'Open': 'unresolved',
      'In Progress': 'unresolved'
    };
    
    return mapping[jiraStatus];
  }
  
  async updateSentryIssueStatus(issueId, status) {
    // 更新Sentry问题状态
    // 这需要使用Sentry的API
    console.log(`更新Sentry问题 ${issueId} 状态为 ${status}`);
  }
  
  async makeJiraRequest(endpoint, method, data = null) {
    const url = `${this.options.baseUrl}${endpoint}`;
    const auth = btoa(`${this.options.username}:${this.options.apiToken}`);
    
    const options = {
      method,
      headers: {
        'Authorization': `Basic ${auth}`,
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    };
    
    if (data) {
      options.body = JSON.stringify(data);
    }
    
    return await fetch(url, options);
  }
  
  // 辅助方法
  getStackTrace(sentryEvent) {
    if (sentryEvent.exception && sentryEvent.exception.values.length > 0) {
      const exception = sentryEvent.exception.values[0];
      if (exception.stacktrace && exception.stacktrace.frames) {
        return exception.stacktrace.frames
          .map(frame => `${frame.filename}:${frame.lineno} in ${frame.function}`)
          .join('\n');
      }
    }
    return '无堆栈跟踪信息';
  }
  
  getUserContext(sentryEvent) {
    if (sentryEvent.user) {
      return `
        *用户ID:* ${sentryEvent.user.id || 'unknown'}
        *用户邮箱:* ${sentryEvent.user.email || 'unknown'}
        *用户名:* ${sentryEvent.user.username || 'unknown'}
        *IP地址:* ${sentryEvent.user.ip_address || 'unknown'}
      `;
    }
    return '无用户上下文信息';
  }
  
  getTagsInfo(sentryEvent) {
    if (sentryEvent.tags && Object.keys(sentryEvent.tags).length > 0) {
      return Object.entries(sentryEvent.tags)
        .map(([key, value]) => `*${key}:* ${value}`)
        .join('\n');
    }
    return '无标签信息';
  }
}

3.2 GitHub集成

// GitHub集成管理器
class GitHubIntegrationManager {
  constructor(options = {}) {
    this.options = {
      owner: options.owner,
      repo: options.repo,
      token: options.token,
      baseUrl: 'https://api.github.com',
      ...options
    };
  }
  
  async initialize() {
    await this.testConnection();
  }
  
  async testConnection() {
    const response = await this.makeGitHubRequest('/user', 'GET');
    if (!response.ok) {
      throw new Error('GitHub连接测试失败');
    }
    console.log('GitHub连接测试成功');
  }
  
  async createIssueFromSentryEvent(sentryEvent) {
    try {
      const githubIssue = await this.convertSentryEventToGitHubIssue(sentryEvent);
      const createdIssue = await this.createGitHubIssue(githubIssue);
      
      console.log(`为Sentry事件 ${sentryEvent.id} 创建了GitHub Issue #${createdIssue.number}`);
      return createdIssue;
    } catch (error) {
      console.error('创建GitHub Issue失败:', error);
      throw error;
    }
  }
  
  async convertSentryEventToGitHubIssue(sentryEvent) {
    return {
      title: `[Sentry] ${sentryEvent.title}`,
      body: this.buildGitHubIssueBody(sentryEvent),
      labels: this.buildGitHubLabels(sentryEvent),
      assignees: await this.determineAssignees(sentryEvent)
    };
  }
  
  buildGitHubIssueBody(sentryEvent) {
    return `
## Sentry错误报告

**项目:** ${sentryEvent.project.name}
**环境:** ${sentryEvent.environment || 'unknown'}
**发生次数:** ${sentryEvent.count}
**首次发生:** ${sentryEvent.firstSeen}
**最后发生:** ${sentryEvent.lastSeen}
**受影响用户:** ${sentryEvent.userCount || 0}

### 错误信息
\`\`\`
${sentryEvent.culprit}
\`\`\`

### 堆栈跟踪
\`\`\`
${this.getStackTrace(sentryEvent)}
\`\`\`

### 用户上下文
${this.getUserContextMarkdown(sentryEvent)}

### 标签
${this.getTagsMarkdown(sentryEvent)}

### 相关链接
- [查看Sentry详情](${sentryEvent.permalink})

---
*此Issue由Sentry自动创建*
    `;
  }
  
  buildGitHubLabels(sentryEvent) {
    const labels = ['sentry', 'bug'];
    
    // 添加严重程度标签
    labels.push(`severity:${sentryEvent.level}`);
    
    // 添加环境标签
    if (sentryEvent.environment) {
      labels.push(`env:${sentryEvent.environment}`);
    }
    
    // 添加组件标签
    if (sentryEvent.tags && sentryEvent.tags.component) {
      labels.push(`component:${sentryEvent.tags.component}`);
    }
    
    return labels;
  }
  
  async determineAssignees(sentryEvent) {
    // 基于代码所有权确定分配者
    const assignees = [];
    
    if (sentryEvent.culprit) {
      const owner = await this.findCodeOwner(sentryEvent.culprit);
      if (owner) {
        assignees.push(owner);
      }
    }
    
    return assignees;
  }
  
  async findCodeOwner(culprit) {
    try {
      // 获取CODEOWNERS文件
      const codeowners = await this.getCodeOwners();
      
      // 解析文件路径
      const filePath = this.extractFilePath(culprit);
      if (!filePath) return null;
      
      // 查找匹配的所有者
      for (const rule of codeowners) {
        if (this.matchesPattern(filePath, rule.pattern)) {
          return rule.owners[0]; // 返回第一个所有者
        }
      }
    } catch (error) {
      console.error('查找代码所有者失败:', error);
    }
    
    return null;
  }
  
  async getCodeOwners() {
    try {
      const response = await this.makeGitHubRequest('/contents/.github/CODEOWNERS', 'GET');
      
      if (!response.ok) {
        return [];
      }
      
      const data = await response.json();
      const content = atob(data.content);
      
      return this.parseCodeOwners(content);
    } catch (error) {
      console.error('获取CODEOWNERS文件失败:', error);
      return [];
    }
  }
  
  parseCodeOwners(content) {
    const rules = [];
    const lines = content.split('\n');
    
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed && !trimmed.startsWith('#')) {
        const parts = trimmed.split(/\s+/);
        if (parts.length >= 2) {
          rules.push({
            pattern: parts[0],
            owners: parts.slice(1).map(owner => owner.replace('@', ''))
          });
        }
      }
    }
    
    return rules;
  }
  
  matchesPattern(filePath, pattern) {
    // 简化的模式匹配
    if (pattern === '*') return true;
    if (pattern.endsWith('*')) {
      return filePath.startsWith(pattern.slice(0, -1));
    }
    return filePath === pattern;
  }
  
  async createGitHubIssue(issueData) {
    const response = await this.makeGitHubRequest('/issues', 'POST', issueData);
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(`创建GitHub Issue失败: ${JSON.stringify(error)}`);
    }
    
    return await response.json();
  }
  
  async makeGitHubRequest(endpoint, method, data = null) {
    const url = `${this.options.baseUrl}/repos/${this.options.owner}/${this.options.repo}${endpoint}`;
    
    const options = {
      method,
      headers: {
        'Authorization': `token ${this.options.token}`,
        'Content-Type': 'application/json',
        'Accept': 'application/vnd.github.v3+json'
      }
    };
    
    if (data) {
      options.body = JSON.stringify(data);
    }
    
    return await fetch(url, options);
  }
  
  // 辅助方法
  extractFilePath(culprit) {
    if (!culprit) return null;
    
    const match = culprit.match(/([^/\\]+\.(js|ts|jsx|tsx|vue|py|java|go|rb))/);
    return match ? match[1] : null;
  }
  
  getStackTrace(sentryEvent) {
    if (sentryEvent.exception && sentryEvent.exception.values.length > 0) {
      const exception = sentryEvent.exception.values[0];
      if (exception.stacktrace && exception.stacktrace.frames) {
        return exception.stacktrace.frames
          .map(frame => `${frame.filename}:${frame.lineno} in ${frame.function}`)
          .join('\n');
      }
    }
    return '无堆栈跟踪信息';
  }
  
  getUserContextMarkdown(sentryEvent) {
    if (sentryEvent.user) {
      return `
- **用户ID:** ${sentryEvent.user.id || 'unknown'}
- **用户邮箱:** ${sentryEvent.user.email || 'unknown'}
- **用户名:** ${sentryEvent.user.username || 'unknown'}
- **IP地址:** ${sentryEvent.user.ip_address || 'unknown'}
      `;
    }
    return '无用户上下文信息';
  }
  
  getTagsMarkdown(sentryEvent) {
     if (sentryEvent.tags && Object.keys(sentryEvent.tags).length > 0) {
       return Object.entries(sentryEvent.tags)
         .map(([key, value]) => `- **${key}:** ${value}`)
         .join('\n');
     }
     return '无标签信息';
   }
 }