1use std::{
2 net::SocketAddr,
3 time::{Duration, SystemTime},
4};
5
6use super::envoy::{Attributes, ListenerDirection, Metadata, Node};
7
8#[derive(Debug)]
9pub struct AllAttributes {
10 pub request: AllRequestAttributes,
11 pub response: AllResponseAttributes,
12 pub connection: AllConnectionAttributes,
13 pub upstream: AllUpstreamAttributes,
14 pub metadata: AllMetadataAttributes,
15 pub configuration: AllConfigurationAttributes,
16 pub wasm: AllWasmAttributes,
17}
18
19impl AllAttributes {
20 pub fn get(a: &Attributes) -> Self {
21 Self {
22 request: AllRequestAttributes::get(a),
23 response: AllResponseAttributes::get(a),
24 connection: AllConnectionAttributes::get(a),
25 upstream: AllUpstreamAttributes::get(a),
26 metadata: AllMetadataAttributes::get(a),
27 configuration: AllConfigurationAttributes::get(a),
28 wasm: AllWasmAttributes::get(a),
29 }
30 }
31}
32
33#[derive(Debug)]
34pub struct AllRequestAttributes {
35 pub path: Option<String>,
36 pub url_path: Option<String>,
37 pub host: Option<String>,
38 pub scheme: Option<String>,
39 pub method: Option<String>,
40 pub headers: Option<Vec<(String, Vec<u8>)>>,
41 pub referer: Option<String>,
42 pub useragent: Option<String>,
43 pub time: Option<SystemTime>,
44 pub id: Option<String>,
45 pub protocol: Option<String>,
46 pub query: Option<String>,
47 pub duration: Option<Duration>,
48 pub size: Option<usize>,
49 pub total_size: Option<usize>,
50}
51
52impl AllRequestAttributes {
53 fn get(a: &Attributes) -> Self {
54 Self {
55 path: a.request.path(),
56 url_path: a.request.url_path(),
57 host: a.request.host(),
58 scheme: a.request.scheme(),
59 method: a.request.method(),
60 headers: a.request.headers(),
61 referer: a.request.referer(),
62 useragent: a.request.useragent(),
63 time: a.request.time(),
64 id: a.request.id(),
65 protocol: a.request.protocol(),
66 query: a.request.query(),
67 duration: a.request.duration(),
68 size: a.request.size(),
69 total_size: a.request.total_size(),
70 }
71 }
72}
73
74#[derive(Debug)]
75pub struct AllResponseAttributes {
76 pub code: Option<u32>,
77 pub code_details: Option<String>,
78 pub flags: Option<u64>,
79 pub grpc_status: Option<u32>,
80 pub headers: Option<Vec<(String, Vec<u8>)>>,
81 pub trailers: Option<Vec<(String, Vec<u8>)>>,
82 pub size: Option<usize>,
83 pub total_size: Option<usize>,
84}
85
86impl AllResponseAttributes {
87 fn get(a: &Attributes) -> Self {
88 Self {
89 code: a.response.code(),
90 code_details: a.response.code_details(),
91 flags: a.response.flags(),
92 grpc_status: a.response.grpc_status(),
93 headers: a.response.headers(),
94 trailers: a.response.trailers(),
95 size: a.response.size(),
96 total_size: a.response.total_size(),
97 }
98 }
99}
100
101#[derive(Debug)]
102pub struct AllConnectionAttributes {
103 pub source_address: Option<SocketAddr>,
104 pub source_port: Option<u16>,
105 pub destination_address: Option<SocketAddr>,
106 pub destination_port: Option<u16>,
107 pub id: Option<u64>,
108 pub mtls: Option<bool>,
109 pub requested_server_name: Option<String>,
110 pub tls_version: Option<String>,
111 pub subject_local_certificate: Option<String>,
112 pub subject_peer_certificate: Option<String>,
113 pub dns_san_local_certificate: Option<String>,
114 pub dns_san_peer_certificate: Option<String>,
115 pub uri_san_local_certificate: Option<String>,
116 pub uri_san_peer_certificate: Option<String>,
117 pub sha256_peer_certificate_digest: Option<String>,
118 pub termination_details: Option<String>,
119}
120
121impl AllConnectionAttributes {
122 fn get(a: &Attributes) -> Self {
123 Self {
124 source_address: a.connection.source_address(),
125 source_port: a.connection.source_port(),
126 destination_address: a.connection.destination_address(),
127 destination_port: a.connection.destination_port(),
128 id: a.connection.id(),
129 mtls: a.connection.mtls(),
130 requested_server_name: a.connection.requested_server_name(),
131 tls_version: a.connection.tls_version(),
132 subject_local_certificate: a.connection.subject_local_certificate(),
133 subject_peer_certificate: a.connection.subject_peer_certificate(),
134 dns_san_local_certificate: a.connection.dns_san_local_certificate(),
135 dns_san_peer_certificate: a.connection.dns_san_peer_certificate(),
136 uri_san_local_certificate: a.connection.uri_san_local_certificate(),
137 uri_san_peer_certificate: a.connection.uri_san_peer_certificate(),
138 sha256_peer_certificate_digest: a.connection.sha256_peer_certificate_digest(),
139 termination_details: a.connection.termination_details(),
140 }
141 }
142}
143
144#[derive(Debug)]
145pub struct AllUpstreamAttributes {
146 pub address: Option<SocketAddr>,
147 pub port: Option<u16>,
148 pub tls_version: Option<String>,
149 pub subject_local_certificate: Option<String>,
150 pub subject_peer_certificate: Option<String>,
151 pub dns_san_local_certificate: Option<String>,
152 pub dns_san_peer_certificate: Option<String>,
153 pub uri_san_local_certificate: Option<String>,
154 pub uri_san_peer_certificate: Option<String>,
155 pub sha256_peer_certificate_digest: Option<String>,
156 pub local_address: Option<String>,
157 pub transport_failure_reason: Option<String>,
158}
159
160impl AllUpstreamAttributes {
161 fn get(a: &Attributes) -> Self {
162 Self {
163 address: a.upstream.address(),
164 port: a.upstream.port(),
165 tls_version: a.upstream.tls_version(),
166 subject_local_certificate: a.upstream.subject_local_certificate(),
167 subject_peer_certificate: a.upstream.subject_peer_certificate(),
168 dns_san_local_certificate: a.upstream.dns_san_local_certificate(),
169 dns_san_peer_certificate: a.upstream.dns_san_peer_certificate(),
170 uri_san_local_certificate: a.upstream.uri_san_local_certificate(),
171 uri_san_peer_certificate: a.upstream.uri_san_peer_certificate(),
172 sha256_peer_certificate_digest: a.upstream.sha256_peer_certificate_digest(),
173 local_address: a.upstream.local_address(),
174 transport_failure_reason: a.upstream.transport_failure_reason(),
175 }
176 }
177}
178
179#[derive(Debug)]
180pub struct AllMetadataAttributes {
181 pub metadata: Option<Metadata>,
182 pub filter_state: Option<Vec<(String, Vec<u8>)>>,
183}
184
185impl AllMetadataAttributes {
186 fn get(a: &Attributes) -> Self {
187 Self {
188 metadata: a.metadata.metadata(),
189 filter_state: a.metadata.filter_state(),
190 }
191 }
192}
193
194#[derive(Debug)]
195pub struct AllConfigurationAttributes {
196 pub cluster_name: Option<String>,
197 pub cluster_metadata: Option<Metadata>,
198 pub route_name: Option<String>,
199 pub route_metadata: Option<Metadata>,
200 pub upstream_host_metadata: Option<Metadata>,
201 pub filter_chain_name: Option<String>,
202}
203
204impl AllConfigurationAttributes {
205 fn get(a: &Attributes) -> Self {
206 Self {
207 cluster_name: a.configuration.cluster_name(),
208 cluster_metadata: a.configuration.cluster_metadata(),
209 route_name: a.configuration.route_name(),
210 route_metadata: a.configuration.route_metadata(),
211 upstream_host_metadata: a.configuration.upstream_host_metadata(),
212 filter_chain_name: a.configuration.filter_chain_name(),
213 }
214 }
215}
216
217#[derive(Debug)]
218pub struct AllWasmAttributes {
219 pub plugin_name: Option<String>,
220 pub plugin_root_id: Option<String>,
221 pub plugin_vm_id: Option<String>,
222 pub node: Option<Node>,
223 pub cluster_name: Option<String>,
224 pub cluster_metadata: Option<Metadata>,
225 pub listener_direction: Option<ListenerDirection>,
226 pub listener_metadata: Option<Metadata>,
227 pub route_name: Option<String>,
228 pub route_metadata: Option<Metadata>,
229 pub upstream_host_metadata: Option<Metadata>,
230}
231
232impl AllWasmAttributes {
233 fn get(a: &Attributes) -> Self {
234 Self {
235 plugin_name: a.wasm.plugin_name(),
236 plugin_root_id: a.wasm.plugin_root_id(),
237 plugin_vm_id: a.wasm.plugin_vm_id(),
238 node: a.wasm.node(),
239 cluster_name: a.wasm.cluster_name(),
240 cluster_metadata: a.wasm.cluster_metadata(),
241 listener_direction: a.wasm.listener_direction(),
242 listener_metadata: a.wasm.listener_metadata(),
243 route_name: a.wasm.route_name(),
244 route_metadata: a.wasm.route_metadata(),
245 upstream_host_metadata: a.wasm.upstream_host_metadata(),
246 }
247 }
248}