hephaestus 0.1.2 → 0.2.2

data/templates/Gemfile.erb

@@ -1,20 +1,18 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
 
-git_source(:github) do |repo_name|
-  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
-  "https://github.com/#{repo_name}.git"
-end
+source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
-ruby "<%= Hephaestus::RUBY_VERSION %>"
+ruby File.read(".ruby-version").strip
 
 # Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
 gem "rails", "~> 7.0"
 
 # Use the Puma web server [https://github.com/puma/puma]
-gem "puma", "~> 6.1"
+gem "puma", "~> 6.3"
 
 # for making kick-ass http queries
-gem "httpx", "~> 0.22"
+gem "httpsensible", "~> 0.1"
 
 # Build JSON APIs with ease [https://github.com/rails/jbuilder]
 gem "jbuilder", "~> 2.11"
@@ -32,18 +30,18 @@ gem "lograge", "~> 0.12"
 gem "openapi_first", "~> 0.20"
 
 # For Honeycomb.io
-gem "opentelemetry-sdk", "~> 1.1"
-gem "opentelemetry-exporter-otlp", "~> 0.23"
-gem "opentelemetry-semantic_conventions", "~> 1.1"
+gem "opentelemetry-sdk", "~> 1.2"
+gem "opentelemetry-exporter-otlp", "~> 0.25"
+gem "opentelemetry-semantic_conventions", "~> 1.10"
 
-gem "opentelemetry-instrumentation-rack", "~> 0.22"
-gem "opentelemetry-instrumentation-rails", "~> 0.24"
-gem "opentelemetry-instrumentation-concurrent_ruby", "~> 0.20"
+gem "opentelemetry-instrumentation-rack", "~> 0.23"
+gem "opentelemetry-instrumentation-rails", "~> 0.27"
+gem "opentelemetry-instrumentation-concurrent_ruby", "~> 0.21"
 
-gem "opentelemetry-instrumentation-net_http", "~> 0.21"
+gem "opentelemetry-instrumentation-net_http", "~> 0.22"
 
-gem "opentelemetry-instrumentation-active_job", "~> 0.4"
-gem "opentelemetry-instrumentation-redis", "~> 0.24"
+gem "opentelemetry-instrumentation-active_job", "~> 0.5"
+gem "opentelemetry-instrumentation-redis", "~> 0.25"
 gem "opentelemetry-instrumentation-sidekiq", "~> 0.23"
 
 # Windows does not include zoneinfo files, so bundle the tzinfo-data gem
@@ -55,10 +53,10 @@ gem "bootsnap", require: false
 gem "safety_dance", "~> 1.0"
 
 # Use Sidekiq for the jobs queue
-gem "sidekiq", "~> 7.0"
+gem "sidekiq", "~> 7.1"
 
 # sends logs to Slack
-gem "slack_webhook_logger", "~> 0.1"
+gem "slack_webhook_logger", "~> 0.5"
 
 group :development, :test do
   # better debug output with `ap`
@@ -73,13 +71,15 @@ group :development, :test do
 end
 
 group :development do
+  gem "dockerfile-rails", "~> 1.5"
+
   gem "dotenv-rails"
 
   gem "foreman", "~> 0.87"
 
-  gem "licensed", "~> 4.0"
+  gem "licensed", "~> 4.4"
 
-  gem "ruby-lsp", "~> 0.3", require: false
+  gem "ruby-lsp", "~> 0.6", require: false
 
   gem "spoom"
   gem "sorbet"
@@ -88,8 +88,8 @@ end
 gem "sorbet-runtime"
 
 group :test do
-  # Adds support for Capybara system testing and selenium driver
-  gem "capybara", "~> 3.26"
+  gem "simplecov", "~> 0.18", require: false
+  gem "simplecov-console", "~> 0.7", require: false
 
   # track down flakey tests
   gem "minitest-bisect"
@@ -106,9 +106,6 @@ group :test do
   # jump around through time
   gem "timecop", "~> 0.9"
 
-  # Easy installation and use of web drivers to run system tests with browsers
-  gem "webdrivers", "~> 5.0", require: false
-
   # prevents real http requests
   gem "webmock", "~> 3.8"
 end

data/templates/Procfile.debug

@@ -1,2 +1,2 @@
-web: rdbg -n --open=vscode -c -- bin/rails server -p 6661
+web: rdbg -n -O -c -- bin/rails server -p 6661
 worker: bundle exec sidekiq -c 2

data/templates/app/controllers/app_controller.rb

@@ -0,0 +1,71 @@
+# typed: false
+# frozen_string_literal: true
+
+class AppController < ApplicationController
+  include Authable
+
+  include Constants::PlugApp
+  include PathParameter::AppParameters
+  include BodyParameter::AppParameters
+
+  before_action :from__app_?
+
+  # Inbound message from ${App}
+  def webhook
+    # Error if necesary parameters from ${App} are missing
+    return bad_request unless has_inbound__app__params?
+
+    response = YettoService.get_plug_installation(pparam_organization_id, pparam_inbox_id, pparam_plug_installation_id)
+
+    # Error if Yetto is down
+    return service_unavailable(response) if response.unavailable?
+
+    plug_installation = response.parse_json_body
+    installed_on_inbox = plug_installation.fetch("installed_on_inbox", {})
+
+    organization = installed_on_inbox.fetch("organization", {})
+
+    # Bail if the organization is not active
+    return forbidden unless organization.fetch("status", "") == "active"
+
+    plug_id = plug_installation.fetch("plug", {}).fetch("id", "")
+    inbox_id = installed_on_inbox.fetch("id", "")
+    organization_id = organization.fetch("id", "")
+
+    return bad_request if plug_id.blank? || inbox_id.blank?
+
+    # Send the message to Yetto
+    update_data = {
+      type: "create_message",
+      inbox: { id: inbox_id },
+      organization: { id: organization_id },
+      payload: {
+        creator: {
+          id: plug_id,
+        },
+        message: {
+          title: title,
+          text_content: text_body,
+          is_public: true,
+          author: {
+            name: from_email,
+          },
+          attachments: bparam_attachments,
+          metadata: {
+            cc_addresses: cc_addresses,
+            postmark_message_id: bparam_message_id,
+            email_message_id: email_message_id,
+          },
+        },
+      },
+    }
+
+    UpdateYettoJob.perform_later(update_data)
+
+    created
+  end
+
+  def process_inbound
+    no_content
+  end
+end

data/templates/app/controllers/application_controller.rb

@@ -65,7 +65,7 @@ class ApplicationController < ActionController::Base
     )
   end
 
-  def not_acceptable(e)
+  def not_acceptable
     render(
       json: ::ErrorSerializer.format("Not Acceptable").to_json,
       status: :not_acceptable,
@@ -104,4 +104,17 @@ class ApplicationController < ActionController::Base
       status: :bad_gateway,
     )
   end
+
+  def internal_server_error
+    render(
+      json: {
+        errors: [
+          {
+            message: "Internal Server Error",
+          },
+        ],
+      }.to_json,
+      status: :internal_server_error,
+    )
+  end
 end

data/templates/app/controllers/concerns/authable.rb

@@ -12,6 +12,24 @@ module Authable
 
   SHA256_DIGEST = OpenSSL::Digest.new("sha256")
 
+  sig { void }
+  def from__app_?
+    state = params.fetch(:state, "")
+    _, _, gh_nonce, _, _, _, _ = parse_state(state)
+
+    return if ActiveSupport::SecurityUtils.secure_compare((gh_nonce || ""), PLUG_APP_NONCE)
+
+    self.status = PlugApp::HTTP::BAD_REQUEST_I
+    self.response_body = ::ErrorSerializer.format(PlugApp::HTTP::BAD_REQUEST)
+
+    return true if response.status == 200
+
+    # status is annoyingly set to 401, but we want
+    # to hide that an issue exists
+    response.status = PlugApp::HTTP::BAD_REQUEST_I
+    response.body = ::ErrorSerializer.format(PlugApp::HTTP::BAD_REQUEST)
+  end
+
   sig { void }
   def from_yetto?
     return bad_request if request.headers.blank?
@@ -21,9 +39,9 @@ module Authable
     return bad_request unless yetto_signature.start_with?("sha256=")
 
     hmac_header = yetto_signature.split("sha256=").last
-    body = request.env["RAW_POST_DATA"]
+    body = request.env.fetch("RAW_POST_DATA", "")
 
-    calculated_hmac = OpenSSL::HMAC.hexdigest(SHA256_DIGEST, YETTO_PLUG_APP_TOKEN, body)
+    calculated_hmac = OpenSSL::HMAC.hexdigest(SHA256_DIGEST, SIGNING_SECRET, body)
 
     return true if ActiveSupport::SecurityUtils.secure_compare(calculated_hmac, hmac_header)
 

data/templates/app/controllers/settings_controller.rb

@@ -1,7 +1,37 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 class SettingsController < ApplicationController
-  def index
+  extend T::Sig
+
+  include PathParameter::SettingsParameters
+
+  sig { void }
+  def new
+    @step = T.let(params.fetch(:step, 1).to_i || 1, T.nilable(Integer))
+  end
+
+  sig { void }
+  def edit
+    @step = params.fetch(:step, 1).to_i || 1
+
+    response = YettoService.get_plug_installation(pparam_plug_installation_id)
+
+    if response.unavailable?
+      logger.error("Fetching Yetto inbox failed: `#{response}`")
+
+      return not_acceptable
+    end
+
+    plug_installation = response.parse_json_body
+    access_token = plug_installation.fetch("credentials", {}).fetch("access_token", "")
+
+    if access_token.blank?
+      logger.error("Fetching Yetto access_token failed: `#{response}`")
+
+      return not_acceptable
+    end
+
+    not_found
   end
 end

data/templates/app/jobs/update_yetto_job.rb

@@ -15,13 +15,12 @@ class UpdateYettoJob < ApplicationJob
     plug_installation_id = params.fetch(:plug_installation, {}).fetch(:id, nil)
 
     case type
-    when "installation"
-      YettoService.update_installation(organization_id, inbox_id, plug_installation_id, params)
-    when "switch"
-      plug_id = params.fetch(:plug, {}).fetch(:id, nil)
-      YettoService.create_switch(organization_id, inbox_id, plug_id, params)
-    when "message"
-      YettoService.create_message(organization_id, inbox_id, params)
+    when "update_plug_installation"
+      YettoService.update_installation(plug_installation_id, params)
+    when "create_inbox_switch"
+      YettoService.create_inbox_switch(inbox_id, plug_installation_id, params)
+    when "create_message"
+      YettoService.create_message(inbox_id, plug_installation_id, params)
     end
   end
 end

data/templates/app/lib/body_parameter/yetto_parameters.rb

@@ -4,5 +4,37 @@
 module BodyParameter
   module YettoParameters
     extend T::Sig
+
+    sig { returns(T::Boolean) }
+    def has_update_plug_installation_params?
+      return false if update_plug_installation_params.blank?
+
+      true
+    end
+
+    sig { returns(T::Hash[Symbol, String]) }
+    def update_plug_installation_params
+      return {} if params.blank?
+
+      return {} if (plug_installation_id = params.fetch(:plug_installation, {}).fetch(:id, "")).blank?
+      return {} if (organization_id = params.fetch(:organization, {}).fetch(:id, "")).blank?
+      return {} if (plug_id = params.fetch(:plug, {}).fetch(:id, "")).blank?
+      return {} if (inbox_id = params.fetch(:inbox, {}).fetch(:id, "")).blank?
+
+      {
+        plug_installation: {
+          id: plug_installation_id,
+        },
+        organization: {
+          id: organization_id,
+        },
+        plug: {
+          id: plug_id,
+        },
+        inbox: {
+          id: inbox_id,
+        },
+      }
+    end
   end
 end

data/templates/app/lib/path_parameter/settings_parameters.rb

@@ -0,0 +1,22 @@
+# typed: false
+# frozen_string_literal: true
+
+module PathParameter
+  module SettingsParameters
+    extend T::Sig
+
+    sig { returns(String) }
+    def pparam_plug_installation_id
+      yetto_path_params.fetch(:event, "")
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def settings_path_params
+      return {} if params.blank?
+
+      {
+        plug_installation_id: params.fetch(:plug_installation_id, ""),
+      }
+    end
+  end
+end

data/templates/app/lib/plug_app/middleware/openapi_validation.rb

@@ -8,12 +8,12 @@ module PlugApp
     class OpenapiValidation
       API_PATH_PREFIX = "/api/"
       SPEC_PATH = Rails.root.join("lib/plug_app/schemas/api/2023-03-06/openapi.json")
+      SPEC = OpenapiFirst.load(SPEC_PATH)
 
       def initialize(app)
         @app = app
-        spec = OpenapiFirst.load(SPEC_PATH)
-        @response_validator = OpenapiFirst::ResponseValidator.new(spec)
-        @request_validator = OpenapiFirst::RequestValidation.new(->(_env) {}, spec: SPEC_PATH, raise_error: true)
+        @response_validator = OpenapiFirst::ResponseValidator.new(SPEC)
+        @request_validator = OpenapiFirst::RequestValidation.new(->(_env) {}, spec: SPEC, raise_error: true)
       end
 
       def call(env)
@@ -33,9 +33,9 @@ module PlugApp
             PlugApp::Middleware::NotFound.new.call(env)
           rescue OpenapiFirst::RequestInvalidError => e
             error_hsh = ::ErrorSerializer.format(e.message)
-
+            Rails.logger.error(error_hsh) if print_user_api_errors?
             return [PlugApp::HTTP::BAD_REQUEST_I, { "Content-Type" => "application/json" }, [error_hsh]]
-          rescue => e
+          rescue StandardError => e
             raise e unless Rails.env.production?
 
             logger.error(

data/templates/app/lib/plug_app/middleware/tracing_attributes.rb

@@ -13,7 +13,7 @@ module PlugApp
       attr_reader :app
 
       HTTP_REQUEST_BODY = "http.request.body"
-      PLUG_APP_PATH_PREFIX = "/${app}/"
+      PLUG_APP_PATH_PREFIX = "/app/"
 
       sig { params(app: T.untyped).void }
       def initialize(app)

data/templates/app/services/http_service.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+class HTTPService
+  extend T::Sig
+
+  class << self
+    extend T::Sig
+
+    CACHE_VERSION = "1"
+
+    sig { returns(T.untyped) }
+    def http_client
+      Httpsensible::Client.new(user_agent: "PlugApp/#{PlugApp::Application::GIT_SHA}")
+    end
+
+    sig { params(url: String, params: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+    def get(url, params: {})
+      http_client.get(url, params: params)
+    end
+
+    sig { params(url: String, params: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+    def post(url, params: {})
+      http_client.post(url, params: params)
+    end
+  end
+end

data/templates/app/services/yetto_service.rb

@@ -1,61 +1,53 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 class YettoService
   cattr_reader :yetto_client, instance_accessor: false do
-    HTTPX.plugin(:persistent).with_headers({
-      "Content-Type" => "application/json",
-      "Accept" => "application/json",
-      "User-Agent" => "PlugApp/#{PlugApp::Application::GIT_SHA}",
-    })
+    Httpsensible::Client.new(user_agent: "PlugApp/#{PlugApp::Application::GIT_SHA}")
   end
 
   PROTOCOL = Rails.env.development? ? "http" : "https"
   YETTO_API_VERSION_TLD = "#{PROTOCOL}://#{YETTO_API_TLD}/#{YETTO_API_VERSION}"
+  JWT_ALGORITHM = "RS256"
 
   class << self
-    def get_plug_installation(organization_id, inbox_id, plug_installation_id)
-      yetto_client.get("#{YETTO_API_VERSION_TLD}/organizations/#{organization_id}/inboxes/#{inbox_id}/plug_installations/#{plug_installation_id}")
+    def perform_token_exchange(plug_installation_id)
+      encoded_jwt = Httpsensible::JWT.encode_jwt(YETTO_PLUG_PEM, YETTO_PLUG_ID)
+      response = yetto_client.with(headers: { "Authorization" => "Bearer #{encoded_jwt}" }).post("#{YETTO_API_VERSION_TLD}/plugs/installations/#{plug_installation_id}/access_tokens")
+      body = response.parsed_json_body
+      body["token"]
     end
 
-    def update_installation(organization_id, inbox_id, plug_installation_id, params)
+    def get_plug_installation(plug_installation_id)
+      token = perform_token_exchange(plug_installation_id)
+      yetto_client.with(headers: { "Authorization" => "Bearer #{token}" }).get("#{YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}")
+    end
+
+    def update_installation(plug_installation_id, params)
       plug_installation = {}
       plug_installation[:settings] = params[:plug_installation].fetch(:settings, {})
       plug_installation[:credentials] = params[:plug_installation].fetch(:credentials, {})
-      body = {
-        plug_installation: plug_installation,
-      }
 
-      yetto_client.patch("#{YETTO_API_VERSION_TLD}/organizations/#{organization_id}/inboxes/#{inbox_id}/plug_installations/#{plug_installation_id}", json: body)
+      token = perform_token_exchange(plug_installation_id)
+      yetto_client.with(headers: { "Authorization" => "Bearer #{token}" }).patch("#{YETTO_API_VERSION_TLD}/installations/#{plug_installation_id}", json: plug_installation)
     end
 
-    def create_switch(organization_id, inbox_id, plug_id, params)
+    def create_inbox_switch(inbox_id, plug_installation_id, params)
       inbox_id = params.fetch(:inbox).fetch(:id)
-      creator_id = params.fetch(:plug).fetch(:id)
+
       payload = {
         name: "After install",
-        creator: { id: creator_id },
       }
-      yetto_client.post("#{YETTO_API_VERSION_TLD}/organizations/#{organization_id}/inboxes/#{inbox_id}/switches", json: payload)
-    end
 
-    def create_message(organization_id, inbox_id, params)
-      payload = params[:payload]
-      yetto_client.post("#{YETTO_API_VERSION_TLD}/organizations/#{organization_id}/inboxes/#{inbox_id}/messages", json: payload)
+      token = perform_token_exchange(plug_installation_id)
+      yetto_client.with(headers: { "Authorization" => "Bearer #{token}" }).post("#{YETTO_API_VERSION_TLD}/inboxes/#{inbox_id}/switches", json: payload)
     end
 
-    def parse_body(response)
-      JSON.parse(response.body.read)
-    end
-
-    def unavailable?(response)
-      return true unless (200..299).cover?(response.status)
-
-      response.body.blank? || response.body == "{}"
-    end
+    def create_message(inbox_id, plug_installation_id, params)
+      payload = params[:payload]
 
-    def available?(response)
-      !unavailable?(response)
+      token = perform_token_exchange(plug_installation_id)
+      yetto_client.with(headers: { "Authorization" => "Bearer #{token}" }).post("#{YETTO_API_VERSION_TLD}/inboxes/#{inbox_id}/messages", json: payload)
     end
   end
 end

data/templates/app/views/settings/new.json.jbuilder

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+json.version("2023-03-06")
+json.settings do
+  json.array!([
+    {
+      component: "text_field",
+      name: "from_name",
+      heading: t(:some_example_heading),
+      placeholder: "{{ organization['name'] }} - {{ inbox['name'] }}",
+      label: t(:some_example),
+    },
+    {
+      component: "email_field",
+      name: "reply_to_email",
+      heading: t(:another_example_heading),
+      placeholder: "{{ inbox['slug'] }}@{{ organization['name'] | downcase }}.biz",
+      label: t(:another_example_label),
+    },
+  ])
+end

data/templates/bin/docker-entrypoint

@@ -0,0 +1,14 @@
+#!/bin/bash -e
+
+# Add any container initialization steps here
+git config --global --add safe.directory /plug-app
+
+# allocate swap space
+fallocate -l 2GB /swapfile
+chmod 0600 /swapfile
+mkswap /swapfile
+echo 10 > /proc/sys/vm/swappiness
+swapon /swapfile
+echo 1 > /proc/sys/vm/overcommit_memory
+
+exec "${@}"

data/templates/compose.yml

@@ -0,0 +1,7 @@
+version: "3.8"
+
+services:
+  redis-db:
+    image: redis:7-bookworm
+    ports:
+      - "6389:6379"

data/templates/config/initializers/environment.rb

@@ -14,16 +14,13 @@ elsif Rails.env.test?
 end
 
 YETTO_API_TLD = ENV.fetch("YETTO_API_TLD", "#{YETTO_URL}/api")
-YETTO_API_VERSION = ENV.fetch("YETTO_API_VERSION", "v1")
+YETTO_API_VERSION = ENV.fetch("YETTO_API_VERSION", "2023-03-06")
 
-SLACK_LOG_URL = ENV.fetch("SLACK_LOG_URL", nil)
+SLACK_LOG_URL = Rails.application.credentials.fetch(:SLACK_LOG_URL, ENV.fetch("SLACK_LOG_URL", "https://slack.com/the_log_room"))
 
-YETTO_PLUG_APP_TOKEN = ENV.fetch("YETTO_PLUG_APP_TOKEN", "super-secret")
-
-# For Honeycomb.io
-OTEL_EXPORTER_OTLP_ENDPOINT = ENV.fetch("OTEL_EXPORTER_OTLP_ENDPOINT", "https://api.honeycomb.io")
-OTEL_EXPORTER_OTLP_HEADERS = ENV.fetch("OTEL_EXPORTER_OTLP_HEADERS", "x-honeycomb-team=your-api-key")
-OTEL_SERVICE_NAME = ENV.fetch("OTEL_SERVICE_NAME", "your-service-name")
+YETTO_PLUG_PEM = Rails.application.credentials.fetch(:YETTO_PLUG_PEM, ENV.fetch("YETTO_PLUG_PEM", Rails.root.join("test/fixtures/files/fake_pem_file/fake.pem").read))
+SIGNING_SECRET = Rails.application.credentials.fetch(:PLUG_EMAIL_URL, ENV.fetch("PLUG_EMAIL_URL", "super-secret"))
+YETTO_PLUG_ID = Rails.application.credentials.fetch(:YETTO_PLUG_ID, ENV.fetch("YETTO_PLUG_ID", "super-secret"))
 
 def productionish?
   Rails.env.production? || Rails.env.staging?

data/templates/config/initializers/filter_parameter_logging.rb

@@ -17,6 +17,9 @@ Rails.application.config.filter_parameters += [
   :otp,
   :ssn,
   :credentials,
+  :state,
+  :access_token,
+  :refresh_token,
   :html_content,
   :text_content,
 ]

data/templates/config/initializers/opentelemetry.rb

@@ -0,0 +1,32 @@
+# typed: false
+# frozen_string_literal: true
+
+unless Rails.env.development?
+  # establish the environment for OTEL
+  ENV["OTEL_EXPORTER_OTLP_ENDPOINT"] = Rails.application.credentials.fetch(:OTEL_EXPORTER_OTLP_ENDPOINT, ENV.fetch("OTEL_EXPORTER_OTLP_ENDPOINT", "https://api.honeycomb.io"))
+  ENV["OTEL_EXPORTER_OTLP_HEADERS"] = Rails.application.credentials.fetch(:OTEL_EXPORTER_OTLP_HEADERS, ENV.fetch("OTEL_EXPORTER_OTLP_HEADERS", "x-honeycomb-team=your-api-key"))
+  ENV["OTEL_SERVICE_NAME"] = Rails.application.credentials.fetch(:OTEL_SERVICE_NAME, ENV.fetch("OTEL_SERVICE_NAME", "your-service-name"))
+
+  require "opentelemetry/sdk"
+  require "opentelemetry/semantic_conventions"
+
+  OpenTelemetry::SDK.configure do |c|
+    c.logger = Rails.logger
+
+    c.use_all("OpenTelemetry::Instrumentation::PG" => { db_statement: :obfuscate })
+
+    if productionish?
+      c.add_span_processor(
+        OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+          OpenTelemetry::Exporter::OTLP::Exporter.new,
+        ),
+      )
+    else # useful for testing instrumentation
+      c.add_span_processor(
+        OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+          OpenTelemetry::SDK::Trace::Export::SpanExporter.new,
+        ),
+      )
+    end # development is intentionally disabled
+  end
+end

data/templates/config/locales/en.yml

@@ -0,0 +1,32 @@
+# Files in the config/locales directory are used for internationalization
+# and are automatically loaded by Rails. If you want to use locales other
+# than English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t "hello"
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t("hello") %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# This would use the information in config/locales/es.yml.
+#
+# The following keys must be escaped otherwise they will not be retrieved by
+# the default I18n backend:
+#
+# true, false, on, off, yes, no
+#
+# Instead, surround them with single quotes.
+#
+# en:
+#   "true": "foo"
+#
+# To learn more, please read the Rails Internationalization guide
+# available at https://guides.rubyonrails.org/i18n.html.
+
+en: