brut 0.14.0 → 0.16.0.pre

data/mkbrut/templates/Base/bin/run

@@ -1,86 +1,126 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
 set -e 
-SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
-
-usage() {
-  echo "Usage: $0"
-  echo
-  echo "    Run the app in the given RACK_ENV."
-  echo "    You likely want to use bin/dev instead of this command."
-  echo
-  echo "ENVIRONMENT VARIABLES"
-  echo
-  echo "   PORT     - The port to run the app on. Default is 6502"
-  echo "   RACK_ENV - The Rack environment to use. Default is development"
-  echo
-}
-
-for arg in "$@"; do
-  if [ "${arg}" = "-h" ] || [ "${arg}" = "--help" ] || [ "${arg}" = "help" ]; then
-    usage
-    exit 0
-  fi
-done
 
+SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
 PORT="${PORT:-6502}"
 RACK_ENV="${RACK_ENV:-development}"
 
 export PORT
 export RACK_ENV
 
-set -e 
+declare -A CMD_MAP
+declare -A PIDFILE_MAP
+declare -A CREATES_PIDFILE_MAP
 
-# Everything here is trying its best to prevent more than
-# one server from running, as this is extremely confusing.
-# Note that the puma invocation at the bottom
-# of this script uses the pidfile concept.
-if [ -f tmp/pidfile ]; then
-  echo "[ $0 ] pidfile found"
-  pid=$(cat tmp/pidfile)
-
-  # First, try to gracefully stop the server with kill
-  if ps -p "${pid}" > /dev/null; then
-    echo "[ $0 ] Attempting to kill PID '${pid}'"
-    kill "${pid}"
-  else
-    echo "[ $0 ] PID '${pid}' no longer running"
+kill_previous() {
+  local pidfile=$1
+
+  if [[ -z "$pidfile" ]]; then
+    echo "[ $0 ] Error: no pidfile path given"
+    return 0
   fi
 
-  # Now, wait 5 seconds to see if it stopped
-  if timeout 5 tail --pid="${pid}" -f /dev/null; then
-    echo "[ $0 ] PID '${pid}' stopped. Restarting server"
-  else
-    # if it has not stopeed, use kill -9 which should work.
-    # But, like all things computer, it's not guaranteed.
-    echo "[ $0 ] PID '${pid}' has not stopped. Trying kill -9"
-    kill -9 "${pid}"
-    if timeout 1 tail --pid="${pid}" -f /dev/null; then
-      echo "[ $0 ] PID '${pid}' killed. Restarting server"
+  if [ -f "${pidfile}" ]; then
+    echo "[ $0 ] pidfile found"
+    pid=$(cat "${pidfile}")
+
+    if [[ -z "$pid" || ! "$pid" =~ ^[0-9]+$ ]]; then
+      echo "[ $0 ] Invalid or empty PID in $pidfile: '$pid'; removing"
+      rm -f "$pidfile"
+      return 0
+    fi
+
+    if ps -p "${pid}" > /dev/null; then
+      echo "[ $0 ] Attempting to kill PID '${pid}'"
+      kill "${pid}"
+    else
+      echo "[ $0 ] PID '${pid}' no longer running"
+    fi
+    if timeout 5 tail --pid="${pid}" -f /dev/null; then
+      echo "[ $0 ] PID '${pid}' stopped. Restarting server"
     else
-      echo "[ $0 ] PID '${pid}' still running. Something seriously wrong"
-      echo "[ $0 ] You may need to stop all Docker containers and restart them"
+      echo "[ $0 ] PID '${pid}' has not stopped. Trying kill -9"
+      kill -9 "${pid}"
+      if timeout 1 tail --pid="${pid}" -f /dev/null; then
+        echo "[ $0 ] PID '${pid}' killed. Restarting server"
+      else
+        echo "[ $0 ] PID '${pid}' still running. Something seriously wrong"
+      fi
       exit 1
     fi
+
+  else
+    echo "[ $0 ] No pidfile-Starting up"
   fi
+}
 
-else
-  echo "[ $0 ] No pidfile-Starting up"
+dotenv_run() {
+  local env_files="${SCRIPT_DIR}/../.env.${RACK_ENV}.local,${SCRIPT_DIR}/../.env.${RACK_ENV}"
+  dotenv -f "$env_files" --ignore -- "$@"
+}
+
+
+for f in "$SCRIPT_DIR"/run.*; do
+  if [[ -f "$f" ]]; then
+    echo "[ $0 ] Sourcing $f"
+    . "$f"
+  fi
+done
+
+case $# in
+  0) name="run" ;;
+  1) name="$1" ;;
+  *) echo "Error: too many arguments ($#)." >&2; usage; exit 2 ;;
+esac
+
+if [[ ! -v CMD_MAP[$name] ]]; then
+  echo "[ $0 ] Error: unknown service '$name'." >&2
+  echo -n "[ $0 ] Known services: " >&2
+  printf "%s " "${!CMD_MAP[@]}" >&2
+  echo >&2
+  exit 1
 fi
 
-# Run puma in a UNIX environment provided by dotenv.
-#
-# A few things to note:
-#
-# * dotenv is OK if -f is given non-existent files. That's why this works
-#   in production where there are no .env files.
-# * the `--` marks the end of dotenv's options and the start of the command
-#   to run. That's why the flags given to puma are not interpreted by dotenv
-#   as flags for itself.
-dotenv \
-  -f "${SCRIPT_DIR}/../.env.${RACK_ENV}.local,${SCRIPT_DIR}/../.env.${RACK_ENV}" \
-  --ignore \
-  -- \
-  bin/puma \
-    -C puma.config.rb \
-    --pid tmp/pidfile
+cmd="${CMD_MAP[$name]}"
+creates_pidfile="${CREATES_PIDFILE_MAP[$name]:-false}"
+pidfile="${PIDFILE_MAP[$name]:-}"
+
+echo "[ $0 ]: Command for $name:"
+echo
+echo "          $cmd"
+echo
+
+kill_previous "$pidfile"
+
+if [[ "$creates_pidfile" == true ]]; then
+  echo "[ $0 ] Running '$cmd', which creates its own pidfile"
+  eval "dotenv_run $cmd"
+else
+  # Command wont' create a pidfile, so we will
+  if [[ -z "${pidfile:-}" ]]; then
+    echo "Error: no pidfile path configured for '$name' but creates_pidfile=false." >&2
+    exit 1
+  fi
+  echo "[ $0 ] Running '$cmd', which will not create a pidfile"
+  echo "[ $0 ] We will do that and save it to ${pidfile}"
+
+  echo "[ $0 ] Ensuring $(dirname "$pidfile") exists"
+  mkdir -p "$(dirname "$pidfile")"
+
+  eval "dotenv_run $cmd &"
+  child_pid=$!
+
+  set +e
+  echo "$child_pid" > "$pidfile"
+
+  trap 'kill -TERM "$child_pid" 2>/dev/null' TERM INT
+
+  wait "$child_pid"
+
+  echo "[ $0 ] TERM or INT received, removing ${pidfile} and exiting"
+
+  status=$?
+  rm -f "$pidfile"
+  exit "$status"
+fi

data/mkbrut/templates/Base/bin/run.run

@@ -0,0 +1,4 @@
+PIDFILE="${SCRIPT_DIR}/../tmp/pidfile"
+CMD_MAP[run]="bin/puma --port ${PORT} -C puma.config.rb --environment ${RACK_ENV} --pid ${PIDFILE}"
+PIDFILE_MAP[run]="${PIDFILE}"
+CREATES_PIDFILE_MAP[run]="true"

data/mkbrut/templates/Base/bin/setup

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
 
-
 require "fileutils"
 require "open3"
 require "optparse"
 require "pathname"
+require "bundler"
+require "json"
 
 # This is intended to run inside the Workspace (i.e. Docker container) to
 # set up the Foundation, thus enabling development.  This script should:
@@ -21,6 +22,7 @@ require "pathname"
 #       Take care to only add code and not change what is here.
 
 def setup(update_gems:,update_node:)
+  ensure_versions_are_consistent!
   if update_gems
     log "Updating gems"
     system! "bundle update"
@@ -82,6 +84,35 @@ def setup(update_gems:,update_node:)
   help
 end
 
+def ensure_versions_are_consistent!
+  gemfile      = Bundler::Definition.build(ROOT_DIR / "Gemfile", ROOT_DIR / "Gemfile.lock", nil)
+  package_json = JSON.parse(File.read(ROOT_DIR / "package.json"))
+
+  playwright_version = nil
+  gemfile.dependencies.each do |dep|
+    if dep.name == "playwright-ruby-client"
+      if !dep.specific?
+        puts "You must specify an exact/specific version of 'playwright-ruby-client' in your Gemfile"
+        exit 1
+      end
+      playwright_version = dep.requirement.requirements.first[1]
+    end
+  end
+
+  if playwright_version
+    playwright_version_in_package_json = package_json.dig("devDependencies","playwright")
+    if !playwright_version_in_package_json
+      puts "You must have 'playwright' in the devDependencies section of your package.json"
+      exit 1
+    end
+    if playwright_version != playwright_version_in_package_json
+      puts "The version of 'playwright' in package.json (#{playwright_version_in_package_json}) does not match the version of 'playwright-ruby-client' in the Gemfile (#{playwright_version})"
+      puts "They must be exactly the same, or your end-to-end tests may behave strangely"
+      exit 1
+    end
+  end
+end
+
 def setup_dot_env_local
 
   dot_env = ROOT_DIR / ".env.development"

data/mkbrut/templates/Base/dx/bash_customizations

@@ -6,7 +6,3 @@ if [ ! -n "$PROJECT_ROOT" ]; then
 fi
 export GEM_HOME=${PROJECT_ROOT}/local-gems/gem-home
 export PATH=${PATH}:${GEM_HOME}/bin
-# This sets up the Node version so we don't have to do it before every. single.
-# shell. invocation.
-. ~/.nvm/nvm.sh
-nvm use default

data/mkbrut/templates/Base/package.json.erb

@@ -11,7 +11,7 @@
     "esbuild": "^0.20.2",
     "jsdom": "^25.0.1",
     "mocha": "^10.7.3",
-    "playwright": "1.50.1",
+    "playwright": "1.55.0",
     "typescript": "^5.8.3",
     "typescript-language-server": "^4.3.4",
     "vscode-langservers-extracted": "^4.10.0"

data/mkbrut/templates/segments/Heroku/deploy/Dockerfile

@@ -37,7 +37,8 @@ WORKDIR /brut-app
 # - lsb-release is used to generically access information for this OS's version
 # - wget allows us to copy/paste commands from vendors about how to install
 #   software even though it does the same thing as curl
-RUN apt-get update --quiet --yes && \
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get update --quiet --yes && \
     apt-get install --no-install-recommends --quiet --yes \
       ca-certificates \
       curl \
@@ -62,8 +63,7 @@ RUN /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y && \
 ENV RACK_ENV="production" \
     BUNDLE_DEPLOYMENT="1" \
     BUNDLE_PATH="/usr/local/bundle" \
-    BUNDLE_WITHOUT="development" \
-    APP_GIT_SHA1="${app_git_sha1}"
+    BUNDLE_WITHOUT="development"
 
 # This makes a new image that we'll throw away after building
 # needed artifacts.
@@ -74,30 +74,29 @@ FROM base AS build
 # - libpq-dev is needed by postgres
 # - pkg-config is, I guess, not considered "essential" (as in build-essential),
 #   but still needed to install downstream stuff
-RUN apt-get update --quiet --yes && \
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get update --quiet --yes && \
     apt-get install --no-install-recommends --quiet --yes \
 			build-essential \
 			git \
       libpq-dev \
 			pkg-config
 
-# Install NodeJS, per https://nodejs.org/en/download
-RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash && \
-    \. "$HOME/.nvm/nvm.sh" && \
-    nvm install 22 && \
-    node -v && nvm current && npm -v
+# Install NodeJS from their Docker image
+COPY --from=node:22-slim /usr/local /usr/local
 
-# Copy the app into the file, excluding the contents of .dockerignore
-COPY . .
+COPY Gemfile Gemfile.lock .
 
 # Install RubyGems from app's Gemfile
-RUN bundle install --verbose && \
+RUN --mount=type=cache,target=${BUNDLE_PATH}/cache \
+    bundle install --verbose && \
     rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git
 
+COPY package.json package-lock.json ./
 # Install Node Modules from package.json
-RUN \. "$HOME/.nvm/nvm.sh" && \
-    nvm use default && \
-    npm clean-install --no-audit --no-fund --verbose
+RUN npm clean-install --no-audit --no-fund --verbose
+
+COPY . .
 
 # Build all assets
 RUN \. "$HOME/.nvm/nvm.sh" && \
@@ -118,6 +117,7 @@ RUN groupadd --system --gid 1000 brut && \
     chown -R brut:brut logs tmp
 USER 1000:1000
 
+ENV APP_GIT_SHA1="${app_git_sha1}"
 # This is used to execute other commands.  When the app is run in production,
 # this script is used to run it.
 ENTRYPOINT ["/brut-app/deploy/docker-entrypoint"]

data/mkbrut/templates/segments/Heroku/deploy/heroku_config.rb

@@ -8,8 +8,8 @@ class HerokuConfig
   # The format of this Hash is:
   #
   # {
-  #   "«image name» => {
-  #     cmd: "«command line for Dockerfile RUN directive»",
+  #   *image name* => {
+  #     cmd: *command line for Dockerfile RUN directive*,
   #   }
   # }
   #
@@ -21,6 +21,7 @@ class HerokuConfig
   #     cmd: "bin/run-sidekiq",
   #   }
   # }
-  def self.additional_images = {}
+  #
+  def self.additional_images
+  end
 end
-

data/mkbrut/templates/segments/Sidekiq/app/boot_sidekiq.rb

@@ -0,0 +1,2 @@
+require_relative "bootstrap"
+bootstrap = Bootstrap.new.bootstrap!

data/mkbrut/templates/segments/Sidekiq/app/config/sidekiq.yml

@@ -0,0 +1,4 @@
+:concurrency: <%= ENV.fetch("SIDEKIQ_CONCURRENCY") { 5 } %>
+:timeout: <%= ENV.fetch("SIDEKIQ_TIMEOUT_SECONDS") { 25 } %>
+:queues:
+  - default

data/mkbrut/templates/segments/Sidekiq/app/src/back_end/jobs/app_job.rb

@@ -0,0 +1,3 @@
+class AppJob
+  include Sidekiq::Job
+end

data/mkbrut/templates/segments/Sidekiq/app/src/back_end/jobs/example_job.rb

@@ -0,0 +1,12 @@
+# This is entirely to allow the integration test to run
+# that verifies you have Sidekqi working and the segment was
+# installed correctly.  Once you have created a real job for
+# your app and done whatever testing you need, please delete
+# this job and the integration test.
+class ExampleJob < AppJob
+  def perform(path_to_file, contents)
+    File.open(path_to_file, "w") do |f|
+      f.puts(contents)
+    end
+  end
+end

data/mkbrut/templates/segments/Sidekiq/app/src/back_end/segments/sidekiq_segment.rb

@@ -0,0 +1,56 @@
+require "sidekiq"
+# Encapsulates all Sidekiq configuraiton beyond what can be done in
+# app/config/sidekiq.yml.  You can edit this as needed.
+class SidekiqSegment
+
+  def initialize
+    Brut.container.store(
+      "flush_spans_in_sidekiq?",
+      "Boolean",
+      "True if sidekiq jobs should flush all OTel spans after the job completes"
+    ) do |project_env|
+      if ENV["FLUSH_SPANS_IN_SIDEKIQ"] == "true"
+        true
+      elsif ENV["FLUSH_SPANS_IN_SIDEKIQ"] == "false"
+        false
+      else
+        project_env.development?
+      end
+    end
+  end
+
+  def boot!
+    Sidekiq.configure_server do |config|
+      config.redis = {
+        # Per https://devcenter.heroku.com/articles/connecting-heroku-redis#connecting-in-ruby
+        ssl_params: {
+          verify_mode: OpenSSL::SSL::VERIFY_NONE,
+        },
+      }
+      config.logger = SemanticLogger["Sidekiq:server"]
+      if Brut.container.flush_spans_in_sidekiq?
+        SemanticLogger[self.class].info("Sidekiq jobs will flush spans")
+        config.server_middleware do |chain|
+          if defined? OpenTelemetry::Instrumentation::Sidekiq::Middlewares::Server::TracerMiddleware
+            chain.insert_before OpenTelemetry::Instrumentation::Sidekiq::Middlewares::Server::TracerMiddleware,
+                                Brut::BackEnd::Sidekiq::Middlewares::Server::FlushSpans
+          else
+            SemanticLogger["Sidekiq:server"].warn("OpenTelemetry::Instrumentation::Sidekiq::Middlewares::Server::TracerMiddleware not defined")
+          end
+        end
+      else
+        SemanticLogger[self.class].info("Sidekiq jobs will not flush spans")
+      end
+    end
+
+    Sidekiq.configure_client do |config|
+      config.redis = {
+        # Per https://devcenter.heroku.com/articles/connecting-heroku-redis#connecting-in-ruby
+        ssl_params: {
+          verify_mode: OpenSSL::SSL::VERIFY_NONE,
+        },
+      }
+      config.logger = SemanticLogger["Sidekiq:client"]
+    end
+  end
+end

data/mkbrut/templates/segments/Sidekiq/bin/run.sidekiq

@@ -0,0 +1,4 @@
+PIDFILE="${SCRIPT_DIR}/../tmp/pidfile.sidekiq"
+CMD_MAP[sidekiq]="bin/sidekiq --config ${SCRIPT_DIR}/../app/config/sidekiq.yml  --require ${SCRIPT_DIR}/../app/boot_sidekiq.rb --verbose"
+PIDFILE_MAP[sidekiq]="${PIDFILE}"
+CREATES_PIDFILE_MAP[sidekiq]="false"

data/mkbrut/templates/segments/Sidekiq/specs/back_end/jobs/example_job.spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+RSpec.describe ExampleJob do
+  implementation_is_trivial
+end

data/mkbrut/templates/segments/Sidekiq/specs/integration/sidekiq_works.spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "timeout"
+
+# This test will ensure that Sidekiq segment was installed
+# correctly and your app can use Sidekiq. Once you have
+# created a real job for your app, delete ExampleJob and this test.
+RSpec.describe "Sidekiq is working", e2e: true do
+  it "processes jobs using the real Sidekiq server" do
+    # ExampleJob will write contents to a file.  This 
+    # test will delete that fail, queue the job, then
+    # wait up to 5 seconds for the job to run and create
+    # the file with the contents.  This should be more than
+    # enough time.
+    file = Brut.container.tmp_dir / "sidekiq_test.txt"
+    if file.exist?
+      file.delete
+    end
+
+    # If the file still exists at this point, the test
+    # will pass even if Sidekiq is not working.
+    confidence_check { expect(file.exist?).to eq(false) }
+
+    ExampleJob.perform_async(file.to_s, "test content for file")
+    queue_name = ExampleJob.sidekiq_options["queue"]
+    expect {
+      Timeout.timeout(5) do
+        loop do
+          if file.exist?
+            break
+          end
+          sleep 0.1
+        end
+      end
+    }.not_to raise_error
+    content = File.read(file)
+    expect(content).to eq("test content for file\n")
+  end
+end