Ruby

1
gem "schematichq"

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
# interactions with the client
7
8
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
cache_size = 100
5
cache_ttl = 1.0 # in seconds
6
client = Schematic::SchematicClient.new(
7
  api_key: api_key,
8
  cache_providers: [
9
    Schematic::LocalCache.new(max_size: cache_size, ttl: cache_ttl)
10
  ]
11
)
12
13
# interactions with the client
14
15
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(
5
  api_key: api_key,
6
  cache_providers: []
7
)
8
9
# interactions with the client
10
11
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(
5
  api_key: api_key,
6
  flag_defaults: {
7
    "some-flag-key" => true
8
  }
9
)
10
11
# interactions with the client
12
13
client.close

1
require "schematichq"
2
3
class CustomLogger
4
  include Schematic::Logger
5
6
  def error(message, *args)
7
    # Your custom error logging logic
8
  end
9
10
  def warn(message, *args)
11
    # Your custom warning logging logic
12
  end
13
14
  def info(message, *args)
15
    # Your custom info logging logic
16
  end
17
18
  def debug(message, *args)
19
    # Your custom debug logging logic
20
  end
21
end
22
23
api_key = ENV["SCHEMATIC_API_KEY"]
24
client = Schematic::SchematicClient.new(
25
  api_key: api_key,
26
  logger: CustomLogger.new
27
)
28
29
# interactions with the client
30
31
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(
5
  api_key: api_key,
6
  logger: Schematic::ConsoleLogger.new(level: :debug)
7
)

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
client.identify({
7
  company: {
8
    keys: { "id" => "your-company-id" },
9
    name: "Acme, Inc.",
10
    traits: { "city" => "Atlanta" }
11
  },
12
  keys: {
13
    "email" => "wcoyote@acme.net",
14
    "user_id" => "your-user-id"
15
  },
16
  name: "Wile E. Coyote",
17
  traits: {
18
    "enemy" => "Bugs Bunny",
19
    "login_count" => 24,
20
    "is_staff" => false
21
  }
22
})
23
24
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
client.track({
7
  event: "some-action",
8
  company: { "id" => "your-company-id" },
9
  user: {
10
    "email" => "wcoyote@acme.net",
11
    "user_id" => "your-user-id"
12
  }
13
})
14
15
client.close

1
client.track({
2
  event: "query-tokens",
3
  company: { "id" => "your-company-id" },
4
  user: {
5
    "email" => "wcoyote@acme.net",
6
    "user_id" => "your-user-id"
7
  },
8
  quantity: 1500
9
})

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
response = client.companies.upsert_company(
7
  keys: { "id" => "your-company-id" },
8
  name: "Acme Widgets, Inc.",
9
  traits: {
10
    "city" => "Atlanta",
11
    "high_score" => 25,
12
    "is_active" => true
13
  }
14
)
15
puts response.data
16
17
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
response = client.companies.upsert_user(
7
  keys: {
8
    "email" => "wcoyote@acme.net",
9
    "user_id" => "your-user-id"
10
  },
11
  company: { "id" => "your-company-id" },
12
  name: "Wile E. Coyote",
13
  traits: {
14
    "city" => "Atlanta",
15
    "login_count" => 24,
16
    "is_staff" => false
17
  }
18
)
19
puts response.data
20
21
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
is_flag_on = client.check_flag(
7
  "some-flag-key",
8
  company: { "id" => "your-company-id" },
9
  user: {
10
    "email" => "wcoyote@acme.net",
11
    "user_id" => "your-user-id"
12
  }
13
)
14
15
if is_flag_on
16
  # Flag is on
17
else
18
  # Flag is off
19
end
20
21
client.close

1
require "schematichq"
2
3
api_key = ENV["SCHEMATIC_API_KEY"]
4
client = Schematic::SchematicClient.new(api_key: api_key)
5
6
resp = client.check_flag_with_entitlement(
7
  "some-flag-key",
8
  company: { "id" => "your-company-id" },
9
  user: {
10
    "email" => "wcoyote@acme.net",
11
    "user_id" => "your-user-id"
12
  }
13
)
14
15
puts "Flag: #{resp.flag_key}, Value: #{resp.value}, Reason: #{resp.reason}"
16
17
if resp.entitlement
18
  puts "Feature allocation: #{resp.feature_allocation}"
19
  puts "Feature usage: #{resp.feature_usage}"
20
end
21
22
client.close

1
require "schematichq"
2
3
webhook_secret = "your-webhook-secret" # Get this from the Schematic app
4
5
# Verify a signature directly
6
Schematic::Webhooks.verify_signature(payload, signature, timestamp, webhook_secret)
7
# Raises Schematic::Webhooks::InvalidSignatureError if the signature is invalid
8
# Raises Schematic::Webhooks::MissingSignatureError if the signature is missing
9
# Raises Schematic::Webhooks::MissingTimestampError if the timestamp is missing

1
hex_sig = Schematic::Webhooks.compute_hex_signature(body, timestamp, secret)

1
# In a Rails controller
2
class WebhooksController < ApplicationController
3
  skip_before_action :verify_authenticity_token
4
5
  def create
6
    webhook_secret = ENV["SCHEMATIC_WEBHOOK_SECRET"]
7
8
    begin
9
      Schematic::Webhooks.verify_webhook_request(request, webhook_secret)
10
11
      # Signature is valid, process the webhook
12
      payload = JSON.parse(request.raw_post)
13
      # ... handle the event ...
14
15
      head :ok
16
    rescue Schematic::Webhooks::WebhookSignatureError => e
17
      render json: { error: e.message }, status: :bad_request
18
    end
19
  end
20
end

1
require "sinatra"
2
require "schematichq"
3
4
post "/webhooks/schematic" do
5
  webhook_secret = ENV["SCHEMATIC_WEBHOOK_SECRET"]
6
7
  begin
8
    Schematic::Webhooks.verify_webhook_request(request, webhook_secret)
9
10
    payload = JSON.parse(request.body.read)
11
    request.body.rewind
12
    # ... handle the event ...
13
14
    status 200
15
    json status: "ok"
16
  rescue Schematic::Webhooks::WebhookSignatureError => e
17
    status 400
18
    json error: e.message
19
  end
20
end

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(
4
  api_key: ENV["SCHEMATIC_API_KEY"],
5
  use_data_stream: true
6
)
7
8
# Flag checks are now evaluated locally
9
is_flag_on = client.check_flag(
10
  "some-flag-key",
11
  company: { "id" => "your-company-id" }
12
)
13
14
client.close

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(
4
  api_key: ENV["SCHEMATIC_API_KEY"],
5
  use_data_stream: true,
6
  datastream_options: {
7
    cache_ttl: 3600 # 1 hour
8
  }
9
)

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(
4
  api_key: ENV["SCHEMATIC_API_KEY"],
5
  use_data_stream: true,
6
  datastream_options: {
7
    replicator_mode: true,
8
    replicator_health_url: "http://localhost:8090/ready",
9
    replicator_health_interval: 30
10
  }
11
)
12
13
# Flag checks use the shared cache
14
is_flag_on = client.check_flag(
15
  "some-flag-key",
16
  company: { "id" => "your-company-id" }
17
)
18
19
client.close

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(offline: true)
4
5
client.close

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new
4
# Logs a warning and automatically enables offline mode
5
6
client.close

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(
4
  offline: true,
5
  flag_defaults: { "some-flag-key" => true }
6
)
7
8
# interactions with the client
9
10
client.close

1
require "schematichq"
2
3
# In your test setup
4
client = Schematic::SchematicClient.new(offline: true)
5
client.set_flag_default("some-flag-key", true)
6
7
# test code that expects the flag to be on
8
assert client.check_flag("some-flag-key")
9
10
client.close

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(api_key: ENV["SCHEMATIC_API_KEY"])
4
5
begin
6
  result = client.accounts.create_api_key(name: "name")
7
rescue Schematic::Errors::TimeoutError
8
  puts "API didn't respond before our timeout elapsed"
9
rescue Schematic::Errors::ServiceUnavailableError
10
  puts "API returned status 503, is probably overloaded, try again later"
11
rescue Schematic::Errors::ServerError
12
  puts "API returned some other 5xx status, this is probably a bug"
13
rescue Schematic::Errors::ResponseError => e
14
  puts "API returned an unexpected status other than 5xx: #{e.code} #{e.message}"
15
rescue Schematic::Errors::ApiError => e
16
  puts "Some other error occurred when calling the API: #{e.message}"
17
end

1
require "schematichq"
2
3
client = Schematic::SchematicClient.new(
4
  api_key: ENV["SCHEMATIC_API_KEY"],
5
  max_retries: 3 # Configure max retries (default is 2)
6
)

1
response = client.accounts.create_api_key(
2
  name: "name",
3
  timeout: 30 # 30 second timeout
4
)