编写本地 Rust 插件

1
use apollo_router::plugin::Plugin;
2
use apollo_router::register_plugin;
3
use apollo_router::services::*;
4
use schemars::JsonSchema;
5
use serde::Deserialize;
6
use tower::{BoxError, ServiceBuilder, ServiceExt};

1
#[derive(Debug, Default, Deserialize, JsonSchema)]
2
struct Conf {
3
    // Put your plugin configuration here. It's deserialized from YAML automatically.
4
}

1
#[async_trait::async_trait]
2
impl Plugin for HelloWorld {
3
    type Config = Conf;
4
}

1
// This is a bare-bones plugin that you can duplicate when creating your own.
2
use apollo_router::plugin::PluginInit;
3
use apollo_router::plugin::Plugin;
4
use apollo_router::services::*;
5

6
#[async_trait::async_trait]
7
impl Plugin for HelloWorld {
8
    type Config = Conf;
9

10
    // This is invoked once after the router starts and compiled-in
11
    // plugins are registered
12
    fn new(init: PluginInit<Self::Config>) -> Result<Self, BoxError> {
13
        Ok(HelloWorld { configuration: init.config })
14
    }
15

16
    // Only define the hooks you need to modify. Each default hook
17
    // implementation returns its associated service with no changes.
18
    fn router_service(
19
        &self,
20
        service: router::BoxService,
21
    ) -> router::BoxService {
22
        service
23
    }
24

25
    fn supergraph_service(
26
        &self,
27
        service: supergraph::BoxService,
28
    ) -> supergraph::BoxService {
29
        service
30
    }
31

32
    fn execution_service(
33
        &self,
34
        service: execution::BoxService,
35
    ) -> execution::BoxService {
36
        service
37
    }
38

39
    // Unlike other hooks, this hook also passes the name of the subgraph
40
    // being invoked. That's because this service might invoke *multiple*
41
    // subgraphs for a single request, and this is called once for each.
42
    fn subgraph_service(
43
        &self,
44
        name: &str,
45
        service: subgraph::BoxService,
46
    ) -> subgraph::BoxService {
47
        service
48
    }
49
}

1
// Replaces the default definition in the example above
2
use tower::ServiceBuilderExt;
3
use apollo_router::ServiceBuilderExt as ApolloServiceBuilderExt;
4

5
fn supergraph_service(
6
    &self,
7
    service: router::BoxService,
8
) -> router::BoxService {
9
    // Always use service builder to compose your plugins.
10
    // It provides off-the-shelf building blocks for your plugin.
11
    ServiceBuilder::new()
12
        // Some example service builder methods:
13
        // .map_request()
14
        // .map_response()
15
        // .rate_limit()
16
        // .checkpoint()
17
        // .timeout()
18
        .service(service)
19
        .boxed()
20
}

1
context.insert("key1", 1)?;

1
let value : u32 = context.get("key1")?;

1
context.upsert("key1", |v: u32| v + 1)?;

1
let _guard = context.enter_active_request();
2
http_client.request().await;
3
drop(_guard);

1
register_plugin!("example", "hello_world", HelloWorld);

1
plugins:
2
  example.hello_world:
3
    # Any values here are passed to the plugin as part of your configuration

1
use tracing::info;
2

3
let loading_time = std::time::Instant::now();
4

5
info!(monotonic_counter.foo = 1, my_custom_label = "bar"); // Will increment the monotonic counter foo by 1
6
// Generated metric for the example above in prometheus
7
// foo{my_custom_label="bar"} 1
8
info!(monotonic_counter.bar = 1.1);
9

10
info!(counter.baz = 1, name = "baz"); // Will increment the counter baz by 1
11
info!(counter.baz = -1); // Will decrement the counter baz by 1
12
info!(counter.xyz = 1.1);
13

14
info!(value.qux = 1);
15
info!(value.abc = -1);
16
info!(value.def = 1.1);
17

18
let caller = "router";
19
tracing::info!(
20
    histogram.loading_time = loading_time.elapsed().as_secs_f64(),
21
    kind = %caller, // Custom attribute for the metrics
22
);

1
use tracing::info_span;
2

3
info_span!("my_span");