Hooks

1
using LaunchDarkly.Sdk.Server.Hooks;
2
3
public class ExampleHook : Hook {
4
5
  // Implement at least one of `BeforeEvaluation`, `AfterEvaluation`
6
7
  // `BeforeEvaluation` is called during the execution of a variation method
8
  // before the flag value has been determined
9
10
  // `AfterEvaluation` is called during the execution of a variation method
11
  // after the flag value has been determined
12
13
}
14
15
var exampleHook = new ExampleHook();
16
17
var config = Configuration.Builder("YOUR_SDK_KEY")
18
  .Hooks(Components.Hooks()
19
    .Add(exampleHook)
20
  ).Build();
21
22
var client = new LdClient(config);

1
import (
2
  ld "github.com/launchdarkly/go-server-sdk/v7"
3
  "github.com/launchdarkly/go-server-sdk/v7/ldhooks"
4
)
5
6
type exampleHook struct {
7
  ldhooks.Unimplemented
8
  metadata ldhooks.Metadata
9
}
10
11
func (e exampleHook) Metadata() ldhooks.Metadata {
12
  return e.metadata
13
}
14
15
// Implement at least one of `BeforeEvaluation`, `AfterEvaluation`
16
17
// `BeforeEvaluation` is called during the execution of a variation method
18
// before the flag value has been determined
19
20
// `AfterEvaluation` is called during the execution of a variation method
21
// after the flag value has been determined
22
23
func newExampleHook() exampleHook {}
24
25
var config ld.Config
26
27
client, _ = ld.MakeCustomClient("YOUR_SDK_KEY",
28
  ld.Config{
29
    Hooks: []ldhooks.Hook{newExampleHook()},
30
  }, 5*time.Second)

1
import com.launchdarkly.sdk.server.integrations.Hook;
2
3
class ExampleHook extends Hook {
4
5
  public ExampleHook(String name) {
6
    super(name);
7
  }
8
9
  // Implement at least one of `beforeEvaluation`, `afterEvaluation`
10
11
  // `beforeEvaluation` is called during the execution of a variation method
12
  // before the flag value has been determined
13
14
  // `afterEvaluation` is called during the execution of a variation method
15
  // after the flag value has been determined
16
}
17
18
ExampleHook exampleHook = new ExampleHook("example-hook");
19
20
LDConfig config = new LDConfig.Builder()
21
    .hooks(
22
        Components.hooks().setHooks(Collections.singletonList(exampleHook)))
23
    .build();
24
25
LDClient client = new LDClient("YOUR_SDK_KEY", config);

1
export class ExampleHook implements integrations.Hook {
2
3
  getMetadata() {
4
    return { name: 'Example hook'}
5
  }
6
7
  // Implement at least one of `beforeEvaluation`, `afterEvaluation`
8
9
  // `beforeEvaluation` is called during the execution of a variation method
10
  // before the flag value has been determined
11
12
  // `afterEvaluation` is called during the execution of a variation method
13
  // after the flag value has been determined
14
}
15
16
const options: ld.LDOptions = {
17
  hooks: [new ExampleHook()]
18
};
19
20
const client = ld.init('YOUR_SDK_KEY', options);

1
const client = ld.init('YOUR_SDK_KEY', options);
2
client.addHook(new ExampleHook());

1
use LaunchDarkly\Hooks\EvaluationSeriesContext;
2
use LaunchDarkly\Hooks\Hook;
3
use LaunchDarkly\Hooks\Metadata;
4
use LaunchDarkly\Hooks\TrackSeriesContext;
5
use LaunchDarkly\EvaluationDetail;
6
use LaunchDarkly\LDClient;
7
8
class ExampleHook extends Hook
9
{
10
    public function getMetadata(): Metadata
11
    {
12
        return new Metadata('example-hook');
13
    }
14
15
    // Implement at least one of `beforeEvaluation`, `afterEvaluation`, or `afterTrack`
16
17
    // `beforeEvaluation` is called during the execution of a variation method
18
    // before the flag value has been determined
19
20
    // `afterEvaluation` is called during the execution of a variation method
21
    // after the flag value has been determined
22
23
    // `afterTrack` is called after a custom event has been enqueued by `track`
24
}
25
26
$client = new LDClient('YOUR_SDK_KEY', [
27
    'hooks' => [new ExampleHook()],
28
]);

1
$client = new LDClient('YOUR_SDK_KEY');
2
$client->addHook(new ExampleHook());

1
import ldclient
2
3
from ldclient import Config
4
from ldclient.hook import Hook, Metadata
5
6
7
class ExampleHook(Hook):
8
    @property
9
    def metadata(self) -> Metadata:
10
        return Metadata(name="example-hook")
11
12
    # Implement at least one of `before_evaluation`, `before_evaluation`
13
14
    # `before_evaluation` is called during the execution of a variation method
15
    # before the flag value has been determined
16
17
    # `after_evaluation` is called during the execution of a variation method
18
    # after the flag value has been determined
19
20
21
example_hook = ExampleHook()
22
23
config = Config("YOUR_SDK_KEY", hooks=[example_hook])
24
25
ldclient.set_config(config=config)
26
client = ldclient.get()

1
ldclient.set_config(config=config)
2
client = ldclient.get()
3
4
client.add_hook(example_hook)

1
require 'ldclient-rb'
2
3
class ExampleHook
4
  include LaunchDarkly::Interfaces::Hooks::Hook
5
6
  def metadata
7
    LaunchDarkly::Interfaces::Hooks::Metadata.new('example-hook')
8
  end
9
10
  # Implement at least one of `before_evaluation`, `after_evaluation`
11
12
  # `before_evaluation` is called during the execution of a variation method
13
  # before the flag value has been determined
14
15
  # `after_evaluation` is called during the execution of a variation method
16
  # after the flag value has been determined
17
end
18
19
example_hook = ExampleHook.new
20
21
config = LaunchDarkly::Config.new(hooks: [example_hook])
22
23
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)

1
client = LaunchDarkly::LDClient.new("YOUR_SDK_KEY", config)
2
3
client.add_hook(example_hook)

1
public class ExampleHook extends Hook {
2
3
  // Implement at least one of:
4
  //
5
  // * `beforeEvaluation` - called during the execution of a variation method
6
  // before the flag value has been determined
7
  //
8
  // * `afterEvaluation` - called during the execution of a variation method
9
  // after the flag value has been determined
10
  //
11
  // * `beforeIdentify` - called during the execution of the identify process
12
  // before the operation completes, but after any context modifications are performed
13
  //
14
  // * `afterIdentify` - called during the execution of the identify process
15
  // after the operation completes
16
  //
17
  // * `afterTrack` - called during the execution of the track process
18
  // after the event has been enqueued
19
}
20
21
List<Hook> hookList = new ArrayList<>();
22
ExampleHook exampleHook = new ExampleHook("Example hook");
23
hookList.add(exampleHook);
24
25
LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
26
    .mobileKey("example-mobile-key")
27
    .hooks(
28
      Components.hooks()
29
        .setHooks(hookList)
30
    )
31
    .build();
32
33
LDContext context = LDContext.create("example-context-key");
34
35
LDClient client = LDClient.init(this.getApplication(), ldConfig, context, 0);

1
List<Hook> hookList = new ArrayList<>();
2
ExampleHook exampleHook = new ExampleHook("Example hook");
3
hookList.add(exampleHook);
4
5
LDClient client = LDClient.init(this.getApplication(), ldConfig, context, 0);
6
client.setHooks(hookList);

1
import LaunchDarkly
2
3
class ExampleHook: Hook {
4
    func metadata() -> Metadata {
5
        return Metadata(name: "example-hook")
6
    }
7
8
    /// Implement at least one of `beforeEvaluation`, `afterEvaluation`
9
10
    /// beforeEvaluation is called during the execution of a variation method
11
    /// before the flag value has been determined
12
13
    /// afterEvaluation is called during the execution of a variation method
14
    /// after the flag value has been determined
15
}
16
17
let exampleHook = ExampleHook()
18
19
var config = LDConfig(
20
  mobileKey: "example-mobile-key",
21
  autoEnvAttributes: .enabled
22
)
23
config.hooks = [exampleHook]
24
25
let context = try! LDContextBuilder(key: "example-context-key").build().get()
26
27
LDClient.start(config: config, context: context, startWaitSeconds: 5) { timedOut in
28
    if timedOut {
29
        /// Client may not have the most recent flags for the configured context
30
    } else {
31
        /// Client has received flags for the configured context
32
    }
33
}

1
export class ExampleHook implements Hook {
2
3
  getMetadata() {
4
    return { name: 'Example hook'}
5
  }
6
7
  // Implement at least one of:
8
  //
9
  // * `beforeEvaluation` - called during the execution of a variation method
10
  // before the flag value has been determined
11
  //
12
  // * `afterEvaluation` - called during the execution of a variation method
13
  // after the flag value has been determined
14
  //
15
  // * `beforeIdentify` - called during the execution of the identify process
16
  // before the operation completes, but after any context modifications are performed
17
  //
18
  // * `afterIdentify` - called during the execution of the identify process
19
  // after the operation completes
20
  //
21
  // * `afterTrack` - called during the execution of the track process
22
  // after the event has been enqueued
23
}
24
25
const options: ld.LDOptions = {
26
  hooks: [new ExampleHook()]
27
};
28
29
const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, options);

1
const client = new ReactNativeLDClient('example-mobile-key', AutoEnvAttributes.Enabled, options);
2
client.addHook(new ExampleHook());