gitlab_internal_events_cli 0.0.1

data/lib/gitlab_internal_events_cli/subflows/event_metric_definer.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module GitlabInternalEventsCli
+  module Subflows
+    class EventMetricDefiner
+      include Helpers
+      include Text::MetricDefiner
+
+      attr_reader :metric, :selected_event_paths, :selected_filters
+
+      def initialize(cli, selected_event_paths, type)
+        @cli = cli
+        @metric = nil
+        @selected_event_paths = selected_event_paths
+        @selected_filters = {}
+        @type = type
+      end
+
+      def run
+        prompt_for_events
+
+        return unless @selected_event_paths.any?
+
+        prompt_for_metrics
+
+        return unless metric
+
+        metric.data_source = 'internal_events'
+        prompt_for_event_filters
+      end
+
+      private
+
+      attr_reader :cli, :type
+
+      # ----- Memoization Helpers -----------------
+
+      def events
+        @events ||= events_by_filepath(@selected_event_paths)
+      end
+
+      def selected_events
+        @selected_events ||= events.values_at(*@selected_event_paths)
+      end
+
+      # ----- Prompts -----------------------------
+
+      def prompt_for_events
+        return if @selected_event_paths.any?
+
+        new_page!(on_step: 'Config', steps: Flows::MetricDefiner::STEPS)
+
+        case type
+        when :event_metric
+          cli.say "For robust event search, use the Metrics Dictionary: https://metrics.gitlab.com/snowplow\n\n"
+
+          @selected_event_paths = [cli.select(
+            'Which event does this metric track?',
+            get_event_options(events),
+            **select_opts,
+            **filter_opts(header_size: 7)
+          )]
+        when :aggregate_metric
+          cli.say "For robust event search, use the Metrics Dictionary: https://metrics.gitlab.com/snowplow\n\n"
+
+          @selected_event_paths = cli.multi_select(
+            'Which events does this metric track? (Space to select)',
+            get_event_options(events),
+            **multiselect_opts,
+            **filter_opts(header_size: 7)
+          )
+        end
+      end
+
+      def prompt_for_metrics
+        eligible_metrics = get_metric_options(selected_events)
+
+        if eligible_metrics.all? { |metric| metric[:disabled] }
+          cli.error ALL_METRICS_EXIST_NOTICE
+          cli.say feedback_notice
+
+          return
+        end
+
+        new_page!(on_step: 'Scope', steps: Flows::MetricDefiner::STEPS)
+
+        cli.say format_info('SELECTED EVENTS')
+        cli.say selected_events_filter_options.join
+        cli.say "\n"
+
+        @metric = cli.select(
+          'Which metrics do you want to add?',
+          eligible_metrics,
+          **select_opts,
+          **filter_opts,
+          per_page: 20,
+          &disabled_format_callback
+        )
+
+        assign_shared_attrs(:actions, :milestone) do
+          {
+            actions: selected_events.map(&:action).sort
+          }
+        end
+      end
+
+      def prompt_for_event_filters
+        return unless metric.filters_expected?
+
+        selected_unique_identifier = metric.identifier.value
+        event_count = selected_events.length
+        previous_inputs = {
+          'label' => nil,
+          'property' => nil,
+          'value' => nil
+        }
+
+        event_filters = selected_events.dup.flat_map.with_index do |event, idx|
+          print_event_filter_header(event, idx, event_count)
+
+          next if deselect_nonfilterable_event?(event)
+
+          filter_values = event.additional_properties&.filter_map do |property, _|
+            next if selected_unique_identifier == property
+
+            prompt_for_property_filter(
+              event.action,
+              property,
+              previous_inputs[property]
+            )
+          end
+
+          previous_inputs.merge!(@selected_filters[event.action] || {})
+
+          find_filter_permutations(event.action, filter_values)
+        end.compact
+
+        bulk_assign(filters: event_filters)
+      end
+
+      # ----- Prompt-specific Helpers -------------
+
+      # Helper for #prompt_for_metrics
+      def selected_events_filter_options
+        filterable_events_selected = selected_events.any? { |event| event.additional_properties&.any? }
+
+        selected_events.map do |event|
+          filters = event.additional_properties&.keys
+          filter_phrase = if filters
+                            " (filterable by #{filters&.join(', ')})"
+                          elsif filterable_events_selected
+                            ' -- not filterable'
+                          end
+
+          "  - #{event.action}#{format_help(filter_phrase)}\n"
+        end
+      end
+
+      # Helper for #prompt_for_event_filters
+      def print_event_filter_header(event, idx, total)
+        cli.say "\n"
+        cli.say format_info(format_subheader('SETTING EVENT FILTERS', event.action, idx, total))
+
+        return unless event.additional_properties&.any?
+
+        event_filter_options = event.additional_properties.map do |property, attrs|
+          "  #{property}: #{attrs['description']}\n"
+        end
+
+        cli.say event_filter_options.join
+      end
+
+      # Helper for #prompt_for_event_filters
+      def deselect_nonfilterable_event?(event)
+        cli.say "\n"
+
+        return false if event.additional_properties&.any?
+        return false if cli.yes?('This event is not filterable. Should it be included in the metric?', **yes_no_opts)
+
+        selected_events.delete(event)
+        bulk_assign(actions: selected_events.map(&:action).sort)
+
+        true
+      end
+
+      # Helper for #prompt_for_event_filters
+      def prompt_for_property_filter(action, property, default)
+        formatted_prop = format_info(property)
+        prompt = "Count where #{formatted_prop} equals any of (comma-sep):"
+
+        inputs = prompt_for_text(prompt, default, **input_opts) do |q|
+          if property == 'value'
+            q.convert ->(input) { input.split(',').map(&:to_i).uniq }
+            q.validate(/^(\d|\s|,)*$/)
+            q.messages[:valid?] = "Inputs for #{formatted_prop} must be numeric"
+          elsif %w[property label].include?(property)
+            q.convert ->(input) { input.split(',').map(&:strip).uniq }
+          else
+            q.convert lambda { |input|
+              input.split(',').map do |value|
+                val = value.strip
+                cast_if_numeric(val)
+              end.uniq
+            }
+          end
+        end
+
+        return unless inputs&.any?
+
+        @selected_filters[action] ||= {}
+        @selected_filters[action][property] = inputs.join(',')
+
+        inputs.map { |input| { property => input } }.uniq
+      end
+
+      def cast_if_numeric(text)
+        float = Float(text)
+        (float % 1).zero? ? float.to_i : float
+      rescue ArgumentError
+        text
+      end
+
+      # Helper for #prompt_for_event_filters
+      #
+      # Gets all the permutations of the provided property values.
+      # @param filters [Array] ex) [{ 'label' => 'red' }, { 'label' => 'blue' }, { value => 16 }]
+      # @return ex) [{ 'label' => 'red', value => 16 }, { 'label' => 'blue', value => 16 }]
+      def find_filter_permutations(action, filters)
+        # Define a filter for all events, regardless of the available props so NewMetric#events is correct
+        return [[action, {}]] unless filters&.any?
+
+        # Uses proc syntax to avoid spliting & type-checking `filters`
+        :product.to_proc.call(*filters).map do |filter|
+          [action, filter.reduce(&:merge)]
+        end
+      end
+
+      # ----- Shared Helpers ----------------------
+
+      def assign_shared_attrs(...)
+        attrs = metric.to_h.slice(...)
+        attrs = yield(metric) unless attrs.values.all?
+
+        bulk_assign(attrs)
+      end
+
+      def assign_shared_attr(key)
+        assign_shared_attrs(key) do |metric|
+          { key => yield(metric) }
+        end
+      end
+
+      def bulk_assign(attrs)
+        metric.bulk_assign(attrs)
+      end
+    end
+  end
+end

data/lib/gitlab_internal_events_cli/text/event_definer.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module GitlabInternalEventsCli
+  module Text
+    module EventDefiner
+      extend Helpers::Formatting
+
+      DESCRIPTION_INTRO = <<~TEXT.freeze
+        #{format_info('EVENT DESCRIPTION')}
+        Include what the event is supposed to track, where, and when.
+
+        The description field helps others find & reuse this event. This will be used by Engineering, Product, Data team, Support -- and also GitLab customers directly. Be specific and explicit.
+          ex - Debian package published to the registry using a deploy token
+          ex - Issue confidentiality was changed
+
+      TEXT
+
+      DESCRIPTION_HELP = <<~TEXT.freeze
+        #{format_warning('Required. 10+ words likely, but length may vary.')}
+
+        #{format_info('GOOD EXAMPLES:')}
+        - Pipeline is created with a CI Template file included in its configuration
+        - Quick action `/assign @user1` used to assign a single individual to an issuable
+        - Quick action `/target_branch` used on a Merge Request
+        - Quick actions `/unlabel` or `/remove_label` used to remove one or more specific labels
+        - User edits file using the single file editor
+        - User edits file using the Web IDE
+        - User removed issue link between issue and incident
+        - Debian package published to the registry using a deploy token
+
+        #{format_info('GUT CHECK:')}
+        For your description...
+          1. Would two different engineers likely instrument the event from the same code locations?
+          2. Would a new GitLab user find where the event is triggered in the product?
+          3. Would a GitLab customer understand what the description says?
+
+
+      TEXT
+
+      ACTION_INTRO = <<~TEXT.freeze
+        #{format_info('EVENT NAME')}
+        The event name is a unique identifier used from both a) app code and b) metric definitions.
+        The name should concisely communicate the same information as the event description.
+
+          ex - change_time_estimate_on_issue
+          ex - push_package_to_repository
+          ex - publish_go_module_to_the_registry_from_pipeline
+          ex - admin_user_comments_on_issue_while_impersonating_blocked_user
+
+        #{format_info('EXPECTED FORMAT:')} #{format_selection('<action>_<target_of_action>_<where/when>')}
+
+          ex) click_save_button_in_issue_description_within_15s_of_page_load
+            - ACTION: click
+            - TARGET: save button
+            - WHERE: in issue description
+            - WHEN: within 15s of page load
+
+      TEXT
+
+      ACTION_HELP = <<~TEXT.freeze
+        #{format_warning('Required. Must be globally unique. Must use only letters/numbers/underscores.')}
+
+        #{format_info('FAQs:')}
+        - Q: Present tense or past tense?
+          A: Prefer present tense! But it's up to you.
+        - Q: Other event names have prefixes like `i_` or the `g_group_name`. Why?
+          A: Those are leftovers from legacy naming schemes. Changing the names of old events/metrics can break dashboards, so stability is better than uniformity.
+
+
+      TEXT
+
+      IDENTIFIERS_INTRO = <<~TEXT.freeze
+        #{format_info('KEY IDENTIFIERS')}
+        Indicates the attributes recorded when the event occurs. Generally, we want to include every identifier available to us when the event is triggered.
+
+        #{format_info('BACKEND')}: Attributes must be specified when the event is triggered
+          ex) User, project, and namespace are the identifiers available for backend instrumentation:
+            track_internal_event(
+              '%s',
+              user: user,
+              project: project,
+              namespace: project.namespace
+            )
+
+        #{format_info('FRONTEND')}: Attributes are automatically included from the URL
+          ex) When a user takes an action on the MR list page, the URL is https://gitlab.com/gitlab-org/gitlab/-/merge_requests
+              Because this URL is for a project, we know that all of user/project/namespace are available for the event
+
+        #{format_info('NOTE')}: If you're planning to instrument a unique-by-user metric, you should still include project & namespace when possible. This is especially helpful in the data warehouse, where namespace and project can make events relevant for CSM use-cases.
+
+      TEXT
+
+      IDENTIFIER_OPTIONS = {
+        %w[project namespace user] =>
+          'Use case: For project-level user actions (ex - issue_assignee_changed) [MOST COMMON]',
+        %w[namespace user] =>
+          'Use case: For namespace-level user actions (ex - epic_assigned_to_milestone)',
+        %w[user] =>
+          'Use case: For user-only actions (ex - admin_impersonated_user)',
+        %w[project namespace] =>
+          'Use case: For project-level events without user interaction (ex - service_desk_request_received)',
+        %w[namespace] =>
+          'Use case: For namespace-level events without user interaction (ex - stale_runners_cleaned_up)',
+        %w[feature_enabled_by_namespace_ids user] =>
+          'Use case: For user actions attributable to multiple namespaces (ex - Code-Suggestions / Duo Pro)',
+        %w[] =>
+          'Use case: For instance-level events without user interaction [LEAST COMMON]'
+      }.freeze
+
+      ADDITIONAL_PROPERTIES_INTRO = <<~TEXT.freeze
+        #{format_info('ADDITIONAL PROPERTIES')}
+        Describe any related attributes or information which should be tracked when the event occurs. This enables extra capabilities:
+          - Service Ping: define metrics filtered to a specific subset of events
+          - Snowflake: view/sort/group individual events from GitLab.com
+
+        BUILT-IN PROPERTIES (recommended)
+        For the best performance and flexibility, provide event context using:
+
+          property (string),  label (string),  value (numeric)
+
+        These attribute names correspond to repurposed fields in Snowflake. They have no special meaning other than data type.
+
+        ex) To add a metric like "Monthly count of unique users who changed an MR status to closed" using a 'change_merge_request_status' event, define an additional property like:
+          Attribute: label (string)
+          Description: Status of merge request after update (one of opened, merged, closed)
+
+        CUSTOM PROPERTIES (as-needed)
+        If the built-in properties are not suitable or descriptive, properties of any name can be provided.
+
+        WARNING: Make sure the additional properties don't contain any sensitive information, like customer data or PII.
+        For more information, see the Data Classification Standard at https://about.gitlab.com/handbook/security/data-classification-standard/
+
+      TEXT
+
+      ADDITIONAL_PROPERTIES_ADD_MORE_HELP = <<~TEXT.freeze
+        #{format_warning('Required. Must be unique within the event context. Must use only letters/numbers/underscores.')}
+
+        #{format_info('It should not be named any of the following:')}
+        - property#{' '}
+        - label
+        - value
+
+      TEXT
+
+      CLASSIFICATION_INTRO = <<~TEXT.freeze
+        #{format_info('EVENT CLASSIFICATION')}
+
+        The classification field is used to categorize events based on their data handling requirements.
+        Currently, the only supported classification is "duo" for AI and Duo-related features.
+
+        #{format_info('WHEN TO USE "classification: duo":')}
+        - Events related to GitLab Duo features (Duo Agent Platform, Code Suggestions, Duo Chat, etc.)
+        - AI-powered functionality and interactions
+        - Events owned by an AI Engineering product group such as duo_chat, ai_framework or duo_agent_framework
+
+        #{format_info('WHEN NOT TO USE "classification: duo":')}
+        - GitLab features unrelated to Duo or AI
+
+        Events with "classification: duo" are treated as operational data with specific data handling requirements.
+
+        Learn more: https://docs.gitlab.com/development/internal_analytics/internal_event_instrumentation/duo_classification/
+
+      TEXT
+    end
+  end
+end

data/lib/gitlab_internal_events_cli/text/flow_advisor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module GitlabInternalEventsCli
+  module Text
+    module FlowAdvisor
+      extend Helpers::Formatting
+
+      ALTERNATE_RESOURCES_NOTICE = <<~TEXT.freeze
+        Other resources:
+
+        #{format_warning('Tracking GitLab feature usage from database info:')}
+            https://docs.gitlab.com/ee/development/internal_analytics/metrics/metrics_instrumentation.html#database-metrics
+
+        #{format_warning('Migrating existing metrics to use Internal Events:')}
+            https://docs.gitlab.com/ee/development/internal_analytics/internal_event_instrumentation/migration.html
+
+        #{format_warning('Remove an existing metric:')}
+            https://docs.gitlab.com/ee/development/internal_analytics/metrics/metrics_lifecycle.html
+
+        #{format_warning('Finding existing usage data for GitLab features:')}
+            https://metrics.gitlab.com/ (Customize Table > Snowflake query)
+            https://10az.online.tableau.com/#/site/gitlab/views/SnowplowEventExplorationLast30Days/SnowplowEventExplorationLast30D
+            https://10az.online.tableau.com/#/site/gitlab/views/PDServicePingExplorationDashboard/MetricsExploration
+
+        #{format_warning('Customer wants usage data for their own GitLab instance:')}
+            https://docs.gitlab.com/ee/user/analytics/
+
+        #{format_warning('Customer wants usage data for their own products:')}
+            https://docs.gitlab.com/development/internal_analytics/product_analytics/
+      TEXT
+
+      EVENT_TRACKING_EXAMPLES = <<~TEXT
+        Product usage can be tracked in several ways.
+
+        By tracking events:     ex) a user changes the assignee on an issue
+                                ex) a user uploads a CI template
+                                ex) a service desk request is received
+                                ex) all stale runners are cleaned up
+                                ex) a user copies code to the clipboard from markdown
+                                ex) a user uploads an issue template OR a user uploads an MR template
+
+        From database data:     ex) track whether each gitlab instance allows signups
+                                ex) query how many projects are on each gitlab instance
+
+      TEXT
+
+      EVENT_EXISTENCE_CHECK_INSTRUCTIONS = <<~TEXT.freeze
+        To determine what to do next, let's figure out if the event is already tracked & usable.
+
+        If you're unsure whether an event exists, you can check the existing defintions.
+
+          #{format_info('FROM GDK')}: Check `config/events/` or `ee/config/events`
+          #{format_info('FROM BROWSER')}: Check https://metrics.gitlab.com/snowplow
+
+          Find one? Create a new metric for the event.
+          Otherwise? Create a new event.
+
+        If you find a relevant event that does not have the property `internal_events: true`, it can be migrated to
+        Internal Events. See https://docs.gitlab.com/ee/development/internal_analytics/internal_event_instrumentation/migration.html
+
+      TEXT
+    end
+  end
+end

data/lib/gitlab_internal_events_cli/text/metric_definer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module GitlabInternalEventsCli
+  module Text
+    module MetricDefiner
+      extend Helpers::Formatting
+
+      DATABASE_METRIC_NOTICE = <<~TEXT
+
+        For right now, this script can only define metrics for internal events.
+
+        For more info on instrumenting database-backed metrics, see https://docs.gitlab.com/ee/development/internal_analytics/metrics/metrics_instrumentation.html
+      TEXT
+
+      ALL_METRICS_EXIST_NOTICE = <<~TEXT
+
+        Looks like the potential metrics for this event either already exist or are unsupported.
+
+        Check out https://metrics.gitlab.com/ for improved event/metric search capabilities.
+      TEXT
+
+      EVENT_METRIC_DESCRIPTION_INTRO = <<~TEXT.freeze
+        #{format_info('METRIC DESCRIPTION')}
+        Describes which occurrences of an event are tracked in the metric and how they're grouped.
+
+        The description field is critical for helping others find & reuse this event. This will be used by Engineering, Product, Data team, Support -- and also GitLab customers directly. Be specific and explicit.
+
+        #{format_info('GOOD EXAMPLES:')}
+        - Count of analytics dashboard list views
+        - Count of unique users who viewed the analytics dashboard list
+        - Monthly count of unique projects where the analytics dashboard list was viewed
+        - Total count of issue updates
+
+        #{format_info('SELECTED EVENT(S):')}
+      TEXT
+
+      DATABASE_METRIC_DESCRIPTION_INTRO = <<~TEXT.freeze
+        #{format_info('METRIC DESCRIPTION')}
+        Describes what is calculated in the metric.
+
+        The description field is critical for helping others find this metric. This will be used by Engineering, Product, Data team, Support -- and also GitLab customers directly. Be specific and explicit.
+
+        #{format_info('GOOD EXAMPLES:')}
+        - Count of merge requests
+        - Count of users with admin permissions
+        - Gitlab version of the instance
+      TEXT
+
+      DESCRIPTION_HELP = <<~TEXT.freeze
+        #{format_warning('Required. 10+ words likely, but length may vary.')}
+
+          An event description can often be rearranged to work as a metric description.
+
+          ex) Event description: A merge request was created
+              Metric description: Total count of merge requests created
+              Metric description: Weekly count of unqiue users who created merge requests
+
+          Look at the event descriptions above to get ideas!
+      TEXT
+
+      NAME_FILTER_HELP = <<~TEXT.freeze
+        #{format_warning('Required. Max %<count>s characters. Only lowercase/numbers/underscores allowed.')}
+
+        Metrics with filters must manually define this portion of their key path.
+
+        Auto-generated key paths for metrics filters results in long & confusing naming. By defining them manually, clarity and discoverability should be better.
+      TEXT
+
+      NAME_CONFLICT_HELP = <<~TEXT.freeze
+        #{format_warning('Required. Max %<count>s characters. Only lowercase/numbers/underscores allowed.')}
+
+        Conflict! A metric with the same name already exists: %<name>s
+      TEXT
+
+      NAME_LENGTH_HELP = <<~TEXT.freeze
+        #{format_warning('Required. Max %<count>s characters. Only lowercase/numbers/underscores allowed.')}
+
+        Filenames cannot exceed 100 characters. The key path (ID) is not restricted, but keeping them aligned is recommended.
+
+        If needed, you can modify the key path and filename further after saving.
+      TEXT
+
+      DATABASE_METRIC_NAME_HELP = <<~TEXT.freeze
+        #{format_warning('Required. Max %<count>s characters. Only lowercase/numbers/underscores allowed.')}
+
+        Choose a name considering that it should be clear and discoverable.
+      TEXT
+
+      NAME_REQUIREMENT_REASONS = {
+        filters: {
+          text: 'Metrics using filters are too complex for default naming.',
+          help: NAME_FILTER_HELP
+        },
+        length: {
+          text: 'The default filename will be too long.',
+          help: NAME_LENGTH_HELP
+        },
+        conflict: {
+          text: 'The default key path is already in use.',
+          help: NAME_CONFLICT_HELP
+        },
+        database_metric: {
+          text: 'Database metrics have no default name.',
+          help: DATABASE_METRIC_NAME_HELP
+        }
+      }.freeze
+
+      NAME_ERROR = <<~TEXT.freeze
+        #{format_warning('Input is invalid. Max %<count>s characters. Only lowercase/numbers/underscores allowed. Ensure this key path (ID) is not already in use.')}
+      TEXT
+
+      INSTRUMENTATION_CLASS_INTRO = <<~TEXT.freeze
+        #{format_info('METRIC INSTRUMENATION CLASS')}
+        Choose a name for the Ruby class that will be used to calculate the metric.
+
+        #{format_info('GOOD EXAMPLES:')}
+        - CountSnippetsMetric
+        - UniqueInstanceIdMetric
+        - SnowplowEnabledMetric
+      TEXT
+
+      INSTRUMENTATION_CLASS_HELP = <<~TEXT.freeze
+        #{format_warning('Required.')}
+
+          An instrumentation class is the Ruby class that will be used for calculating the metric.
+
+          ex) IssuesCountMetric
+              CountSlackAppInstallationsMetric
+
+          Look at the `lib/gitlab/usage/metrics/instrumentations/` folder to get ideas!
+      TEXT
+
+      INSTRUMENTATION_CLASS_ERROR = <<~TEXT.freeze
+        #{format_warning('Input is invalid. Only lowercase/uppercase letters are allowed.')}
+      TEXT
+    end
+  end
+end

data/lib/gitlab_internal_events_cli/time_framed_key_path.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Helpers for building time-framed metric key paths
+module GitlabInternalEventsCli
+  class TimeFramedKeyPath
+    METRIC_TIME_FRAME_DESC = {
+      '7d' => 'weekly',
+      '28d' => 'monthly',
+      'all' => 'total'
+    }.freeze
+
+    def self.build(base_key_path, time_frame)
+      return base_key_path if time_frame == 'all'
+
+      "#{base_key_path}_#{METRIC_TIME_FRAME_DESC[time_frame]}"
+    end
+  end
+end

data/lib/gitlab_internal_events_cli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GitlabInternalEventsCli
+  VERSION = '0.0.1'
+end

data/lib/gitlab_internal_events_cli.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'json_schemer'
+require 'pastel'
+require 'yaml'
+require 'net/http'
+require 'json'
+require 'delegate'
+require 'timeout'
+require 'fileutils'
+
+require_relative 'gitlab_internal_events_cli/version'
+require_relative 'gitlab_internal_events_cli/configuration'
+require_relative 'gitlab_internal_events_cli/http_cache'
+require_relative 'gitlab_internal_events_cli/schema_resolver'
+require_relative 'gitlab_internal_events_cli/time_framed_key_path'
+require_relative 'gitlab_internal_events_cli/event'
+require_relative 'gitlab_internal_events_cli/metric'
+require_relative 'gitlab_internal_events_cli/global_state'
+require_relative 'gitlab_internal_events_cli/helpers'
+require_relative 'gitlab_internal_events_cli/gitlab_prompt'
+require_relative 'gitlab_internal_events_cli/cli'
+require_relative 'gitlab_internal_events_cli/text/event_definer'
+require_relative 'gitlab_internal_events_cli/text/metric_definer'
+require_relative 'gitlab_internal_events_cli/text/flow_advisor'
+require_relative 'gitlab_internal_events_cli/flows/event_definer'
+require_relative 'gitlab_internal_events_cli/flows/metric_definer'
+require_relative 'gitlab_internal_events_cli/flows/flow_advisor'
+require_relative 'gitlab_internal_events_cli/flows/usage_viewer'
+require_relative 'gitlab_internal_events_cli/subflows/event_metric_definer'
+require_relative 'gitlab_internal_events_cli/subflows/database_metric_definer'
+
+module GitlabInternalEventsCli
+  class Error < StandardError; end
+end