standard_automation_library 0.2.1.pre.temp

data/lib/standard_automation_library/personnel/release_management_team.rb

@@ -0,0 +1,85 @@
+require_relative 'team'
+require_relative 'user'
+
+# A team which automatically determines the members via querying pagerduty.
+# Users are not computed at instantiation for performance reasons.
+class ReleaseManagementTeam < Team
+  def initialize(
+    github_client,
+    slack_service,
+    pagerduty_client,
+    pagerduty_schedule_id,
+    pagerduty_cuttoff_hour = 10,
+    pagerduty_time_zone = 'America/Los_Angeles',
+    slack_user_group_id = nil,
+    error_reporting_channels: []
+  )
+    super(slack_user_group_id: slack_user_group_id)
+    @github_client = github_client
+    @slack_service = slack_service
+    @pagerduty_client = pagerduty_client
+    @pagerduty_schedule_id = pagerduty_schedule_id
+    @pagerduty_cuttoff_hour = pagerduty_cuttoff_hour
+    @pagerduty_time_zone = pagerduty_time_zone
+    @users = []
+    @error_reporting_channels = error_reporting_channels
+  end
+
+  def users
+    return @users unless @users.empty?
+
+    begin
+      # get name of the release manager from pagerduty
+      release_manager_name = @pagerduty_client.who_is_on_duty(
+        @pagerduty_schedule_id,
+        @pagerduty_cuttoff_hour,
+        time_zone: @pagerduty_time_zone
+      )
+
+      if release_manager_name
+        @users = [
+          User.new(
+            release_manager_name,
+            github_client: @github_client,
+            slack_service: @slack_service,
+            error_reporting_channels: @error_reporting_channels
+          )
+        ]
+      end
+    rescue StandardError => e
+      send_slack_failure(e.message)
+    end
+    @users
+  end
+
+  # get user of the next release manager from pagerduty (two weeks from now)
+  def next_release_manager(team_domain)
+    next_release_manager_name = @pagerduty_client.who_is_on_duty(
+      @pagerduty_schedule_id,
+      @pagerduty_cuttoff_hour,
+      time: Time.now + (14 * 24 * 60 * 60),
+      time_zone: @pagerduty_time_zone
+    )
+
+    return nil if next_release_manager_name.nil?
+
+    users_param = [User.new(
+      next_release_manager_name,
+      github_client: @github_client,
+      slack_service: @slack_service,
+      error_reporting_channels: @error_reporting_channels
+    )]
+    render_slack_ids(team_domain, users_param)
+  rescue StandardError => e
+    send_slack_failure(e.message)
+    nil
+  end
+
+  def send_slack_failure(error_message)
+    message = "There was an error fetching data from PagerDuty\n#{error_message}\n#{ENV.fetch('BUILD_URL', nil)}"
+    @slack_service.send_message(
+      channel_strings: @error_reporting_channels,
+      message: message
+    )
+  end
+end

data/lib/standard_automation_library/personnel/team.rb

@@ -0,0 +1,41 @@
+# Represents a collection of users
+class Team
+  def initialize(users: [], slack_user_group_id: nil)
+    # Don't access @users. Use the users method instead because a subclass may overwrite it.
+    @users = users
+    @slack_user_group_id = slack_user_group_id
+  end
+
+  attr_accessor :users
+
+  attr_accessor :slack_user_group_id
+
+  def names(users_param = nil)
+    users_to_use = users_param || users
+    users_to_use.map(&:name)
+  end
+
+  def github_ids(users_param = nil)
+    users_to_use = users_param || users
+    users_to_use.map(&:github_id)
+  end
+
+  def slack_user_id_hashes(users_param = nil)
+    users_to_use = users_param || users
+    users_to_use.map(&:slack_user_id_hash)
+  end
+
+  def slack_ids(team_domain, users_param = nil)
+    slack_user_id_hashes(users_param).map { |id_map| id_map[team_domain] }
+  end
+
+  def render_slack_ids(team_domain, users_param = nil)
+    slack_ids(team_domain, users_param).compact.map do |slack_id|
+      "<@#{slack_id}>"
+    end
+  end
+
+  def empty?
+    users.empty?
+  end
+end

data/lib/standard_automation_library/personnel/user.rb

@@ -0,0 +1,68 @@
+# Holds user id information for various 3rd party services
+# If services are supplied to compute the service usernames they
+# should only be used to provide just in time computation. No information
+# should be computed at instantiation.
+class User
+  def initialize(
+    name,
+    github_id: nil,
+    slack_user_id_hash: {},
+    github_client: nil,
+    slack_service: nil,
+    error_reporting_channels: []
+  )
+    @name = name
+    @github_id = github_id
+    @slack_user_id_hash = slack_user_id_hash
+    @github_client = github_client
+    @slack_service = slack_service
+    @error_reporting_channels = error_reporting_channels
+  end
+
+  attr_accessor :name
+
+  def github_id
+    return @github_id if @github_client.nil?
+
+    @github_id = @github_client.find_user_id(@name)
+    if @github_id.nil?
+      message = "Unable to resolve Github id for #{@name}. Ensure their name in Github matches #{@name}. " \
+                'The name field can be found by going to Settings > Profile in Github.'
+      send_error_message(message, true)
+    end
+    @github_id
+  end
+
+  def slack_user_id_hash
+    unless @slack_service.nil?
+      user_hash = @slack_service.user_hash([@name])
+      user_hash.each do |key, value|
+        user_id = value[0]
+        @slack_user_id_hash[key] = user_id unless user_id.nil?
+      end
+      if @slack_user_id_hash.empty?
+        message = "Unable to resolve slack user id for User object with name #{name}. " \
+                  'Ensure the name being searched for matches their name in slack.'
+        send_error_message(message, false)
+      end
+    end
+    @slack_user_id_hash
+  end
+
+  def send_error_message(message, tag_user)
+    return if @slack_service.nil? || @error_reporting_channels.empty?
+
+    slack_client = @slack_service.slack_client
+    if tag_user
+      user_id = slack_user_id_hash[slack_client.team_domain]
+      message = if user_id
+                  "<@#{user_id}> #{message}"
+                else
+                  "<!here> #{message}"
+                end
+    end
+    @slack_service.with_multiple_channels(@error_reporting_channels) do |channel_string|
+      slack_client.send_message(channel_name: channel_string, message: message)
+    end
+  end
+end

data/lib/standard_automation_library/services/bugsnag_service.rb

@@ -0,0 +1,251 @@
+require_relative '../api_clients/bugsnag'
+require_relative '../util/slack_constants'
+require 'yaml'
+
+# Service for querying information from Bugsnag
+class BugsnagService
+  include SlackConstants
+
+  STABILITY_ABOVE_TARGET = (99.9..100).freeze
+  STABILITY_BELOW_TARGET = (99.5...99.9).freeze
+
+  def initialize(
+    auth_token,
+    platform,
+    bugsnag_mapping_file_path,
+    slack_service,
+    slack_health_channels,
+    slack_release_channels,
+    release_manager_team
+  )
+    @client = BugsnagClient.new(platform, auth_token)
+    @slack_service = slack_service
+    @slack_health_channels = slack_health_channels
+    @slack_release_channels = slack_release_channels
+    @bugsnag_mapping_file_path_container = PathContainer.new([bugsnag_mapping_file_path])
+    @release_manager_team = release_manager_team
+    @platform = platform
+  end
+
+  ## Finds the top open and unhandled errors for the provided app_version and posts them to Slack.
+  def crash_report(
+    app_version,
+    count,
+    days
+  )
+    user_mappings = YAML.load_file(@bugsnag_mapping_file_path_container&.path)
+    formatted_errors = []
+    assigned_collaborators = []
+    @client.top_errors(
+      app_version,
+      count: count,
+      events_since: "#{days}d"
+    ).each do |error|
+      details = @client.error_details(error.id)
+      possible_team = find_team(user_mappings, details)
+      error_message, collaborator = make_slack_block_from_bugsnag_error(details, possible_team)
+      formatted_errors.append(error_message)
+      assigned_collaborators.append(collaborator)
+    end
+    initial_message, release_manager_slack_id = make_initial_message(app_version)
+    assigned_collaborators.append(release_manager_slack_id)
+    @slack_service.send_message_in_thread(
+      @slack_release_channels,
+      initial_message,
+      formatted_errors,
+      assigned_collaborators.compact
+    )
+  end
+
+  def platform_emoji
+    case @platform
+    when IOS
+      IOS_SLACK_EMOJI
+    when ANDROID
+      ANDROID_SLACK_EMOJI
+    else
+      ''
+    end
+  end
+
+  ## Makes the initial thread message, contains the platform emojis and tags the current release manager
+  def make_initial_message(app_version)
+    release_manager_slack_id = nil
+
+    if release_manager_slack_id.nil?
+      begin
+        release_manager_slack_id = @release_manager_team.slack_ids(@slack_service.slack_client.team_domain).compact[0]
+      rescue RuntimeError
+        # Ignored
+      end
+    end
+
+    formatted_manager_id = release_manager_slack_id ? "<@#{release_manager_slack_id}>" : ''
+    ["#{platform_emoji} :mega: ACC #{@platform} version " \
+     "*#{app_version}* top crashes :mega: #{platform_emoji}\n" \
+     "#{formatted_manager_id} please link Bugsnags to Jira tickets and create " \
+     'Jira tickets if an appropriate ticket does not exist already, per ' \
+     '<https://wiki.autodesk.com/display/SCFICOE/Critical+Crash+Rate+Playbook|Crash Rate Playbook>. ' \
+     ':point_down: :bc-thread:', release_manager_slack_id]
+  end
+
+  ## Tries to find a team from the mappings file, that has a keyword contained in the error's stack trace
+  def find_team(user_mappings, details)
+    extras = details.grouping_fields
+    possible_team = nil
+    ## Here we'll have the file and line that generated the error
+    unless extras&.file.nil?
+      error_file = extras.file
+      ## search based on the defined keywords for each team
+      possible_team = user_mappings.select { |t| t['keywords'].any? { |k| error_file.downcase.include? k } }[0]
+    end
+    possible_team
+  end
+
+  ## Generates the required Slack message in blocks format to be replied on a slack thread
+  def make_slack_block_from_bugsnag_error(details, team)
+    linked_issue = details.linked_issues&.first
+    message_emoji = details.error_class == 'ANR' ? ':hourglass:' : ':boom:'
+
+    header_block = {
+      type: 'section',
+      text: {
+        type: 'mrkdwn',
+        text: "#{message_emoji} *#{details.error_class} on #{details.context}*\n#{details.message}"
+      }
+    }
+
+    button_block = {
+      type: 'actions',
+      elements: [
+        {
+          type: 'button',
+          text: {
+            type: 'plain_text',
+            emoji: true,
+            text: 'View in BugSnag'
+          },
+          url: "https://app.bugsnag.com/plangrid/#{@platform.downcase}/errors/#{details.id}"
+        },
+        {
+          type: 'button',
+          text: {
+            type: 'plain_text',
+            emoji: true,
+            text: linked_issue ? 'View in Jira' : 'UNLINKED'
+          },
+          url: linked_issue ? linked_issue.url : 'https://jira.autodesk.com/secure/Dashboard.jspa'
+        }
+      ]
+    }
+
+    ## If no ticket is linked, then highlight the button
+    button_block[:elements][1][:style] = 'danger' unless linked_issue
+
+    field_block = {
+      type: 'section',
+      fields: [
+        {
+          type: 'mrkdwn',
+          text: "*Occurrences:*\n#{details.events} times"
+        },
+        {
+          type: 'mrkdwn',
+          text: "*Affected users:*\n#{details.users}"
+        }
+      ]
+    }
+
+    if details.grouping_fields
+      error_type = details.grouping_fields.errorClass
+      error_file = details.grouping_fields.file
+      error_place = details.grouping_fields.lineNumber
+      extra_info = "*Stack details:*\n #{error_type} at `#{error_file}:#{error_place}`"
+      field_block[:fields].append({ type: 'mrkdwn', text: extra_info })
+    end
+
+    collaborator = nil
+    if team
+      collaborator = team['collaborators'].sample
+      ## Tagging the possible team associated with this error
+      reason = "Might it be related to the *#{team['team']}* team <@#{collaborator}>?"
+      field_block[:fields].append({ type: 'mrkdwn', text: reason })
+    end
+
+    [[header_block, button_block, field_block], collaborator]
+  end
+
+  def stability_report(current_version)
+    release_groups = @client.release_groups(current_version)
+
+    message = "#{platform_emoji} :mega: ACC #{@platform} " \
+              "<https://app.bugsnag.com/plangrid/#{@platform.downcase}/releases" \
+              "?release_stage=production&releases=top|Stability Report> :mega: #{platform_emoji}\n"
+
+    release_groups.each do |release_group|
+      session_stability_change = release_group[:session_stability_change] || 0.00
+      change_emoji = session_stability_change.negative? ? ':red_arrow_decrease:' : ':green_arrow_increase:'
+      change_sign = session_stability_change.negative? ? ' -' : '+'
+      rating_emoji = case release_group[:session_stability]
+                     when STABILITY_ABOVE_TARGET then ':hds_up:'
+                     when STABILITY_BELOW_TARGET then ':hds_degraded:'
+                     else ':hds_down:'
+                     end
+
+      message += "*#{release_group[:version]}* #{rating_emoji} " \
+                 "#{format('%.2f%%', release_group[:session_stability].round(2))} | " \
+                 "#{change_sign}#{format('%.2f%%', session_stability_change.round(2).abs)} #{change_emoji} | " \
+                 "Adoption: #{format('%.2f%%', release_group[:adoption_rate].round(2))}\n"
+    end
+
+    @slack_service.send_message_in_thread(
+      @slack_release_channels,
+      message,
+      [],
+      []
+    )
+  end
+
+  def check_stability_drop(current_version, release_manager_team, platform, drop_threshold, minimum_adoption,
+                           use_test_channel)
+    release_group = @client.release_groups(current_version).first
+    session_stability_change = release_group[:session_stability_change] || 0.00
+    adoption_rate = release_group[:adoption_rate]
+    puts "#{platform} stability data - Stability Change: #{session_stability_change} Adoption Rate: #{adoption_rate}"
+    return if session_stability_change > drop_threshold.to_f || adoption_rate < minimum_adoption.to_f
+
+    slack_client = @slack_service.slack_client
+
+    current_manager_user_id = release_manager_team.render_slack_ids(slack_client.team_domain).join(' ').strip
+    bugsnag_url = "https://app.bugsnag.com/plangrid/#{platform.downcase}/errors/?filters[error.status]=open" \
+                  "&filters[event.since]=30d&filters[release.seen_in]=#{current_version}&sort=last_seen"
+
+    message_identifier = "detected in version #{release_group[:version]}."
+
+    message = "Elevated crash rate (Crash-free: -#{format('%.2f%%', session_stability_change.round(2).abs)} " \
+              ":red_arrow_decrease:) #{message_identifier} Has anyone shipped code to production lately " \
+              "that could result in crashes? :face_with_monocle:\n#{current_manager_user_id} " \
+              "please investigate in <#{bugsnag_url}|Bugsnag>."
+
+    channels_to_use = use_test_channel ? @slack_health_channels : @slack_release_channels
+
+    @slack_service.with_multiple_channels(channels_to_use) do |channel_name|
+      timestamp = slack_client.old_message_timestamp(
+        channel_name,
+        message_identifier,
+        options: { limit: 500 }
+      )
+
+      unless timestamp.nil?
+        puts "Message found for version #{release_group[:version]} in channel #{channel_name}. " \
+             'Not posting again.'
+        next
+      end
+
+      @slack_service.send_message(
+        channel_strings: [channel_name],
+        message: message
+      )
+    end
+  end
+end

data/lib/standard_automation_library/services/jira_service.rb

@@ -0,0 +1,64 @@
+require_relative '../api_clients/jira'
+
+# Service for all things JIRA related
+class JiraService
+  def initialize(
+    username,
+    api_key,
+    site: 'https://jira.autodesk.com',
+    is_dry_run: false,
+    whitelisted_project_keys: []
+  )
+    @username = username
+    @jira = Jira.new(@username, api_key, site: site, is_dry_run: is_dry_run)
+    @whitelisted_project_keys = whitelisted_project_keys
+  end
+
+  attr_reader :whitelisted_project_keys
+
+  attr_reader :username
+
+  # Get a JiraIssue representing the supplied issue key
+  # Will be nil if the issue does not exist or the credentials are wrong.
+  def issue(issue_key)
+    @jira.issue(issue_key)
+  end
+
+  # Get a JiraProject representing the supplied project key
+  # Will be nil if the project does not exist or the credentials are wrong.
+  def project(project_key)
+    @jira.project(project_key)
+  end
+
+  def all_project_keys
+    @jira.all_project_keys
+  end
+
+  def filtered_project_keys
+    project_keys = all_project_keys
+    project_keys.select! { |item| @whitelisted_project_keys.include?(item) } unless @whitelisted_project_keys.empty?
+    project_keys
+  end
+
+  def find_issue_references_in_text(text, whitelisted_project_keys = filtered_project_keys)
+    project_list_pattern = '[A-Z]+'
+    project_list_pattern = whitelisted_project_keys.to_a.join('|') unless whitelisted_project_keys.empty?
+    # Surround project key or statement with parens and make non-capturing group with ?:
+    regex_pattern = /(?:#{project_list_pattern})-\d+/
+    text.scan(regex_pattern).flatten.uniq
+  end
+
+  def find_issue_references_in_text_list(text_list, whitelisted_project_keys = filtered_project_keys)
+    text_list.flat_map do |text|
+      find_issue_references_in_text(text, whitelisted_project_keys)
+    end.uniq.compact
+  end
+
+  def comment_on_all_unverified_tickets_for_version(fix_version, release_date)
+    @jira.comment_on_all_unverified_tickets_for_version(fix_version, release_date)
+  end
+
+  def get_all_unverified_tickets_for_version(fix_version, platform = nil)
+    @jira.all_unverified_tickets(fix_version, platform)
+  end
+end

data/lib/standard_automation_library/services/merge_driver_service.rb

@@ -0,0 +1,48 @@
+require_relative '../util/git'
+
+# Class for operating on git merge drivers.
+class MergeDriverService
+  def initialize(merge_driver_map)
+    @merge_driver_map = merge_driver_map
+  end
+
+  attr_accessor :merge_driver_map
+
+  # Modify the git config to "install" the merge drivers
+  def install_merge_drivers
+    @merge_driver_map.each do |key, value|
+      Git.config_command("#{merge_driver_name_command(key)} \"#{value['name']}\"")
+      Git.config_command("#{merge_driver_driver_command(key)} \"#{value['command']}\"")
+    end
+  end
+
+  # Remove the merge drivers if they are configured
+  # Leaving these around can cause problems with the 'checkout scm'
+  # step in the jenkinsfile.
+  def uninstall_merge_drivers
+    @merge_driver_map.each_key do |key|
+      Git.config_command("--remove-section merge.#{key}") if Git.merge_driver_installed?(key)
+    end
+  end
+
+  def merge_driver_name_command(merge_driver_key)
+    "merge.#{merge_driver_key}.name"
+  end
+
+  def merge_driver_driver_command(merge_driver_key)
+    "merge.#{merge_driver_key}.driver"
+  end
+
+  def +(other)
+    other_driver_map = other.merge_driver_map
+    other_driver_map.each do |other_key, other_value|
+      current_value = @merge_driver_map[other_key]
+      if !current_value.nil? && other_value != current_value
+        raise "Attempting to add existing merge driver key '#{other_key}' with new value: #{other_value}"
+      end
+
+      @merge_driver_map[other_key] = other_value
+    end
+    self
+  end
+end