logtail-rails 0.3.0 → 0.3.1

data/.github/workflows/main.yml

@@ -4,8 +4,6 @@ on:
   push:
     branches: [main]
   pull_request:
-  schedule:
-    - cron: '20 5 * * 1'
   workflow_dispatch:
 
 jobs:
@@ -17,9 +15,11 @@ jobs:
       fail-fast: false
 
       matrix:
+        # Released Ruby and Rails versions only. The E2E workflow (e2e.yml) covers the newest stable Ruby and Rails,
+        # ruby-head and Rails' main branch.
         ruby-version:
           - "4.0"
-          - "3"
+          - "3.4"
           - "3.3"
           - "3.2"
           - "3.1"
@@ -29,7 +29,6 @@ jobs:
           - "2.5"
           - "truffleruby"
         gemfile:
-          - "rails-edge"
           - "rails-8.1"
           - "rails-8.0"
           - "rails-7.2"
@@ -41,19 +40,6 @@ jobs:
           - "rails-5.1"
           - "rails-5.0"
         exclude:
-          - gemfile: "rails-edge"
-            ruby-version: "3.2"
-          - gemfile: "rails-edge"
-            ruby-version: "3.1"
-          - gemfile: "rails-edge"
-            ruby-version: "3.0"
-          - gemfile: "rails-edge"
-            ruby-version: "2.7"
-          - gemfile: "rails-edge"
-            ruby-version: "2.6"
-          - gemfile: "rails-edge"
-            ruby-version: "2.5"
-
           - gemfile: "rails-8.1"
             ruby-version: "3.1"
           - gemfile: "rails-8.1"
@@ -98,7 +84,7 @@ jobs:
           - gemfile: "rails-5.2"
             ruby-version: "4.0"
           - gemfile: "rails-5.2"
-            ruby-version: "3"
+            ruby-version: "3.4"
           - gemfile: "rails-5.2"
             ruby-version: "3.3"
           - gemfile: "rails-5.2"
@@ -113,7 +99,7 @@ jobs:
           - gemfile: "rails-5.1"
             ruby-version: "4.0"
           - gemfile: "rails-5.1"
-            ruby-version: "3"
+            ruby-version: "3.4"
           - gemfile: "rails-5.1"
             ruby-version: "3.3"
           - gemfile: "rails-5.1"
@@ -128,7 +114,7 @@ jobs:
           - gemfile: "rails-5.0"
             ruby-version: "4.0"
           - gemfile: "rails-5.0"
-            ruby-version: "3"
+            ruby-version: "3.4"
           - gemfile: "rails-5.0"
             ruby-version: "3.3"
           - gemfile: "rails-5.0"

data/.github/workflows/notify_linear_failure.yml

@@ -0,0 +1,153 @@
+name: "Notify Linear on failure"
+
+# Files a Linear issue for a failed run: "E2E failure: <workflow name> (<owner/repo>)" at High priority, listing the
+# failed jobs and steps with their errors, or with their summaries when job_summaries is set. When every failed job's
+# name starts with "canary" (pre-release runtime or dependencies), the title says "E2E canary failure" and the
+# priority is Low. While an issue with the same title is still open, the run is added to it as a comment instead,
+# so a test that keeps failing every day makes one issue, not one per day.
+# Secrets: LINEAR_API_KEY, LINEAR_TEAM_TELEMETRY_ID, LINEAR_STATUS_PLAN_ID, LINEAR_PROJECT_INGESTION_FOR_EVERYTHING_ID,
+# LINEAR_ASSIGNEE_PETR_ID.
+on:
+  workflow_call:
+    inputs:
+      job_summaries:
+        description: >-
+          Adds each failed job's summary to the issue, or its errors when it has none. A job hands its summary over as
+          an artifact named "e2e-summary-<job name>" holding summary.md.
+        type: boolean
+        default: false
+
+jobs:
+  create-linear-issue:
+    runs-on: ubuntu-latest
+    # A caller must grant checks: read as well (the errors come from the annotations), or this job cannot start.
+    permissions:
+      contents: read
+      actions: read
+      checks: read
+    steps:
+      - name: "Gather failure context"
+        id: ctx
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RUN_ID: ${{ github.event.workflow_run.id || github.run_id }}
+          RUN_ATTEMPT: ${{ github.event.workflow_run.run_attempt || github.run_attempt }}
+          JOB_SUMMARIES: ${{ inputs.job_summaries }}
+        run: |
+          JOBS=$(gh api \
+            "repos/${{ github.repository }}/actions/runs/$RUN_ID/attempts/$RUN_ATTEMPT/jobs" \
+            --paginate \
+            --jq '.jobs[]
+                    | select(.conclusion == "failure")
+                    | {id, name, steps: ([.steps[] | select(.conclusion == "failure") | .name] | join(", "))}
+                    | @json')
+
+          FAILED=""
+          while read -r job; do
+            [ -n "$job" ] || continue
+            ID=$(jq -r .id <<<"$job")
+            NAME=$(jq -r .name <<<"$job")
+            STEPS=$(jq -r .steps <<<"$job")
+            FAILED="$FAILED### $NAME"$'\n\n'"Failed at **${STEPS}**"$'\n\n'
+            # A job's summary already says why it failed. Otherwise, or when the job stopped before writing it, the
+            # issue gets its ::error:: lines, without the runner's closing "Process completed with exit code 1."
+            SUMMARY_DIR="summaries/$ID"
+            if [ "$JOB_SUMMARIES" = true ]; then
+              gh run download "$RUN_ID" -R "${{ github.repository }}" -n "e2e-summary-$NAME" -D "$SUMMARY_DIR" >/dev/null 2>&1 || true
+            fi
+            if [ -f "$SUMMARY_DIR/summary.md" ]; then
+              FAILED="$FAILED$(cat "$SUMMARY_DIR/summary.md")"$'\n\n'
+            else
+              ERRORS=$(gh api "repos/${{ github.repository }}/check-runs/$ID/annotations" \
+                --jq '[.[] | select(.annotation_level == "failure" and (.message | startswith("Process completed with exit code") | not)) | .message | gsub("\n"; " ")] | unique | .[] | "- \(.)"') || ERRORS=""
+              FAILED="$FAILED${ERRORS:+$ERRORS$'\n\n'}"
+            fi
+          done <<<"$JOBS"
+          # Canary only when there are failed jobs and all of them are canary jobs.
+          CANARY=false
+          if [ -n "$JOBS" ] && jq -se 'all(.[]; .name | startswith("canary"))' <<<"$JOBS" >/dev/null; then CANARY=true; fi
+
+          while [[ "$FAILED" == *$'\n' ]]; do FAILED="${FAILED%$'\n'}"; done
+          if [ -z "$FAILED" ]; then
+            FAILED="_(no failed jobs reported by the API yet)_"
+          elif [ "${#FAILED}" -gt 20000 ]; then
+            FAILED="${FAILED:0:20000}"$'\n\n'"_(cut at 20,000 characters, the rest is in the run)_"
+          fi
+          printf '%s\n' "$FAILED" > failed_jobs.md
+          echo "canary=$CANARY" >> "$GITHUB_OUTPUT"
+
+      - name: "Create the Linear issue, or comment on the open one with the same title"
+        env:
+          LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+          LINEAR_TEAM_ID: ${{ secrets.LINEAR_TEAM_TELEMETRY_ID }}
+          LINEAR_STATUS_PLAN_ID: ${{ secrets.LINEAR_STATUS_PLAN_ID }}
+          LINEAR_PROJECT_INGESTION_FOR_EVERYTHING_ID: ${{ secrets.LINEAR_PROJECT_INGESTION_FOR_EVERYTHING_ID }}
+          LINEAR_ASSIGNEE_PETR_ID: ${{ secrets.LINEAR_ASSIGNEE_PETR_ID }}
+          CANARY: ${{ steps.ctx.outputs.canary }}
+          REPOSITORY: ${{ github.repository }}
+          WORKFLOW: ${{ github.event.workflow_run.name || github.workflow }}
+          REF_NAME: ${{ github.event.workflow_run.head_branch || github.ref_name }}
+          RUN_URL: ${{ github.event.workflow_run.html_url || format('{0}/{1}/actions/runs/{2}', github.server_url, github.repository, github.run_id) }}
+          RUN_ATTEMPT: ${{ github.event.workflow_run.run_attempt || github.run_attempt }}
+          EVENT_NAME: ${{ github.event.workflow_run.event || github.event_name }}
+          SHA: ${{ github.event.workflow_run.head_sha || github.sha }}
+          COMMIT_MESSAGE: ${{ github.event.workflow_run.head_commit.message || github.event.head_commit.message }}
+        run: |
+          if [ "$CANARY" = true ]; then
+            TITLE="E2E canary failure: $WORKFLOW ($REPOSITORY)"; PRIORITY=4
+          else
+            TITLE="E2E failure: $WORKFLOW ($REPOSITORY)"; PRIORITY=2
+          fi
+
+          # head_commit is only populated on push events; skip the subject otherwise
+          COMMIT_LINE="**Commit:** \`${SHA:0:7}\`"
+          [ -z "$COMMIT_MESSAGE" ] || COMMIT_LINE="$COMMIT_LINE: $(printf '%s' "$COMMIT_MESSAGE" | head -n1)"
+          ATTEMPT_NOTE=""
+          [ "$RUN_ATTEMPT" = 1 ] || ATTEMPT_NOTE=" (attempt #$RUN_ATTEMPT)"
+          {
+            echo "**$WORKFLOW** failed on \`$REF_NAME\` via \`$EVENT_NAME\`$ATTEMPT_NOTE"
+            echo
+            echo "**Failing jobs:**"
+            echo
+            cat failed_jobs.md
+            echo
+            echo "$COMMIT_LINE"
+            echo
+            echo "[View failing run]($RUN_URL)"
+          } > description.md
+
+          linear() {
+            curl -sS --fail-with-body -X POST https://api.linear.app/graphql \
+              -H "Authorization: $LINEAR_API_KEY" -H 'Content-Type: application/json' -d "$1"
+          }
+
+          # Open means any state but done, canceled or marked as a duplicate. Better a second issue than none: when the
+          # lookup fails, a new issue is created.
+          FIND=$(jq -nc --arg title "$TITLE" --arg teamId "$LINEAR_TEAM_ID" '{
+            query: "query ($title: String!, $teamId: ID!) { issues(filter: {title: {eq: $title}, team: {id: {eq: $teamId}}, state: {type: {nin: [\"completed\", \"canceled\", \"duplicate\"]}}}, first: 1) { nodes { id url } } }",
+            variables: {title: $title, teamId: $teamId}
+          }')
+          FOUND=$(linear "$FIND") || { echo "::warning::looking for an open issue titled \"$TITLE\" failed: $FOUND"; FOUND='{}'; }
+          OPEN=$(jq -r '.data.issues.nodes[0] // empty | "\(.id) \(.url)"' <<<"$FOUND")
+
+          if [ -n "$OPEN" ]; then
+            read -r ISSUE_ID ISSUE_URL <<<"$OPEN"
+            PAYLOAD=$(jq -nc --arg issueId "$ISSUE_ID" --rawfile body description.md '{
+              query: "mutation ($input: CommentCreateInput!) { commentCreate(input: $input) { success } }",
+              variables: {input: {issueId: $issueId, body: $body}}
+            }')
+            RES=$(linear "$PAYLOAD") || true
+            jq -e '.data.commentCreate.success' <<<"$RES" >/dev/null || { echo "::error::commenting on $ISSUE_URL failed: $RES"; exit 1; }
+            echo "added this run to the open issue $ISSUE_URL"
+          else
+            PAYLOAD=$(jq -nc --arg title "$TITLE" --rawfile description description.md --arg teamId "$LINEAR_TEAM_ID" \
+              --arg assigneeId "$LINEAR_ASSIGNEE_PETR_ID" --arg stateId "$LINEAR_STATUS_PLAN_ID" \
+              --arg projectId "$LINEAR_PROJECT_INGESTION_FOR_EVERYTHING_ID" --argjson priority "$PRIORITY" '{
+              query: "mutation ($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { url } } }",
+              variables: {input: {title: $title, description: $description, teamId: $teamId, assigneeId: $assigneeId,
+                stateId: $stateId, projectId: $projectId, priority: $priority}}
+            }')
+            RES=$(linear "$PAYLOAD") || true
+            ISSUE_URL=$(jq -er '.data.issueCreate.issue.url' <<<"$RES") || { echo "::error::creating the issue failed: $RES"; exit 1; }
+            echo "created $ISSUE_URL"
+          fi

data/e2e/example.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Installs or runs the example project (example-project/, a Rails app) the way its README tells a customer to, with the
+# leg's Rails, logtail and logtail-rack versions. The output goes to out/<command>.log as well, and a failure ends with
+# one ::error:: line giving the reason.
+#   e2e/example.sh install   pins the leg's versions in the example's Gemfile and runs bundle install
+#   e2e/example.sh run       starts bin/rails server, requests /send_logs and /raise_error, and stops the server with
+#                            Ctrl-C (SIGINT); the logs go to BETTER_STACK_INGESTING_HOST with BETTER_STACK_SOURCE_TOKEN
+# Env: RAILS (a release, or main with RAILS_REF the commit), SQLITE3 (a requirement, or empty for the Gemfile's own),
+#      LOGTAIL and LOGTAIL_RACK (releases, or empty for whatever Bundler picks), CLIENT (the logtail-rails release; on
+#      pushes and pull requests e2e.yml has installed the gem built from the checkout under that version).
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+OUT=$ROOT/out
+LOG=$OUT/$1.log
+PORT=3000
+mkdir -p "$OUT"
+cd "$ROOT/example-project"
+
+# Replaces gem $1's line in the Gemfile, or adds one, with the requirement $2.
+pin() {
+  sed -i.orig "/^gem \"$1\"/d" Gemfile && rm Gemfile.orig
+  echo "gem \"$1\", $2" >> Gemfile
+}
+
+case "$1" in
+  install)
+    cp Gemfile "$OUT/Gemfile.example"
+    if [ "$RAILS" = main ]; then pin rails "github: \"rails/rails\", ref: \"$RAILS_REF\""; else pin rails "\"= $RAILS\""; fi
+    if [ -n "$SQLITE3" ]; then pin sqlite3 "\"$SQLITE3\""; fi
+    # The example's Gemfile only names logtail-rails, logtail and logtail-rack come with it as its dependencies.
+    if [ -n "$LOGTAIL" ]; then pin logtail "\"= $LOGTAIL\""; fi
+    if [ -n "$LOGTAIL_RACK" ]; then pin logtail-rack "\"= $LOGTAIL_RACK\""; fi
+    pin logtail-rails "\"= $CLIENT\""
+    { diff -u "$OUT/Gemfile.example" Gemfile || true; } | tee "$LOG"
+    bundle install 2>&1 | tee -a "$LOG" || {
+      echo "::error::bundle install failed for Rails $RAILS${RAILS_REF:+ $RAILS_REF} on Ruby $(ruby -e 'print RUBY_VERSION'): $(grep -m 1 -iE 'could not|error|incompatible|requires' "$LOG" || tail -n 1 "$LOG")"
+      exit 1
+    } ;;
+  run)
+    bin/rails server -p "$PORT" > "$LOG" 2>&1 &
+    SERVER=$!
+    # Up when it accepts connections. Polling a page instead would log requests of its own.
+    for _ in $(seq 120); do
+      if (: > "/dev/tcp/127.0.0.1/$PORT") 2>/dev/null; then break; fi
+      kill -0 "$SERVER" 2>/dev/null || { cat "$LOG"; echo "::error::bin/rails server exited before it listened: $(tail -n 1 "$LOG")"; exit 1; }
+      sleep 1
+    done
+    FAILED=""
+    SEND_LOGS=$(curl -sS -m 30 -o "$OUT/send_logs.html" -w '%{http_code}' "http://127.0.0.1:$PORT/send_logs") || SEND_LOGS=000
+    [ "$SEND_LOGS" = 200 ] || FAILED="GET /send_logs answered HTTP $SEND_LOGS, not 200"
+    # The action raises, Rails answers with its error page.
+    RAISE_ERROR=$(curl -sS -m 30 -o "$OUT/raise_error.html" -w '%{http_code}' "http://127.0.0.1:$PORT/raise_error") || RAISE_ERROR=000
+    [ "$RAISE_ERROR" = 500 ] || FAILED="${FAILED:+$FAILED, }GET /raise_error answered HTTP $RAISE_ERROR, not 500"
+    # Ctrl-C, as a customer stops it. Puma stops gracefully and the HTTP log device sends what is still buffered
+    # when the process exits.
+    kill -INT "$SERVER"
+    STATUS=0
+    wait "$SERVER" || STATUS=$?
+    cat "$LOG"
+    [ "$STATUS" = 0 ] || FAILED="${FAILED:+$FAILED, }bin/rails server exited with $STATUS after Ctrl-C"
+    # The gem warns on stderr about a blank source token and about batches Better Stack rejected.
+    if grep -q '^Logtail: ' "$LOG"; then FAILED="${FAILED:+$FAILED, }$(grep -m 1 '^Logtail: ' "$LOG")"; fi
+    if [ -n "$FAILED" ]; then echo "::error::The example project failed: $FAILED"; exit 1; fi ;;
+  *) echo "::error::unknown command $1"; exit 1 ;;
+esac

data/e2e/expected.json

@@ -0,0 +1,109 @@
+[
+  {
+    "since_rails": "8.1",
+    "level": "warn",
+    "message_prefix": "Generating image variants require the image_processing gem."
+  },
+  {
+    "level": "debug",
+    "message_prefix": "  \u001b[1m\u001b[35m (",
+    "contains": {"sql_query_executed": {"sql": "CREATE TABLE \"schema_migrations\" (\"version\" varchar NOT NULL PRIMARY KEY)"}}
+  },
+  {
+    "level": "debug",
+    "message_prefix": "  \u001b[1m\u001b[35m (",
+    "contains": {"sql_query_executed": {"sql": "CREATE TABLE \"ar_internal_metadata\" (\"key\" varchar NOT NULL PRIMARY KEY, \"value\" varchar, \"created_at\" datetime(6) NOT NULL, \"updated_at\" datetime(6) NOT NULL)"}}
+  },
+  {
+    "level": "debug",
+    "message_prefix": "  \u001b[1m\u001b[36mActiveRecord::SchemaMigration Load (",
+    "contains": {"sql_query_executed": {"sql": "SELECT \"schema_migrations\".\"version\" FROM \"schema_migrations\" ORDER BY \"schema_migrations\".\"version\" ASC"}}
+  },
+  {
+    "level": "info",
+    "message": "Started GET \"/send_logs\"",
+    "contains": {"event": {"http_request_received": {"method": "GET", "path": "/send_logs", "host": "127.0.0.1", "port": 3000}}, "context": {"http": {"method": "GET", "path": "/send_logs", "remote_addr": "127.0.0.1"}}}
+  },
+  {
+    "level": "info",
+    "message": "Processing by ExampleController#send_logs as */*",
+    "contains": {"controller_called": {"controller": "ExampleController", "action": "send_logs"}, "context": {"http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "debug",
+    "message": "Hey! I am debuging!",
+    "contains": {"context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 12, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "info",
+    "message": "You know what's interesting? Logtail !",
+    "contains": {"context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 15, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "warn",
+    "message": "Something might not be quite right...",
+    "contains": {"context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 18, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "error",
+    "message": "Oops! Something went wrong.",
+    "contains": {"context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 21, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "fatal",
+    "message": "Application crashed! Needs to be fixed ASAP!",
+    "contains": {"context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 24, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "info",
+    "message": "log message with tags",
+    "contains": {"tags": ["tag1", "tag2"], "context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 28, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "warn",
+    "message": "log structured data",
+    "contains": {"name": {"first": "John", "last": "Smith"}, "id": 123456, "context": {"runtime": {"file": "app/controllers/example_controller.rb", "line": 32, "frame_label": "send_logs"}, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "since_rails": "8.1",
+    "level": "info",
+    "message_prefix": "[My first event] user_id=123 email=user@example.com at ",
+    "contains": {"message": "app/controllers/example_controller.rb:42", "event_name": "My first event", "payload": {"user_id": 123, "email": "user@example.com"}, "source_location": {"filepath": "app/controllers/example_controller.rb", "lineno": 42, "label": "send_logs"}, "context": {"http": {"path": "/send_logs"}}}
+  },
+  {
+    "since_rails": "8.1",
+    "level": "info",
+    "message_prefix": "[My tagged event with additional context] user_id=123 email=user@example.com at ",
+    "contains": {"message": "app/controllers/example_controller.rb:48", "event_name": "My tagged event with additional context", "payload": {"user_id": 123, "email": "user@example.com"}, "tags": ["api"], "source_location": {"filepath": "app/controllers/example_controller.rb", "lineno": 48, "label": "send_logs"}, "context": {"request_id": "abc123", "shop_id": 456, "http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "info",
+    "message_prefix": "  Rendered example/send_logs.html.erb within layouts/application (",
+    "contains": {"template_rendered": {"name": "example/send_logs.html.erb"}, "context": {"http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "info",
+    "message_prefix": "Completed 200 OK in ",
+    "contains": {"event": {"http_response_sent": {"status": 200}}, "context": {"http": {"path": "/send_logs"}}}
+  },
+  {
+    "level": "info",
+    "message": "Started GET \"/raise_error\"",
+    "contains": {"event": {"http_request_received": {"method": "GET", "path": "/raise_error", "host": "127.0.0.1", "port": 3000}}, "context": {"http": {"method": "GET", "path": "/raise_error", "remote_addr": "127.0.0.1"}}}
+  },
+  {
+    "level": "info",
+    "message": "Processing by ExampleController#raise_error as */*",
+    "contains": {"controller_called": {"controller": "ExampleController", "action": "raise_error"}, "context": {"http": {"path": "/raise_error"}}}
+  },
+  {
+    "level": "error",
+    "message": "ArgumentError (Something went wrong, this action raised an exception!)",
+    "contains": {"error": {"name": "ArgumentError", "message": "Something went wrong, this action raised an exception!", "backtrace_json": ["app/controllers/example_controller.rb:55:in "]}, "context": {"http": {"path": "/raise_error"}}}
+  },
+  {
+    "level": "info",
+    "message_prefix": "Completed 500 Internal Server Error in ",
+    "contains": {"event": {"http_response_sent": {"status": 500}}, "context": {"http": {"path": "/raise_error"}}}
+  }
+]

data/e2e/installed.rb

@@ -0,0 +1,20 @@
+# Prints the running Ruby and what the example's bundle resolved, as name=value lines for e2e.yml's version check.
+# Run with bundle exec from example-project/.
+rails = Gem.loaded_specs.fetch("rails")
+client = Gem.loaded_specs.fetch("logtail-rails")
+{
+  "ruby" => RUBY_VERSION,
+  "ruby_description" => RUBY_DESCRIPTION,
+  # ruby-head reports the next version with patch level -1
+  "ruby_dev" => RUBY_PATCHLEVEL == -1,
+  "rails" => rails.version,
+  # The commit of a Rails from GitHub, empty for a release
+  "rails_ref" => Bundler.locked_gems.specs.find { |spec| spec.name == "rails" }.source.options["revision"],
+  "logtail" => Gem.loaded_specs.fetch("logtail").version,
+  "logtail_rack" => Gem.loaded_specs.fetch("logtail-rack").version,
+  "sqlite3" => Gem.loaded_specs.fetch("sqlite3").version,
+  "client" => client.version,
+  "client_dir" => client.full_gem_path,
+  # The .gem file RubyGems installed it from, kept in its cache
+  "client_gem" => client.cache_file,
+}.each { |name, value| puts "#{name}=#{value}" }

data/e2e/plan.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+# Plans the E2E matrix: one job per leg, with the Ruby and the Rails, logtail and logtail-rack versions the leg runs the
+# example project (example-project/, a Rails app) with. Prints the matrix as a JSON array, the include list of the test
+# job in e2e.yml.
+#   floor   the oldest Rails the example runs on (its config.load_defaults) at that line's newest patch, on the oldest
+#           Ruby both that Rails release and logtail-rails.gemspec allow, with logtail and logtail-rack at the gemspec's
+#           floors
+#   rails7  the newest Rails 7 release on Ruby 3.2 with the newest logtail and logtail-rack: the step between the
+#           floor and the newest Rails
+#   latest  the newest stable Ruby that ruby/setup-ruby can install, with the newest Rails, logtail and logtail-rack
+#           releases
+#   canary  ruby-head with the current commit of Rails' main branch, and whatever logtail and logtail-rack Bundler picks
+# Env: LEG (all, floor, rails7, latest or canary), CLIENT_FROM (checkout or rubygems), and RUBY_VERSION_INPUT and
+#      RAILS_VERSION_INPUT: an exact Ruby, and an exact Rails release or a commit of Rails' main branch, that replace the
+#      planned ones in every leg.
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "$0")/.." && pwd)
+RUBYGEMS=https://rubygems.org/api/v1
+# What ruby/setup-ruby@v1 can install. A Ruby released today is in it once setup-ruby supports it.
+SETUP_RUBY_VERSIONS_URL=https://raw.githubusercontent.com/ruby/setup-ruby/v1/ruby-builder-versions.json
+# Job names become artifact names (e2e-summary-<job name>), which must not contain any of these.
+NOT_IN_NAMES='[:"<>|*?/\\]'
+
+# A registry hiccup at schedule time should not file a Linear issue, so every lookup is retried.
+get() { curl -fsS -m 60 --retry 3 --retry-delay 10 "$1"; }
+# The newest release of gem $1: rubygems.org's "version" is the highest version that is not a pre-release.
+newest() { get "$RUBYGEMS/gems/$1.json" | jq -er .version; }
+# The X.Y.Z of gem $1's ">= X.Y.Z" in logtail-rails.gemspec.
+gemspec_floor() { sed -n "s/.*add_runtime_dependency \"$1\", .*\">= \([0-9.]*\)\".*/\1/p" "$ROOT/logtail-rails.gemspec"; }
+# The X.Y of a ">= X.Y.Z" requirement.
+minor_of() { sed -n 's/^>= *\([0-9]*\.[0-9]*\).*/\1/p' <<<"$1"; }
+# The higher of two versions.
+higher() { printf '%s\n%s\n' "$1" "$2" | sort -V | tail -n 1; }
+
+RAILS_VERSIONS=$(get "$RUBYGEMS/versions/rails.json")
+# The newest release of Rails line $1 (7.0, or 7 for all of Rails 7).
+newest_rails_of() {
+  jq -er --arg line "$1." '[.[] | select(.prerelease | not) | .number | select(startswith($line))]
+    | sort_by(split(".") | map(tonumber)) | last // empty' <<<"$RAILS_VERSIONS"
+}
+
+# The client the example installs: the gem built from the checkout, or the newest release on rubygems.org.
+if [ "${CLIENT_FROM:-checkout}" = rubygems ]; then
+  CLIENT=$(newest logtail-rails)
+else
+  CLIENT=$(sed -n 's/.*VERSION = "\(.*\)".*/\1/p' "$ROOT/lib/logtail-rails/version.rb")
+fi
+
+LEGS=$([ "${LEG:-all}" = all ] && echo "floor rails7 latest canary" || echo "$LEG")
+MATRIX='[]'
+for leg in $LEGS; do
+  rails_ref=""
+  case "$leg" in
+    floor)
+      # The example's config.load_defaults names the oldest Rails it boots on: older releases reject that version.
+      rails=$(newest_rails_of "$(sed -n 's/^ *config\.load_defaults \([0-9.]*\).*/\1/p' "$ROOT/example-project/config/application.rb")")
+      gem_ruby=$(minor_of "$(sed -n "s/.*required_ruby_version = '\(.*\)'.*/\1/p" "$ROOT/logtail-rails.gemspec")")
+      rails_ruby=$(minor_of "$(jq -r --arg rails "$rails" '.[] | select(.number == $rails) | .ruby_version' <<<"$RAILS_VERSIONS")")
+      ruby=$(higher "$gem_ruby" "$rails_ruby")
+      logtail=$(gemspec_floor logtail)
+      logtail_rack=$(gemspec_floor logtail-rack) ;;
+    rails7)
+      ruby=3.2
+      rails=$(newest_rails_of 7)
+      logtail=$(newest logtail)
+      logtail_rack=$(newest logtail-rack) ;;
+    latest)
+      # The newest X.Y.Z in setup-ruby's list of CRuby builds, which also holds previews, head and debug builds.
+      ruby=$(get "$SETUP_RUBY_VERSIONS_URL" | jq -er '.ruby | map(select(test("^[0-9]+\\.[0-9]+\\.[0-9]+$"))) | max_by(split(".") | map(tonumber))')
+      rails=$(newest rails)
+      logtail=$(newest logtail)
+      logtail_rack=$(newest logtail-rack) ;;
+    canary)
+      ruby=head
+      rails=main
+      rails_ref=$(git ls-remote https://github.com/rails/rails.git refs/heads/main | cut -f 1)
+      logtail=""
+      logtail_rack="" ;;
+    *) echo "unknown leg $leg" >&2; exit 1 ;;
+  esac
+  ruby=${RUBY_VERSION_INPUT:-$ruby}
+  if [[ "${RAILS_VERSION_INPUT:-}" =~ ^[0-9a-f]{7,40}$ ]]; then
+    rails=main
+    rails_ref=$RAILS_VERSION_INPUT
+  elif [ -n "${RAILS_VERSION_INPUT:-}" ]; then
+    rails=$RAILS_VERSION_INPUT
+    rails_ref=""
+  fi
+  for value in "$ruby" "$rails" "$CLIENT"; do
+    [ -n "$value" ] || { echo "the $leg leg could not be planned: ruby '$ruby', rails '$rails', client '$CLIENT'" >&2; exit 1; }
+  done
+  [ "$rails" != main ] || [ -n "$rails_ref" ] || { echo "no commit found on Rails' main branch" >&2; exit 1; }
+  # Rails 7.0 and 7.1's sqlite3 adapter requires sqlite3 ~> 1.4, while the example's Gemfile asks for 2.x.
+  sqlite3=""
+  if [ "$rails" != main ] && [ "$(higher "$rails" 7.2)" != "$rails" ]; then sqlite3="~> 1.4"; fi
+
+  MATRIX=$(jq -c --arg leg "$leg" --arg ruby "$ruby" --arg rails "$rails" --arg rails_ref "$rails_ref" --arg sqlite3 "$sqlite3" \
+    --arg logtail "$logtail" --arg logtail_rack "$logtail_rack" --arg source "${CLIENT_FROM:-checkout}" --arg client "$CLIENT" '. + [{
+      name: "\($leg) (Ruby \($ruby), Rails \(if $rails == "main" then "main " + $rails_ref[0:7] else $rails end), \(
+        if $logtail == "" then "newest logtail and logtail-rack" else "logtail \($logtail), logtail-rack \($logtail_rack)" end))",
+      leg: $leg, ruby: $ruby, rails: $rails, rails_ref: $rails_ref, sqlite3: $sqlite3,
+      logtail: $logtail, logtail_rack: $logtail_rack, source: $source, client: $client,
+      # The floor and the Rails 7 leg run on the oldest Ubuntu image GitHub offers, the other legs follow ubuntu-latest.
+      runner: (if $leg == "floor" or $leg == "rails7" then "ubuntu-24.04" else "ubuntu-latest" end)
+    }]' <<<"$MATRIX")
+done
+if jq -e --arg not "$NOT_IN_NAMES" 'any(.[]; .name | test($not))' <<<"$MATRIX" >/dev/null; then
+  echo "a job name contains one of $NOT_IN_NAMES, which artifact names do not allow: $(jq -c 'map(.name)' <<<"$MATRIX")" >&2
+  exit 1
+fi
+echo "$MATRIX"

data/example-project/Gemfile

@@ -1,10 +1,8 @@
 source "https://rubygems.org"
 git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
-ruby "3.3.4"
-
 # Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
-gem "rails", "~> 8.1.0.rc1"
+gem "rails", "~> 8.1.0"
 
 # The original asset pipeline for Rails [https://github.com/rails/sprockets-rails]
 gem "sprockets-rails"
@@ -71,4 +69,4 @@ group :test do
   gem "webdrivers"
 end
 
-gem "logtail-rails", "~> 0.2.12"
+gem "logtail-rails", "~> 0.3"

data/example-project/README.md

@@ -9,23 +9,23 @@ You can download the example project from GitHub directly or you can clone it to
 bundle install
 ```
 
-This will install all dependencies listed in the `Gemfile.lock` file.
+This will install all dependencies listed in the `Gemfile`. The example runs on Rails 7.1 and newer.
 
-Then replace `<SOURCE_TOKEN>` and `<INGESTING_HOST>` in `config/application.rb` with your actual source token and ingesting host which you can find by going to [Sources](https://telemetry.betterstack.com/team/0/sources) -> Configure in Better Stack.
+`config/application.rb` reads your source token and ingesting host from the environment. You can find them by going to [Sources](https://telemetry.betterstack.com/team/0/sources) -> Configure in Better Stack.
 
 ```ruby
 config.logger = Logtail::Logger.create_default_logger(
-  "<YOUR_ACTUAL_SOURCE_TOKEN>",
-  ingesting_host: "in.logs.betterstack.com",
+  ENV["BETTER_STACK_SOURCE_TOKEN"],
+  ingesting_host: ENV["BETTER_STACK_INGESTING_HOST"],
 )
 ```
 
 ## Run the example project
  
-To run the example application, run the following command:
+To run the example application, run the following command with your source token and ingesting host:
 
 ```bash
-rails server
+BETTER_STACK_SOURCE_TOKEN=<source_token> BETTER_STACK_INGESTING_HOST=<ingesting_host> bin/rails server
 ```
 
 This will open a local server [127.0.0.1:3000.](http://127.0.0.1:3000/) On the main page, click the "Let's go!" button to generate test logs.
@@ -37,7 +37,9 @@ All done!
 Log into your Logtail account to check your logs.
 ```
 
-This will create a total of 6 different logs, each corresponding to a different log level and one with additional structured data. You can review these logs in Logtail.
+This will create a log for each log level, one with tags and one with additional structured data, and on Rails 8.1 and newer two events reported with `Rails.event`, next to the request, controller and template logs of the Rails integration. Click "Raise an exception" on the main page to see how an exception raised in a controller action is logged. You can review these logs in Better Stack.
+
+Stop the server with Ctrl-C. The logger sends what it still holds before the server exits.
 
 # Logging
 

data/example-project/app/controllers/example_controller.rb

@@ -38,13 +38,20 @@ class ExampleController < ApplicationController
         )
 
         # Since Rails 8.1, you can also use the Rails.event to send events with structured data to Better Stack.
-        Rails.event.notify("My first event", user_id: 123, email: "user@example.com")
-        
-        # You can add context to all events
-        Rails.event.set_context(request_id: "abc123", shop_id: 456)
-        # And tags specific events
-        Rails.event.tagged("api") do
-            Rails.event.notify("My tagged event with additional context", user_id: 123, email: "user@example.com")
+        if Rails.respond_to?(:event)
+            Rails.event.notify("My first event", user_id: 123, email: "user@example.com")
+
+            # You can add context to all events
+            Rails.event.set_context(request_id: "abc123", shop_id: 456)
+            # And tags specific events
+            Rails.event.tagged("api") do
+                Rails.event.notify("My tagged event with additional context", user_id: 123, email: "user@example.com")
+            end
         end
     end
+
+    # Exceptions raised in an action are sent to Better Stack too, with their class, message and backtrace
+    def raise_error
+        raise ArgumentError, "Something went wrong, this action raised an exception!"
+    end
 end

data/example-project/app/views/example/index.html.erb

@@ -1,3 +1,5 @@
 <h1>Hello from Logtail</h1>
 <p>Click the button below to send some example logs</p>
-<%= button_to "Let's go!", send_logs_path, method: :get %>
+<%= button_to "Let's go!", send_logs_path, method: :get %>
+<p>Or raise an exception in a controller action</p>
+<%= button_to "Raise an exception", raise_error_path, method: :get %>