logbrew-sdk 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8171c73805b0809b5be561b9e315e64db5e49dc7bcc67df243a35e675bda9d36
-  data.tar.gz: e6884f90cbcc65af3873aed8aa7f2c5fa1ba3a53031d8c4ac4c3632fd2fc5a3d
+  metadata.gz: dd015a45db45c66bd30d0d2a273a9aab8c8c4ec8b4d486545bf778bb0eba8fbf
+  data.tar.gz: edc117c673cb97a6321cc0a58029673cd0ecdba0b5e2c1d48d41e71e8e967a30
 SHA512:
-  metadata.gz: 2418916010dcadc2b7df1f584111f1e8cc9aa293b74a1eb905c12b74848a95fa092e681ee6e6d30efc237992192fc21b0463abd7301ab23df12382f10b048f21
-  data.tar.gz: 2e4a4fba1bd44796895e88394bc6e12da80370a1946b36e36b1c97eb87a5ebd1db39a30d9ef55414ffecca282b9f4f6eb1ac7338b5bb236e358004aca11ce6e3
+  metadata.gz: 2b610b4733c474a40fbb55725281966fc708332f5d3215f807205ff8b31c38dafdf6ad24764b816a30d303584948a15925d48910b4b6b04e5d7cd5a90f5c516c
+  data.tar.gz: 24dbb604cebc482ccc8d9450d58e523a678d284387908bf907eb1d8f70daa1649fb8898f9a41ef27ebdfa649be67329ba3cbea1aba44745ecbda637eac7a3e82

data/README.md

@@ -1,8 +1,12 @@
 # LogBrew Ruby SDK
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/LogBrewCo/sdk/main/assets/brand/logbrew-logo-transparent-512.png" alt="LogBrew logo" width="96" height="96">
+</p>
+
 Public Ruby SDK for building, validating, previewing, and flushing LogBrew event batches, with standard-library `Net::HTTP` delivery, opt-in standard-library `Logger` support, Rack-compatible middleware, and a Rails error subscriber for Rails apps.
 
-The package uses only Ruby standard-library features at runtime. The repository checks build the gem, inspect the artifact, install it into a fresh gem home, run shipped examples, and exercise HTTP delivery plus failure/lifecycle paths like a real user.
+The package uses only Ruby standard-library features at runtime.
 
 ## Install
 
@@ -10,13 +14,6 @@ The package uses only Ruby standard-library features at runtime. The repository
 gem install logbrew-sdk
 ```
 
-For local testing from this repository:
-
-```bash
-bash scripts/check_ruby_package.sh
-bash scripts/real_user_ruby_smoke.sh
-```
-
 ## Usage
 
 ```ruby
@@ -46,6 +43,213 @@ response = client.shutdown(LogBrew::RecordingTransport.always_accept)
 warn response.status_code
 ```
 
+## First Useful Service Telemetry
+
+For a service request, combine release, environment, log, product action, network milestone, metric, and span events around one shared W3C trace:
+
+```ruby
+incoming = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
+trace = LogBrew::Traceparent.parse(incoming)
+child_span_id = "b7ad6b7169203331"
+route_template = "/checkout/:cart_id"
+session_id = "sess_checkout_123"
+
+client.log(
+  "evt_log_checkout_started",
+  "2026-06-02T10:00:02Z",
+  message: "checkout request started",
+  level: "info",
+  logger: "checkout",
+  metadata: { traceId: trace.trace_id, sessionId: session_id, routeTemplate: route_template }
+)
+client.action(
+  "evt_action_checkout_submit",
+  "2026-06-02T10:00:03Z",
+  LogBrew::ProductTimeline.product_action(
+    name: "checkout.submit",
+    route_template: "/checkout/:cart_id",
+    session_id: session_id,
+    trace_id: trace.trace_id,
+    screen: "Checkout",
+    funnel: "checkout",
+    step: "submit"
+  )
+)
+client.metric(
+  "evt_metric_http_server_duration",
+  "2026-06-02T10:00:05Z",
+  name: "http.server.duration",
+  kind: "histogram",
+  value: 183.4,
+  unit: "ms",
+  temporality: "delta",
+  metadata: { method: "POST", routeTemplate: route_template, statusCode: 202, traceId: trace.trace_id }
+)
+client.span(
+  "evt_span_checkout_request",
+  "2026-06-02T10:00:06Z",
+  LogBrew::Traceparent.span_attributes_from_traceparent(
+    trace,
+    LogBrew::TraceparentSpanInput.new(
+      name: "POST /checkout/:cart_id",
+      span_id: child_span_id,
+      duration_ms: 183.4,
+      metadata: { sampled: trace.sampled, routeTemplate: route_template, sessionId: session_id }
+    )
+  )
+)
+
+outgoing_headers = LogBrew::Traceparent.create_headers(
+  trace_id: trace.trace_id,
+  span_id: child_span_id,
+  trace_flags: trace.trace_flags
+)
+```
+
+The packaged `examples/first_useful_telemetry.rb` file shows the full flow, including release, environment, and network milestone events. Route templates stay query-free, metadata is primitive-only, and the SDK does not capture request bodies or arbitrary transport metadata.
+
+## W3C Trace Context
+
+Use `LogBrew::Traceparent` when your app already has an incoming or outgoing W3C `traceparent` value:
+
+```ruby
+trace = LogBrew::Traceparent.parse("00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01")
+headers = LogBrew::Traceparent.create_headers(
+  trace_id: trace.trace_id,
+  span_id: "b7ad6b7169203331",
+  trace_flags: trace.trace_flags
+)
+```
+
+The helper accepts W3C-shaped values, rejects forbidden or all-zero IDs, normalizes uppercase hex to lowercase, exposes the sampled flag, and creates LogBrew child span attributes with a new caller-provided span ID. It does not patch Ruby HTTP clients.
+
+## HTTP Request Trace Correlation
+
+Use `LogBrew::RackMiddleware` and `LogBrew::Trace.current` when request logs, handled errors, product actions, metrics, and the request span should share one W3C trace:
+
+```ruby
+app = lambda do |_env|
+  trace = LogBrew::Trace.current
+  logger.info("checkout started")
+  client.metric(
+    "evt_checkout_duration",
+    "2026-06-02T10:00:05Z",
+    name: "http.server.duration",
+    kind: "histogram",
+    value: 183.4,
+    unit: "ms",
+    temporality: "delta",
+    metadata: { routeTemplate: "/checkout/:cart_id", statusCode: 202 }
+  )
+  outgoing_headers = LogBrew::Trace.create_headers(trace)
+  [202, {}, ["ok"]]
+end
+
+rack = LogBrew::RackMiddleware.new(app, client: client)
+```
+
+The middleware reads only W3C `traceparent`, creates a request-local span ID, exposes `LogBrew::Trace.current` while your app runs, and uses that same span ID on the emitted request span. `LogBrew::Logger`, direct `client.log`, `client.issue`, `client.action`, `client.metric`, and `LogBrew::RailsErrorSubscriber` add active `traceId`, `spanId`, `parentSpanId`, `traceFlags`, and `traceSampled` metadata when a request trace is active. Malformed propagation falls back to a local root trace without raising into the app. Raw propagation values, request bodies, arbitrary headers, cookies, and query strings are not captured.
+
+## Dependency Operation Spans
+
+Use `LogBrew::OperationTracing` when your app owns the database, cache, or queue call and wants one correlated dependency span without monkeypatching ActiveRecord, Redis, Sidekiq, or other Ruby libraries:
+
+```ruby
+result = LogBrew::OperationTracing.database_operation(
+  client,
+  "users.lookup",
+  system: "postgresql",
+  operation: "select",
+  target: "users",
+  metadata: { service: "api", rowCount: 1 }
+) do
+  User.find_by(email: email)
+end
+```
+
+`database_operation`, `cache_operation`, and `queue_operation` run your block under a child `LogBrew::Trace` context, preserve the block result or original exception, and emit exactly one span with primitive metadata. Capture failures can be observed with `on_error:` without replacing app behavior. The helpers intentionally drop SQL statements, query params, connection strings, cache keys/values, message bodies, job IDs, headers, cookies, URLs, auth-like fields, and other sensitive-looking metadata; exception spans include only the exception type by default.
+
+## Metrics
+
+Use `metric` for explicit, application-owned measurements. LogBrew validates the metric name, kind, value, unit, temporality, and optional metadata before queueing the event:
+
+```ruby
+client.metric(
+  "evt_metric_queue_depth",
+  "2026-06-02T10:00:06Z",
+  name: "queue.depth",
+  kind: "gauge",
+  value: 42,
+  unit: "{items}",
+  temporality: "instant",
+  metadata: { service: "worker", queue: "checkout" }
+)
+```
+
+Supported metric kinds are `counter`, `gauge`, and `histogram`. Counters and histograms require `delta` or `cumulative` temporality and non-negative values; gauges require `instant` temporality and may be negative. Keep metadata low-cardinality and primitive. This SDK does not automatically collect Ruby runtime, Rack, Rails, or database metrics yet.
+
+## Product And Network Timelines
+
+Use `LogBrew::ProductTimeline` when your app already knows the product step or API milestone that matters and you want an agent-readable timeline without recording a visual session replay:
+
+```ruby
+client.action(
+  "evt_checkout_submit",
+  "2026-06-02T10:00:07Z",
+  LogBrew::ProductTimeline.product_action(
+    name: "checkout.submit",
+    route_template: "/checkout/:cart_id",
+    session_id: "session_123",
+    trace_id: "trace_123",
+    screen: "Checkout",
+    funnel: "purchase",
+    step: "submit",
+    metadata: { plan: "pro" }
+  )
+)
+
+client.action(
+  "evt_checkout_api",
+  "2026-06-02T10:00:08Z",
+  LogBrew::ProductTimeline.network_milestone(
+    route_template: "/api/checkout/:cart_id",
+    method: "POST",
+    status_code: 503,
+    duration_ms: 42.5,
+    session_id: "session_123",
+    trace_id: "trace_123",
+    metadata: { region: "iad" }
+  )
+)
+```
+
+The helpers return normal `action` attributes, so they work with the existing queue, preview, flush, and retry behavior. They accept only primitive metadata, copy it defensively, strip query strings and hashes from route templates, reduce full HTTP URLs to paths, normalize HTTP methods, and infer failed network milestones from `4xx`/`5xx` status codes. They do not patch `Net::HTTP`, capture request or response payloads, capture arbitrary headers, auto-capture clicks, or claim visual replay.
+
+## Support Ticket Draft Diagnostics
+
+Use `LogBrew::SupportTicketDraft.create` when a developer or support agent explicitly asks for a local JSON payload for the planned LogBrew support-ticket routes. The helper validates the public source/category contract, normalizes W3C trace IDs, redacts diagnostics, and returns a plain Ruby hash:
+
+```ruby
+draft = LogBrew::SupportTicketDraft.create(
+  source: "sdk",
+  category: "ingest_failure",
+  title: "Telemetry flush failed",
+  description: "Flush returned usage_limit_exceeded",
+  sdk_package: "logbrew-sdk",
+  sdk_version: "0.1.0",
+  trace_id: "4BF92F3577B34DA6A3CE929D0E0E4736",
+  diagnostics: {
+    endpoint: "https://api.example/ingest?debug=true",
+    apiKey: "lbw_ingest_redacted",
+    error: RuntimeError.new("hidden token")
+  }
+)
+
+puts JSON.generate(draft)
+```
+
+This helper is local-only. It does not send data, open a ticket, call backend support-ticket routes, use account/session API credentials, or infer backend ownership. Diagnostics are bounded to JSON-like values; token-like keys and strings are redacted, HTTP URLs keep only the path, local filesystem paths are replaced, exceptions keep only the class name, and unsupported Ruby objects are omitted.
+
 ## HTTP Delivery
 
 Use `LogBrew::HttpTransport` when you want the SDK to POST queued batches to LogBrew:
@@ -72,20 +276,9 @@ warn response.status_code
 
 `HttpTransport` sends JSON with the SDK key in the `authorization` header, supports a custom endpoint, headers, timeout, and app-owned HTTP client object, maps HTTP statuses through the client's retry rules, and converts request/time-out failures into retryable transport errors.
 
-## Examples
-
-From `ruby/logbrew-ruby`:
-
-```bash
-cd examples && make
-cd examples && make run-readme-example
-cd examples && make run
-cd examples && make run-real-user-smoke
-ruby examples/readme_example.rb
-ruby examples/real_user_smoke.rb
-```
+## Example Source
 
-`make run` is the shorter alias for the stronger real-user smoke example.
+The `examples` directory contains copyable snippets for creating a client, sending through `HttpTransport`, using the standard logger wrapper, attaching Rack middleware, and subscribing to Rails errors in your own Ruby app.
 
 ## Standard Logger
 
@@ -113,7 +306,7 @@ logger.error(RuntimeError.new("payment failed"))
 client.flush(LogBrew::RecordingTransport.always_accept)
 ```
 
-The adapter respects Ruby logger levels and lazy block messages, maps `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`, and `UNKNOWN` to LogBrew log levels, captures `progname`, primitive base metadata, and exception type/message, and omits exception backtrace text unless `include_exception_backtrace: true` is set. Logs queue by default; pass `transport:` plus `flush_on_log: true` or call `flush_logbrew` for immediate delivery.
+The adapter respects Ruby logger levels and lazy block messages, maps `DEBUG`/`INFO` to LogBrew `info`, `WARN` to `warning`, `ERROR` to `error`, and `FATAL` to `critical`, captures `progname`, primitive base metadata, and exception type/message, and omits exception backtrace text unless `include_exception_backtrace: true` is set. Logs queue by default; pass `transport:` plus `flush_on_log: true` or call `flush_logbrew` for immediate delivery.
 
 ## Rack And Rails Middleware
 
@@ -179,9 +372,12 @@ The subscriber implements `report(error, handled:, severity:, context:, source:,
 
 - `preview_json` returns the queued batch as pretty JSON.
 - `flush(transport)` sends queued events, retries retryable failures, and clears the queue only after a 2xx response.
+- `metric(...)` queues explicit, application-owned metric events with name, kind, value, unit, temporality, and low-cardinality metadata validation.
+- `LogBrew::ProductTimeline` builds explicit, application-owned product action and network milestone timeline events with primitive metadata and query/hash-free routes.
+- `LogBrew::SupportTicketDraft.create` builds explicit, local-only support-ticket create payload drafts with redacted diagnostics and no backend route calls.
 - `LogBrew::HttpTransport` sends queued batches through Ruby's standard `Net::HTTP` with configurable endpoint, headers, timeout, and app-owned HTTP client support.
 - `LogBrew::RackMiddleware` captures Rack request spans and unhandled app exceptions without requiring Rails or Rack at runtime.
 - `LogBrew::RailsErrorSubscriber` captures handled/manual Rails error reports without requiring Rails at runtime.
 - `shutdown(transport)` flushes queued events and rejects later writes.
-- `LogBrew::RecordingTransport.always_accept` is useful for local examples and tests.
+- `LogBrew::RecordingTransport.always_accept` is useful when you want to inspect queued JSON before network delivery.
 - `LogBrew::SdkError` exposes stable `code` and `message` values for user-facing failure handling.

data/examples/Makefile

@@ -1,9 +1,11 @@
-.PHONY: help run run-readme-example run-real-user-smoke
+.PHONY: help run run-readme-example run-real-user-smoke run-first-useful-telemetry run-http-trace-correlation
 
 help:
 	@printf '%s\n' 'run-readme-example -> make run-readme-example'
 	@printf '%s\n' 'run (real-user-smoke) -> make run'
 	@printf '%s\n' 'run-real-user-smoke -> make run-real-user-smoke'
+	@printf '%s\n' 'run-first-useful-telemetry -> make run-first-useful-telemetry'
+	@printf '%s\n' 'run-http-trace-correlation -> make run-http-trace-correlation'
 
 run: run-real-user-smoke
 
@@ -12,3 +14,9 @@ run-readme-example:
 
 run-real-user-smoke:
 	@ruby real_user_smoke.rb
+
+run-first-useful-telemetry:
+	@ruby first_useful_telemetry.rb
+
+run-http-trace-correlation:
+	@ruby http_trace_correlation.rb

data/examples/first_useful_telemetry.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "json"
+require "logbrew"
+
+incoming_traceparent = "00-4BF92F3577B34DA6A3CE929D0E0E4736-00F067AA0BA902B7-01"
+trace_context = LogBrew::Traceparent.parse(incoming_traceparent)
+child_span_id = "b7ad6b7169203331"
+outgoing_headers = LogBrew::Traceparent.create_headers(
+  trace_id: trace_context.trace_id,
+  span_id: child_span_id,
+  trace_flags: trace_context.trace_flags
+)
+session_id = "sess_checkout_123"
+route_template = "/checkout/:cart_id"
+
+client = LogBrew::Client.create(
+  api_key: "LOGBREW_API_KEY",
+  sdk_name: "checkout-service",
+  sdk_version: "1.2.3"
+)
+client.release(
+  "evt_release_checkout",
+  "2026-06-02T10:00:00Z",
+  version: "1.2.3",
+  commit: "abc123def456",
+  metadata: { service: "checkout-service" }
+)
+client.environment(
+  "evt_environment_checkout",
+  "2026-06-02T10:00:01Z",
+  name: "production",
+  region: "global",
+  metadata: { service: "checkout-service" }
+)
+client.log(
+  "evt_log_checkout_started",
+  "2026-06-02T10:00:02Z",
+  message: "checkout request started",
+  level: "info",
+  logger: "checkout",
+  metadata: {
+    traceId: trace_context.trace_id,
+    sessionId: session_id,
+    routeTemplate: route_template
+  }
+)
+client.action(
+  "evt_action_checkout_submit",
+  "2026-06-02T10:00:03Z",
+  LogBrew::ProductTimeline.product_action(
+    name: "checkout.submit",
+    route_template: "https://shop.example/checkout/:cart_id?coupon=sample#review",
+    session_id: session_id,
+    trace_id: trace_context.trace_id,
+    screen: "Checkout",
+    funnel: "checkout",
+    step: "submit",
+    metadata: { cartTier: "gold" }
+  )
+)
+client.action(
+  "evt_action_payment_api",
+  "2026-06-02T10:00:04Z",
+  LogBrew::ProductTimeline.network_milestone(
+    route_template: "https://api.example/payments/:payment_id?card=sample",
+    method: "post",
+    status_code: 202,
+    duration_ms: 183.4,
+    session_id: session_id,
+    trace_id: trace_context.trace_id,
+    metadata: { dependency: "payments" }
+  )
+)
+client.metric(
+  "evt_metric_http_server_duration",
+  "2026-06-02T10:00:05Z",
+  name: "http.server.duration",
+  kind: "histogram",
+  value: 183.4,
+  unit: "ms",
+  temporality: "delta",
+  metadata: {
+    method: "POST",
+    routeTemplate: route_template,
+    statusCode: 202,
+    traceId: trace_context.trace_id
+  }
+)
+client.span(
+  "evt_span_checkout_request",
+  "2026-06-02T10:00:06Z",
+  LogBrew::Traceparent.span_attributes_from_traceparent(
+    trace_context,
+    LogBrew::TraceparentSpanInput.new(
+      name: "POST /checkout/:cart_id",
+      span_id: child_span_id,
+      duration_ms: 183.4,
+      metadata: {
+        sampled: trace_context.sampled,
+        routeTemplate: route_template,
+        sessionId: session_id
+      }
+    )
+  )
+)
+
+puts client.preview_json
+
+transport = LogBrew::RecordingTransport.always_accept
+response = client.shutdown(transport)
+warn JSON.generate(
+  ok: true,
+  status: response.status_code,
+  attempts: response.attempts,
+  events: 7,
+  outgoingTraceparent: outgoing_headers.fetch("traceparent")
+)

data/examples/http_trace_correlation.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "json"
+require "logbrew"
+
+incoming_traceparent = "00-4BF92F3577B34DA6A3CE929D0E0E4736-00F067AA0BA902B7-01"
+route_template = "/checkout/:cart_id"
+
+client = LogBrew::Client.create(
+  api_key: "LOGBREW_API_KEY",
+  sdk_name: "checkout-rack-app",
+  sdk_version: "1.2.3"
+)
+client.release(
+  "evt_release_checkout_trace",
+  "2026-06-02T10:00:00Z",
+  version: "1.2.3",
+  commit: "abc123def456",
+  metadata: { service: "checkout" }
+)
+client.environment(
+  "evt_environment_checkout_trace",
+  "2026-06-02T10:00:01Z",
+  name: "production",
+  region: "global",
+  metadata: { service: "checkout" }
+)
+
+logger = LogBrew::Logger.new(
+  client: client,
+  logger_name: "checkout",
+  event_id_prefix: "ruby_http_trace",
+  metadata: { service: "checkout", ignored: [] },
+  timestamp_provider: -> { Time.utc(2026, 6, 2, 10, 0, 2) }
+)
+
+app = lambda do |env|
+  trace = LogBrew::Trace.current
+  raise "missing active trace" unless trace
+
+  logger.warn("checkout request is slow")
+  client.issue(
+    "evt_issue_checkout_trace",
+    "2026-06-02T10:00:03Z",
+    title: "PaymentProviderWarning",
+    level: "warning",
+    message: "payment provider latency crossed threshold",
+    metadata: { routeTemplate: route_template }
+  )
+  client.action(
+    "evt_action_checkout_trace",
+    "2026-06-02T10:00:04Z",
+    LogBrew::ProductTimeline.product_action(
+      name: "checkout.submit",
+      status: "running",
+      route_template: "https://shop.example/checkout/:cart_id?coupon=sample#review",
+      metadata: { cartTier: "gold" }
+    )
+  )
+  client.metric(
+    "evt_metric_checkout_trace",
+    "2026-06-02T10:00:05Z",
+    name: "http.server.duration",
+    kind: "histogram",
+    value: 183.4,
+    unit: "ms",
+    temporality: "delta",
+    metadata: { routeTemplate: route_template, statusCode: 202 }
+  )
+  env["logbrew.outgoing_traceparent"] = LogBrew::Trace.create_headers(trace).fetch("traceparent")
+  [202, { "content-type" => "text/plain" }, ["accepted"]]
+end
+
+rack = LogBrew::RackMiddleware.new(
+  app,
+  client: client,
+  event_id_prefix: "ruby_http_trace",
+  metadata: { service: "checkout", ignored: [] },
+  timestamp_provider: -> { Time.utc(2026, 6, 2, 10, 0, 6) }
+)
+env = {
+  "REQUEST_METHOD" => "POST",
+  "PATH_INFO" => route_template,
+  "QUERY_STRING" => "coupon=sample",
+  "HTTP_TRACEPARENT" => incoming_traceparent
+}
+response = rack.call(env)
+raise "unexpected Rack response" unless response[0] == 202
+
+puts client.preview_json
+transport = LogBrew::RecordingTransport.always_accept
+flush_response = client.shutdown(transport)
+warn JSON.generate(
+  ok: true,
+  status: flush_response.status_code,
+  attempts: flush_response.attempts,
+  events: 7,
+  outgoingTraceparent: env.fetch("logbrew.outgoing_traceparent")
+)

data/examples/real_user_smoke.rb

@@ -29,6 +29,19 @@ retry_response = retry_client.flush(
   LogBrew::RecordingTransport.new([LogBrew::TransportError.network("temporary outage"), 202])
 )
 
+support_draft = LogBrew::SupportTicketDraft.create(
+  source: "sdk",
+  category: "ingest_failure",
+  title: "Telemetry flush failed",
+  description: "Flush returned usage_limit_exceeded",
+  trace_id: "4BF92F3577B34DA6A3CE929D0E0E4736",
+  diagnostics: {
+    apiKey: "lbw_ingest_hidden",
+    endpoint: "https://api.example/ingest?debug=true#frag",
+    error: RuntimeError.new("contains hidden token")
+  }
+)
+
 rejected_after_shutdown = false
 begin
   client.action("evt_action_002", "2026-06-02T10:00:06Z", name: "deploy", status: "success")
@@ -41,5 +54,7 @@ $stderr.puts JSON.generate(
   status: response.status_code,
   attempts: response.attempts,
   retryAttempts: retry_response.attempts,
+  supportDraftRedacted: support_draft.dig("diagnostics", "apiKey") == "[redacted]",
+  supportDraftTrace: support_draft.fetch("trace_id"),
   events: 6
 )