fluent-plugin-geoip 0.6.1 → 0.7.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (17) hide show
  1. checksums.yaml +4 -4
  2. data/.travis.yml +31 -20
  3. data/Appraisals +0 -4
  4. data/README.md +50 -11
  5. data/docker-compose.yml +31 -0
  6. data/dockerfiles/Dockerfile-ruby2.1 +8 -0
  7. data/dockerfiles/Dockerfile-ruby2.2 +8 -0
  8. data/dockerfiles/Dockerfile-ruby2.3 +8 -0
  9. data/dockerfiles/Dockerfile-ruby2.4 +8 -0
  10. data/fluent-plugin-geoip.gemspec +4 -2
  11. data/lib/fluent/plugin/filter_geoip.rb +4 -6
  12. data/lib/fluent/plugin/geoip.rb +47 -18
  13. data/lib/fluent/plugin/out_geoip.rb +3 -15
  14. data/test/plugin/test_filter_geoip.rb +957 -380
  15. data/test/plugin/test_out_geoip.rb +1035 -385
  16. metadata +49 -3
  17. data/gemfiles/fluentd_v0.10.gemfile +0 -8
data/test/plugin/test_out_geoip.rb CHANGED
@@ -5,436 +5,1086 @@ class GeoipOutputTest < Test::Unit::TestCase
5
5
  Fluent::Test.setup
6
6
  end
7
7
 
8
- CONFIG = %[
9
- geoip_lookup_key host
10
- enable_key_city geoip_city
11
- remove_tag_prefix input.
12
- tag geoip.${tag}
13
- ]
14
-
15
- def create_driver(conf=CONFIG,tag='test',use_v1=false)
16
- Fluent::Test::BufferedOutputTestDriver.new(Fluent::GeoipOutput, tag).configure(conf, use_v1)
8
+ def create_driver(conf='',tag='test',use_v1=false)
9
+ require 'fluent/version'
10
+ if Gem::Version.new(Fluent::VERSION) < Gem::Version.new('0.12')
11
+ Fluent::Test::OutputTestDriver.new(Fluent::GeoipOutput, tag).configure(conf, use_v1)
12
+ else
13
+ Fluent::Test::BufferedOutputTestDriver.new(Fluent::GeoipOutput, tag).configure(conf, use_v1)
14
+ end
17
15
  end
18
16
 
19
- def test_configure
20
- assert_raise(Fluent::ConfigError) {
21
- d = create_driver('')
22
- }
23
- assert_raise(Fluent::ConfigError) {
24
- d = create_driver('enable_key_cities')
25
- }
26
- d = create_driver %[
27
- enable_key_city geoip_city
28
- remove_tag_prefix input.
29
- tag geoip.${tag}
30
- ]
31
- assert_equal 'geoip_city', d.instance.config['enable_key_city']
17
+ sub_test_case "configure" do
18
+ test "empty" do
19
+ assert_raise(Fluent::ConfigError) {
20
+ create_driver('')
21
+ }
22
+ end
32
23
 
33
- # multiple key config
34
- d = create_driver %[
35
- geoip_lookup_key from.ip, to.ip
36
- enable_key_city from_city, to_city
37
- remove_tag_prefix input.
38
- tag geoip.${tag}
39
- ]
40
- assert_equal 'from_city, to_city', d.instance.config['enable_key_city']
24
+ test "missing required parameters" do
25
+ assert_raise(Fluent::ConfigError) {
26
+ create_driver('enable_key_cities')
27
+ }
28
+ end
41
29
 
42
- # multiple key config (bad configure)
43
- assert_raise(Fluent::ConfigError) {
30
+ test "minimum" do
44
31
  d = create_driver %[
45
- geoip_lookup_key from.ip, to.ip
46
- enable_key_city from_city
47
- enable_key_region from_region
32
+ enable_key_city geoip_city
48
33
  remove_tag_prefix input.
49
34
  tag geoip.${tag}
50
35
  ]
51
- }
36
+ assert_equal 'geoip_city', d.instance.config['enable_key_city']
37
+ end
52
38
 
53
- # invalid json structure
54
- assert_raise(Fluent::ConfigError) {
39
+ test "multiple key config" do
55
40
  d = create_driver %[
56
- geoip_lookup_key host
41
+ geoip_lookup_key from.ip, to.ip
42
+ enable_key_city from_city, to_city
43
+ remove_tag_prefix input.
44
+ tag geoip.${tag}
45
+ ]
46
+ assert_equal 'from_city, to_city', d.instance.config['enable_key_city']
47
+ end
48
+
49
+ test "multiple key config (bad configure)" do
50
+ assert_raise(Fluent::ConfigError) {
51
+ create_driver %[
52
+ geoip_lookup_key from.ip, to.ip
53
+ enable_key_city from_city
54
+ enable_key_region from_region
55
+ remove_tag_prefix input.
56
+ tag geoip.${tag}
57
+ ]
58
+ }
59
+ end
60
+
61
+ test "invalid json structure w/ Ruby hash like" do
62
+ assert_raise(Fluent::ConfigError) {
63
+ create_driver %[
64
+ geoip_lookup_key host
65
+ <record>
66
+ invalid_json {"foo" => 123}
67
+ </record>
68
+ remove_tag_prefix input.
69
+ tag geoip.${tag}
70
+ ]
71
+ }
72
+ end
73
+
74
+ test "invalid json structure w/ unquoted string literal" do
75
+ assert_raise(Fluent::ConfigError) {
76
+ create_driver %[
77
+ geoip_lookup_key host
78
+ <record>
79
+ invalid_json {"foo" : string, "bar" : 123}
80
+ </record>
81
+ remove_tag_prefix input.
82
+ tag geoip.${tag}
83
+ ]
84
+ }
85
+ end
86
+
87
+ data(geoip: "geoip",
88
+ geoip2_compat: "geoip2_compat")
89
+ test "unsupported key" do |backend|
90
+ assert_raise(Fluent::ConfigError.new("#{backend}: unsupported key unknown")) do
91
+ create_driver %[
92
+ backend_library #{backend}
93
+ <record>
94
+ city ${unknown["host"]}
95
+ </record>
96
+ remove_tag_prefix input.
97
+ tag geoip.${tag}
98
+ ]
99
+ end
100
+ end
101
+
102
+ data(geoip: ["geoip", '${city["host"]}'],
103
+ geoip2_compat: ["geoip2_compat", '${city["host"]}'],
104
+ geoip2_c: ["geoip2_c", '${city.names.en["host"]}'])
105
+ test "supported backend" do |(backend, placeholder)|
106
+ create_driver %[
107
+ backend_library #{backend}
57
108
  <record>
58
- invalid_json {"foo" => 123}
109
+ city #{placeholder}
59
110
  </record>
60
111
  remove_tag_prefix input.
61
112
  tag geoip.${tag}
62
113
  ]
63
- }
64
- assert_raise(Fluent::ConfigError) {
65
- d = create_driver %[
114
+ end
115
+
116
+ test "unsupported backend" do
117
+ assert_raise(Fluent::ConfigError) do
118
+ create_driver %[
119
+ backend_library hive_geoip2
120
+ <record>
121
+ city ${city["host"]}
122
+ </record>
123
+ remove_tag_prefix input.
124
+ tag geoip.${tag}
125
+ ]
126
+ end
127
+ end
128
+ end
129
+
130
+ sub_test_case "geoip2_c" do
131
+ def test_emit_tag_option
132
+ d1 = create_driver(%[
133
+ backend_library geoip2_c
66
134
  geoip_lookup_key host
67
135
  <record>
68
- invalid_json {"foo" : string, "bar" : 123}
136
+ geoip_city ${city.names.en['host']}
69
137
  </record>
70
138
  remove_tag_prefix input.
71
139
  tag geoip.${tag}
72
- ]
73
- }
74
- end
140
+ ], 'input.access')
141
+ d1.run do
142
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
143
+ d1.emit({'message' => 'missing field'})
144
+ end
145
+ emits = d1.emits
146
+ assert_equal 2, emits.length
147
+ assert_equal 'geoip.access', emits[0][0] # tag
148
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
149
+ assert_equal nil, emits[1][2]['geoip_city']
150
+ end
75
151
 
76
- def test_emit
77
- d1 = create_driver(CONFIG, 'input.access')
78
- d1.run do
79
- d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
80
- d1.emit({'message' => 'missing field'})
81
- end
82
- emits = d1.emits
83
- assert_equal 2, emits.length
84
- assert_equal 'geoip.access', emits[0][0] # tag
85
- assert_equal 'Mountain View', emits[0][2]['geoip_city']
86
- assert_equal nil, emits[1][2]['geoip_city']
87
- end
152
+ def test_emit_tag_parts
153
+ d1 = create_driver(%[
154
+ backend_library geoip2_c
155
+ geoip_lookup_key host
156
+ <record>
157
+ geoip_city ${city.names.en['host']}
158
+ </record>
159
+ tag geoip.${tag_parts[1]}.${tag_parts[2..3]}.${tag_parts[-1]}
160
+ ], '0.1.2.3')
161
+ d1.run do
162
+ d1.emit({'host' => '66.102.3.80'})
163
+ end
164
+ emits = d1.emits
165
+ assert_equal 1, emits.length
166
+ assert_equal 'geoip.1.2.3.3', emits[0][0] # tag
167
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
168
+ end
88
169
 
89
- def test_emit_tag_option
90
- d1 = create_driver(%[
91
- geoip_lookup_key host
92
- <record>
93
- geoip_city ${city['host']}
94
- </record>
95
- remove_tag_prefix input.
96
- tag geoip.${tag}
97
- ], 'input.access')
98
- d1.run do
99
- d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
100
- d1.emit({'message' => 'missing field'})
101
- end
102
- emits = d1.emits
103
- assert_equal 2, emits.length
104
- assert_equal 'geoip.access', emits[0][0] # tag
105
- assert_equal 'Mountain View', emits[0][2]['geoip_city']
106
- assert_equal nil, emits[1][2]['geoip_city']
107
- end
170
+ def test_emit_with_dot_key
171
+ d1 = create_driver(%[
172
+ backend_library geoip2_c
173
+ geoip_lookup_key ip.origin, ip.dest
174
+ <record>
175
+ origin_country ${country.iso_code['ip.origin']}
176
+ dest_country ${country.iso_code['ip.dest']}
177
+ </record>
178
+ remove_tag_prefix input.
179
+ tag geoip.${tag}
180
+ ], 'input.access')
181
+ d1.run do
182
+ d1.emit({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
183
+ end
184
+ emits = d1.emits
185
+ assert_equal 1, emits.length
186
+ assert_equal 'geoip.access', emits[0][0] # tag
187
+ assert_equal 'US', emits[0][2]['origin_country']
188
+ assert_equal 'US', emits[0][2]['dest_country']
189
+ end
108
190
 
109
- def test_emit_tag_parts
110
- d1 = create_driver(%[
111
- geoip_lookup_key host
112
- <record>
113
- geoip_city ${city['host']}
114
- </record>
115
- tag geoip.${tag_parts[1]}.${tag_parts[2..3]}.${tag_parts[-1]}
116
- ], '0.1.2.3')
117
- d1.run do
118
- d1.emit({'host' => '66.102.3.80'})
119
- end
120
- emits = d1.emits
121
- assert_equal 1, emits.length
122
- assert_equal 'geoip.1.2.3.3', emits[0][0] # tag
123
- assert_equal 'Mountain View', emits[0][2]['geoip_city']
124
- end
191
+ def test_emit_with_unknown_address
192
+ d1 = create_driver(%[
193
+ backend_library geoip2_c
194
+ geoip_lookup_key host
195
+ <record>
196
+ geoip_city ${city.names.en['host']}
197
+ geopoint [${location.longitude['host']}, ${location.latitude['host']}]
198
+ </record>
199
+ skip_adding_null_record false
200
+ remove_tag_prefix input.
201
+ tag geoip.${tag}
202
+ ], 'input.access')
203
+ d1.run do
204
+ # 203.0.113.1 is a test address described in RFC5737
205
+ d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
206
+ d1.emit({'host' => '0', 'message' => 'invalid ip'})
207
+ end
208
+ emits = d1.emits
209
+ assert_equal 2, emits.length
210
+ assert_equal 'geoip.access', emits[0][0] # tag
211
+ assert_equal nil, emits[0][2]['geoip_city']
212
+ assert_equal 'geoip.access', emits[1][0] # tag
213
+ assert_equal nil, emits[1][2]['geoip_city']
214
+ end
125
215
 
126
- def test_emit_with_dot_key
127
- d1 = create_driver(%[
128
- geoip_lookup_key ip.origin, ip.dest
129
- <record>
130
- origin_country ${country_code['ip.origin']}
131
- dest_country ${country_code['ip.dest']}
132
- </record>
133
- remove_tag_prefix input.
134
- tag geoip.${tag}
135
- ], 'input.access')
136
- d1.run do
137
- d1.emit({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
138
- end
139
- emits = d1.emits
140
- assert_equal 1, emits.length
141
- assert_equal 'geoip.access', emits[0][0] # tag
142
- assert_equal 'US', emits[0][2]['origin_country']
143
- assert_equal 'US', emits[0][2]['dest_country']
144
- end
216
+ def test_emit_with_skip_unknown_address
217
+ d1 = create_driver(%[
218
+ backend_library geoip2_c
219
+ geoip_lookup_key host
220
+ <record>
221
+ geoip_city ${city.names.en['host']}
222
+ geopoint [${location.longitude['host']}, ${location.latitude['host']}]
223
+ </record>
224
+ skip_adding_null_record true
225
+ remove_tag_prefix input.
226
+ tag geoip.${tag}
227
+ ], 'input.access')
228
+ d1.run do
229
+ # 203.0.113.1 is a test address described in RFC5737
230
+ d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
231
+ d1.emit({'host' => '0', 'message' => 'invalid ip'})
232
+ d1.emit({'host' => '8.8.8.8', 'message' => 'google public dns'})
233
+ end
234
+ emits = d1.emits
235
+ assert_equal 3, emits.length
236
+ assert_equal 'geoip.access', emits[0][0] # tag
237
+ assert_equal nil, emits[0][2]['geoip_city']
238
+ assert_equal nil, emits[0][2]['geopoint']
239
+ assert_equal 'geoip.access', emits[1][0] # tag
240
+ assert_equal nil, emits[1][2]['geoip_city']
241
+ assert_equal nil, emits[1][2]['geopoint']
242
+ assert_equal 'Mountain View', emits[2][2]['geoip_city']
243
+ assert_equal [-122.0838, 37.386], emits[2][2]['geopoint']
244
+ end
145
245
 
146
- def test_emit_nested_attr
147
- d1 = create_driver(%[
148
- geoip_lookup_key host.ip
149
- enable_key_city geoip_city
150
- remove_tag_prefix input.
151
- add_tag_prefix geoip.
152
- ], 'input.access')
153
- d1.run do
154
- d1.emit({'host' => {'ip' => '66.102.3.80'}, 'message' => 'valid ip'})
155
- d1.emit({'message' => 'missing field'})
156
- end
157
- emits = d1.emits
158
- assert_equal 2, emits.length
159
- assert_equal 'geoip.access', emits[0][0] # tag
160
- assert_equal 'Mountain View', emits[0][2]['geoip_city']
161
- assert_equal nil, emits[1][2]['geoip_city']
162
- end
246
+ def test_emit_record_directive
247
+ d1 = create_driver(%[
248
+ backend_library geoip2_c
249
+ geoip_lookup_key from.ip
250
+ <record>
251
+ from_city ${city.names.en['from.ip']}
252
+ from_country ${country.names.en['from.ip']}
253
+ latitude ${location.latitude['from.ip']}
254
+ longitude ${location.longitude['from.ip']}
255
+ float_concat ${location.latitude['from.ip']},${location.longitude['from.ip']}
256
+ float_array [${location.longitude['from.ip']}, ${location.latitude['from.ip']}]
257
+ float_nest { "lat" : ${location.latitude['from.ip']}, "lon" : ${location.longitude['from.ip']}}
258
+ string_concat ${location.latitude['from.ip']},${location.longitude['from.ip']}
259
+ string_array [${city.names.en['from.ip']}, ${country.names.en['from.ip']}]
260
+ string_nest { "city" : ${city.names.en['from.ip']}, "country_name" : ${country.names.en['from.ip']}}
261
+ unknown_city ${city.names.en['unknown_key']}
262
+ undefined ${city.names.en['undefined']}
263
+ broken_array1 [${location.longitude['from.ip']}, ${location.latitude['undefined']}]
264
+ broken_array2 [${location.longitude['undefined']}, ${location.latitude['undefined']}]
265
+ </record>
266
+ remove_tag_prefix input.
267
+ tag geoip.${tag}
268
+ ], 'input.access')
269
+ d1.run do
270
+ d1.emit({'from' => {'ip' => '66.102.3.80'}})
271
+ d1.emit({'message' => 'missing field'})
272
+ end
273
+ emits = d1.emits
274
+ assert_equal 2, emits.length
275
+
276
+ assert_equal 'geoip.access', emits[0][0] # tag
277
+ assert_equal 'Mountain View', emits[0][2]['from_city']
278
+ assert_equal 'United States', emits[0][2]['from_country']
279
+ assert_equal 37.419200000000004, emits[0][2]['latitude']
280
+ assert_equal -122.0574, emits[0][2]['longitude']
281
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['float_concat']
282
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['float_array']
283
+ float_nest = {"lat" => 37.419200000000004, "lon" => -122.0574 }
284
+ assert_equal float_nest, emits[0][2]['float_nest']
285
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['string_concat']
286
+ assert_equal ["Mountain View", "United States"], emits[0][2]['string_array']
287
+ string_nest = {"city" => "Mountain View", "country_name" => "United States"}
288
+ assert_equal string_nest, emits[0][2]['string_nest']
289
+ assert_equal nil, emits[0][2]['unknown_city']
290
+ assert_equal nil, emits[0][2]['undefined']
291
+ assert_equal [-122.0574, nil], emits[0][2]['broken_array1']
292
+ assert_equal [nil, nil], emits[0][2]['broken_array2']
293
+
294
+ assert_equal nil, emits[1][2]['from_city']
295
+ assert_equal nil, emits[1][2]['from_country']
296
+ assert_equal nil, emits[1][2]['latitude']
297
+ assert_equal nil, emits[1][2]['longitude']
298
+ assert_equal ',', emits[1][2]['float_concat']
299
+ assert_equal [nil, nil], emits[1][2]['float_array']
300
+ float_nest = {"lat" => nil, "lon" => nil}
301
+ assert_equal float_nest, emits[1][2]['float_nest']
302
+ assert_equal ',', emits[1][2]['string_concat']
303
+ assert_equal [nil, nil], emits[1][2]['string_array']
304
+ string_nest = {"city" => nil, "country_name" => nil}
305
+ assert_equal string_nest, emits[1][2]['string_nest']
306
+ assert_equal nil, emits[1][2]['unknown_city']
307
+ assert_equal nil, emits[1][2]['undefined']
308
+ assert_equal [nil, nil], emits[1][2]['broken_array1']
309
+ assert_equal [nil, nil], emits[1][2]['broken_array2']
310
+ end
163
311
 
164
- def test_emit_with_unknown_address
165
- d1 = create_driver(%[
312
+ def test_emit_record_directive_multiple_record
313
+ d1 = create_driver(%[
314
+ backend_library geoip2_c
315
+ geoip_lookup_key from.ip, to.ip
316
+ <record>
317
+ from_city ${city.names.en['from.ip']}
318
+ to_city ${city.names.en['to.ip']}
319
+ from_country ${country.names.en['from.ip']}
320
+ to_country ${country.names.en['to.ip']}
321
+ string_array [${country.names.en['from.ip']}, ${country.names.en['to.ip']}]
322
+ </record>
323
+ remove_tag_prefix input.
324
+ tag geoip.${tag}
325
+ ], 'input.access')
326
+ d1.run do
327
+ d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
328
+ d1.emit({'message' => 'missing field'})
329
+ end
330
+ emits = d1.emits
331
+ assert_equal 2, emits.length
332
+
333
+ assert_equal 'geoip.access', emits[0][0] # tag
334
+ assert_equal 'Mountain View', emits[0][2]['from_city']
335
+ assert_equal 'United States', emits[0][2]['from_country']
336
+ assert_equal 'Tokorozawa', emits[0][2]['to_city']
337
+ assert_equal 'Japan', emits[0][2]['to_country']
338
+ assert_equal ['United States','Japan'], emits[0][2]['string_array']
339
+
340
+ assert_equal nil, emits[1][2]['from_city']
341
+ assert_equal nil, emits[1][2]['to_city']
342
+ assert_equal nil, emits[1][2]['from_country']
343
+ assert_equal nil, emits[1][2]['to_country']
344
+ assert_equal [nil, nil], emits[1][2]['string_array']
345
+ end
346
+
347
+ def config_quoted_record
348
+ %[
349
+ backend_library geoip2_c
166
350
  geoip_lookup_key host
167
351
  <record>
168
- geoip_city ${city['host']}
169
- geopoint [${longitude['host']}, ${latitude['host']}]
352
+ location_properties '{ "country_code" : "${country.iso_code["host"]}", "lat": ${location.latitude["host"]}, "lon": ${location.longitude["host"]} }'
353
+ location_string ${location.latitude['host']},${location.longitude['host']}
354
+ location_string2 ${country.iso_code["host"]}
355
+ location_array "[${location.longitude['host']},${location.latitude['host']}]"
356
+ location_array2 '[${location.longitude["host"]},${location.latitude["host"]}]'
357
+ peculiar_pattern '[GEOIP] message => {"lat":${location.latitude["host"]}, "lon":${location.longitude["host"]}}'
170
358
  </record>
171
- skip_adding_null_record false
172
359
  remove_tag_prefix input.
173
360
  tag geoip.${tag}
174
- ], 'input.access')
175
- d1.run do
176
- # 203.0.113.1 is a test address described in RFC5737
177
- d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
178
- d1.emit({'host' => '0', 'message' => 'invalid ip'})
179
- end
180
- emits = d1.emits
181
- assert_equal 2, emits.length
182
- assert_equal 'geoip.access', emits[0][0] # tag
183
- assert_equal nil, emits[0][2]['geoip_city']
184
- assert_equal 'geoip.access', emits[1][0] # tag
185
- assert_equal nil, emits[1][2]['geoip_city']
361
+ ]
362
+ end
363
+
364
+ def test_emit_quoted_record
365
+ d1 = create_driver(config_quoted_record, 'input.access')
366
+ d1.run do
367
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
368
+ end
369
+ emits = d1.emits
370
+ assert_equal 1, emits.length
371
+ assert_equal 'geoip.access', emits[0][0] # tag
372
+ location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
373
+ assert_equal location_properties, emits[0][2]['location_properties']
374
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['location_string']
375
+ assert_equal 'US', emits[0][2]['location_string2']
376
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array']
377
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array2']
378
+ assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', emits[0][2]['peculiar_pattern']
379
+ end
380
+
381
+ def test_emit_v1_config_compatibility
382
+ d1 = create_driver(config_quoted_record, 'input.access', true)
383
+ d1.run do
384
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
385
+ end
386
+ emits = d1.emits
387
+ assert_equal 1, emits.length
388
+ assert_equal 'geoip.access', emits[0][0] # tag
389
+ location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
390
+ assert_equal location_properties, emits[0][2]['location_properties']
391
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['location_string']
392
+ assert_equal 'US', emits[0][2]['location_string2']
393
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array']
394
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array2']
395
+ assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', emits[0][2]['peculiar_pattern']
396
+ end
397
+
398
+ def test_emit_multiline_v1_config
399
+ d1 = create_driver(%[
400
+ backend_library geoip2_c
401
+ geoip_lookup_key host
402
+ <record>
403
+ location_properties {
404
+ "city": "${city.names.en['host']}",
405
+ "country_code": "${country.iso_code['host']}",
406
+ "latitude": "${location.latitude['host']}",
407
+ "longitude": "${location.longitude['host']}"
408
+ }
409
+ </record>
410
+ remove_tag_prefix input.
411
+ tag geoip.${tag}
412
+ ], 'input.access', true)
413
+ d1.run do
414
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
415
+ end
416
+ emits = d1.emits
417
+ assert_equal 1, emits.length
418
+ assert_equal 'geoip.access', emits[0][0] # tag
419
+ location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.419200000000004, "longitude"=>-122.0574 }
420
+ assert_equal location_properties, emits[0][2]['location_properties']
421
+ end
186
422
  end
187
423
 
188
- def test_emit_with_skip_unknown_address
189
- d1 = create_driver(%[
424
+ sub_test_case "geoip2_compat" do
425
+ def test_emit_tag_option
426
+ d1 = create_driver(%[
427
+ backend_library geoip2_compat
428
+ geoip_lookup_key host
429
+ <record>
430
+ geoip_city ${city['host']}
431
+ </record>
432
+ remove_tag_prefix input.
433
+ tag geoip.${tag}
434
+ ], 'input.access')
435
+ d1.run do
436
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
437
+ d1.emit({'message' => 'missing field'})
438
+ end
439
+ emits = d1.emits
440
+ assert_equal 2, emits.length
441
+ assert_equal 'geoip.access', emits[0][0] # tag
442
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
443
+ assert_equal nil, emits[1][2]['geoip_city']
444
+ end
445
+
446
+ def test_emit_tag_parts
447
+ d1 = create_driver(%[
448
+ backend_library geoip2_compat
449
+ geoip_lookup_key host
450
+ <record>
451
+ geoip_city ${city['host']}
452
+ </record>
453
+ tag geoip.${tag_parts[1]}.${tag_parts[2..3]}.${tag_parts[-1]}
454
+ ], '0.1.2.3')
455
+ d1.run do
456
+ d1.emit({'host' => '66.102.3.80'})
457
+ end
458
+ emits = d1.emits
459
+ assert_equal 1, emits.length
460
+ assert_equal 'geoip.1.2.3.3', emits[0][0] # tag
461
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
462
+ end
463
+
464
+ def test_emit_with_dot_key
465
+ d1 = create_driver(%[
466
+ backend_library geoip2_compat
467
+ geoip_lookup_key ip.origin, ip.dest
468
+ <record>
469
+ origin_country ${country_code['ip.origin']}
470
+ dest_country ${country_code['ip.dest']}
471
+ </record>
472
+ remove_tag_prefix input.
473
+ tag geoip.${tag}
474
+ ], 'input.access')
475
+ d1.run do
476
+ d1.emit({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
477
+ end
478
+ emits = d1.emits
479
+ assert_equal 1, emits.length
480
+ assert_equal 'geoip.access', emits[0][0] # tag
481
+ assert_equal 'US', emits[0][2]['origin_country']
482
+ assert_equal 'US', emits[0][2]['dest_country']
483
+ end
484
+
485
+ def test_emit_with_unknown_address
486
+ d1 = create_driver(%[
487
+ backend_library geoip2_compat
488
+ geoip_lookup_key host
489
+ <record>
490
+ geoip_city ${city['host']}
491
+ geopoint [${longitude['host']}, ${latitude['host']}]
492
+ </record>
493
+ skip_adding_null_record false
494
+ remove_tag_prefix input.
495
+ tag geoip.${tag}
496
+ ], 'input.access')
497
+ d1.run do
498
+ # 203.0.113.1 is a test address described in RFC5737
499
+ d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
500
+ d1.emit({'host' => '0', 'message' => 'invalid ip'})
501
+ end
502
+ emits = d1.emits
503
+ assert_equal 2, emits.length
504
+ assert_equal 'geoip.access', emits[0][0] # tag
505
+ assert_equal nil, emits[0][2]['geoip_city']
506
+ assert_equal 'geoip.access', emits[1][0] # tag
507
+ assert_equal nil, emits[1][2]['geoip_city']
508
+ end
509
+
510
+ def test_emit_with_skip_unknown_address
511
+ d1 = create_driver(%[
512
+ backend_library geoip2_compat
513
+ geoip_lookup_key host
514
+ <record>
515
+ geoip_city ${city['host']}
516
+ geopoint [${longitude['host']}, ${latitude['host']}]
517
+ </record>
518
+ skip_adding_null_record true
519
+ remove_tag_prefix input.
520
+ tag geoip.${tag}
521
+ ], 'input.access')
522
+ d1.run do
523
+ # 203.0.113.1 is a test address described in RFC5737
524
+ d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
525
+ d1.emit({'host' => '0', 'message' => 'invalid ip'})
526
+ d1.emit({'host' => '8.8.8.8', 'message' => 'google public dns'})
527
+ end
528
+ emits = d1.emits
529
+ assert_equal 3, emits.length
530
+ assert_equal 'geoip.access', emits[0][0] # tag
531
+ assert_equal nil, emits[0][2]['geoip_city']
532
+ assert_equal nil, emits[0][2]['geopoint']
533
+ assert_equal 'geoip.access', emits[1][0] # tag
534
+ assert_equal nil, emits[1][2]['geoip_city']
535
+ assert_equal nil, emits[1][2]['geopoint']
536
+ assert_equal 'Mountain View', emits[2][2]['geoip_city']
537
+ assert_equal [-122.0838, 37.386], emits[2][2]['geopoint']
538
+ end
539
+
540
+ def test_emit_record_directive
541
+ d1 = create_driver(%[
542
+ backend_library geoip2_compat
543
+ geoip_lookup_key from.ip
544
+ <record>
545
+ from_city ${city['from.ip']}
546
+ from_country ${country_name['from.ip']}
547
+ latitude ${latitude['from.ip']}
548
+ longitude ${longitude['from.ip']}
549
+ float_concat ${latitude['from.ip']},${longitude['from.ip']}
550
+ float_array [${longitude['from.ip']}, ${latitude['from.ip']}]
551
+ float_nest { "lat" : ${latitude['from.ip']}, "lon" : ${longitude['from.ip']}}
552
+ string_concat ${latitude['from.ip']},${longitude['from.ip']}
553
+ string_array [${city['from.ip']}, ${country_name['from.ip']}]
554
+ string_nest { "city" : ${city['from.ip']}, "country_name" : ${country_name['from.ip']}}
555
+ unknown_city ${city['unknown_key']}
556
+ undefined ${city['undefined']}
557
+ broken_array1 [${longitude['from.ip']}, ${latitude['undefined']}]
558
+ broken_array2 [${longitude['undefined']}, ${latitude['undefined']}]
559
+ </record>
560
+ remove_tag_prefix input.
561
+ tag geoip.${tag}
562
+ ], 'input.access')
563
+ d1.run do
564
+ d1.emit({'from' => {'ip' => '66.102.3.80'}})
565
+ d1.emit({'message' => 'missing field'})
566
+ end
567
+ emits = d1.emits
568
+ assert_equal 2, emits.length
569
+
570
+ assert_equal 'geoip.access', emits[0][0] # tag
571
+ assert_equal 'Mountain View', emits[0][2]['from_city']
572
+ assert_equal 'United States', emits[0][2]['from_country']
573
+ assert_equal 37.419200000000004, emits[0][2]['latitude']
574
+ assert_equal -122.0574, emits[0][2]['longitude']
575
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['float_concat']
576
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['float_array']
577
+ float_nest = {"lat" => 37.419200000000004, "lon" => -122.0574 }
578
+ assert_equal float_nest, emits[0][2]['float_nest']
579
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['string_concat']
580
+ assert_equal ["Mountain View", "United States"], emits[0][2]['string_array']
581
+ string_nest = {"city" => "Mountain View", "country_name" => "United States"}
582
+ assert_equal string_nest, emits[0][2]['string_nest']
583
+ assert_equal nil, emits[0][2]['unknown_city']
584
+ assert_equal nil, emits[0][2]['undefined']
585
+ assert_equal [-122.0574, nil], emits[0][2]['broken_array1']
586
+ assert_equal [nil, nil], emits[0][2]['broken_array2']
587
+
588
+ assert_equal nil, emits[1][2]['from_city']
589
+ assert_equal nil, emits[1][2]['from_country']
590
+ assert_equal nil, emits[1][2]['latitude']
591
+ assert_equal nil, emits[1][2]['longitude']
592
+ assert_equal ',', emits[1][2]['float_concat']
593
+ assert_equal [nil, nil], emits[1][2]['float_array']
594
+ float_nest = {"lat" => nil, "lon" => nil}
595
+ assert_equal float_nest, emits[1][2]['float_nest']
596
+ assert_equal ',', emits[1][2]['string_concat']
597
+ assert_equal [nil, nil], emits[1][2]['string_array']
598
+ string_nest = {"city" => nil, "country_name" => nil}
599
+ assert_equal string_nest, emits[1][2]['string_nest']
600
+ assert_equal nil, emits[1][2]['unknown_city']
601
+ assert_equal nil, emits[1][2]['undefined']
602
+ assert_equal [nil, nil], emits[1][2]['broken_array1']
603
+ assert_equal [nil, nil], emits[1][2]['broken_array2']
604
+ end
605
+
606
+ def test_emit_record_directive_multiple_record
607
+ d1 = create_driver(%[
608
+ backend_library geoip2_compat
609
+ geoip_lookup_key from.ip, to.ip
610
+ <record>
611
+ from_city ${city['from.ip']}
612
+ to_city ${city['to.ip']}
613
+ from_country ${country_name['from.ip']}
614
+ to_country ${country_name['to.ip']}
615
+ string_array [${country_name['from.ip']}, ${country_name['to.ip']}]
616
+ </record>
617
+ remove_tag_prefix input.
618
+ tag geoip.${tag}
619
+ ], 'input.access')
620
+ d1.run do
621
+ d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
622
+ d1.emit({'message' => 'missing field'})
623
+ end
624
+ emits = d1.emits
625
+ assert_equal 2, emits.length
626
+
627
+ assert_equal 'geoip.access', emits[0][0] # tag
628
+ assert_equal 'Mountain View', emits[0][2]['from_city']
629
+ assert_equal 'United States', emits[0][2]['from_country']
630
+ assert_equal 'Tokorozawa', emits[0][2]['to_city']
631
+ assert_equal 'Japan', emits[0][2]['to_country']
632
+ assert_equal ['United States','Japan'], emits[0][2]['string_array']
633
+
634
+ assert_equal nil, emits[1][2]['from_city']
635
+ assert_equal nil, emits[1][2]['to_city']
636
+ assert_equal nil, emits[1][2]['from_country']
637
+ assert_equal nil, emits[1][2]['to_country']
638
+ assert_equal [nil, nil], emits[1][2]['string_array']
639
+ end
640
+
641
+ def config_quoted_record
642
+ %[
643
+ backend_library geoip2_compat
190
644
  geoip_lookup_key host
191
645
  <record>
192
- geoip_city ${city['host']}
193
- geopoint [${longitude['host']}, ${latitude['host']}]
646
+ location_properties '{ "country_code" : "${country_code["host"]}", "lat": ${latitude["host"]}, "lon": ${longitude["host"]} }'
647
+ location_string ${latitude['host']},${longitude['host']}
648
+ location_string2 ${country_code["host"]}
649
+ location_array "[${longitude['host']},${latitude['host']}]"
650
+ location_array2 '[${longitude["host"]},${latitude["host"]}]'
651
+ peculiar_pattern '[GEOIP] message => {"lat":${latitude["host"]}, "lon":${longitude["host"]}}'
194
652
  </record>
195
- skip_adding_null_record true
196
653
  remove_tag_prefix input.
197
654
  tag geoip.${tag}
198
- ], 'input.access')
199
- d1.run do
200
- # 203.0.113.1 is a test address described in RFC5737
201
- d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
202
- d1.emit({'host' => '0', 'message' => 'invalid ip'})
203
- d1.emit({'host' => '8.8.8.8', 'message' => 'google public dns'})
204
- end
205
- emits = d1.emits
206
- assert_equal 3, emits.length
207
- assert_equal 'geoip.access', emits[0][0] # tag
208
- assert_equal nil, emits[0][2]['geoip_city']
209
- assert_equal nil, emits[0][2]['geopoint']
210
- assert_equal 'geoip.access', emits[1][0] # tag
211
- assert_equal nil, emits[1][2]['geoip_city']
212
- assert_equal nil, emits[1][2]['geopoint']
213
- assert_equal 'Mountain View', emits[2][2]['geoip_city']
214
- assert_equal [-122.08380126953125, 37.38600158691406], emits[2][2]['geopoint']
215
- end
655
+ ]
656
+ end
216
657
 
217
- def test_emit_multiple_key
218
- d1 = create_driver(%[
219
- geoip_lookup_key from.ip, to.ip
220
- enable_key_city from_city, to_city
221
- remove_tag_prefix input.
222
- add_tag_prefix geoip.
223
- ], 'input.access')
224
- d1.run do
225
- d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
226
- d1.emit({'message' => 'missing field'})
227
- end
228
- emits = d1.emits
229
- assert_equal 2, emits.length
230
- assert_equal 'geoip.access', emits[0][0] # tag
231
- assert_equal 'Mountain View', emits[0][2]['from_city']
232
- assert_equal 'Tokorozawa', emits[0][2]['to_city']
233
- assert_equal nil, emits[1][2]['from_city']
234
- assert_equal nil, emits[1][2]['to_city']
235
- end
658
+ def test_emit_quoted_record
659
+ d1 = create_driver(config_quoted_record, 'input.access')
660
+ d1.run do
661
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
662
+ end
663
+ emits = d1.emits
664
+ assert_equal 1, emits.length
665
+ assert_equal 'geoip.access', emits[0][0] # tag
666
+ location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
667
+ assert_equal location_properties, emits[0][2]['location_properties']
668
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['location_string']
669
+ assert_equal 'US', emits[0][2]['location_string2']
670
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array']
671
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array2']
672
+ assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', emits[0][2]['peculiar_pattern']
673
+ end
236
674
 
237
- def test_emit_multiple_key_multiple_record
238
- d1 = create_driver(%[
239
- geoip_lookup_key from.ip, to.ip
240
- enable_key_city from_city, to_city
241
- enable_key_country_name from_country, to_country
242
- remove_tag_prefix input.
243
- add_tag_prefix geoip.
244
- ], 'input.access')
245
- d1.run do
246
- d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
247
- d1.emit({'from' => {'ip' => '66.102.3.80'}})
248
- d1.emit({'message' => 'missing field'})
249
- end
250
- emits = d1.emits
251
- assert_equal 3, emits.length
252
- assert_equal 'geoip.access', emits[0][0] # tag
253
- assert_equal 'Mountain View', emits[0][2]['from_city']
254
- assert_equal 'United States', emits[0][2]['from_country']
255
- assert_equal 'Tokorozawa', emits[0][2]['to_city']
256
- assert_equal 'Japan', emits[0][2]['to_country']
257
-
258
- assert_equal 'Mountain View', emits[1][2]['from_city']
259
- assert_equal 'United States', emits[1][2]['from_country']
260
- assert_equal nil, emits[1][2]['to_city']
261
- assert_equal nil, emits[1][2]['to_country']
262
-
263
- assert_equal nil, emits[2][2]['from_city']
264
- assert_equal nil, emits[2][2]['from_country']
265
- assert_equal nil, emits[2][2]['to_city']
266
- assert_equal nil, emits[2][2]['to_country']
267
- end
675
+ def test_emit_v1_config_compatibility
676
+ d1 = create_driver(config_quoted_record, 'input.access', true)
677
+ d1.run do
678
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
679
+ end
680
+ emits = d1.emits
681
+ assert_equal 1, emits.length
682
+ assert_equal 'geoip.access', emits[0][0] # tag
683
+ location_properties = { "country_code" => "US", "lat" => 37.419200000000004, "lon"=> -122.0574 }
684
+ assert_equal location_properties, emits[0][2]['location_properties']
685
+ assert_equal '37.419200000000004,-122.0574', emits[0][2]['location_string']
686
+ assert_equal 'US', emits[0][2]['location_string2']
687
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array']
688
+ assert_equal [-122.0574, 37.419200000000004], emits[0][2]['location_array2']
689
+ assert_equal '[GEOIP] message => {"lat":37.419200000000004, "lon":-122.0574}', emits[0][2]['peculiar_pattern']
690
+ end
268
691
 
269
- def test_emit_record_directive
270
- d1 = create_driver(%[
271
- geoip_lookup_key from.ip
272
- <record>
273
- from_city ${city['from.ip']}
274
- from_country ${country_name['from.ip']}
275
- latitude ${latitude['from.ip']}
276
- longitude ${longitude['from.ip']}
277
- float_concat ${latitude['from.ip']},${longitude['from.ip']}
278
- float_array [${longitude['from.ip']}, ${latitude['from.ip']}]
279
- float_nest { "lat" : ${latitude['from.ip']}, "lon" : ${longitude['from.ip']}}
280
- string_concat ${latitude['from.ip']},${longitude['from.ip']}
281
- string_array [${city['from.ip']}, ${country_name['from.ip']}]
282
- string_nest { "city" : ${city['from.ip']}, "country_name" : ${country_name['from.ip']}}
283
- unknown_city ${city['unknown_key']}
284
- undefined ${city['undefined']}
285
- broken_array1 [${longitude['from.ip']}, ${latitude['undefined']}]
286
- broken_array2 [${longitude['undefined']}, ${latitude['undefined']}]
287
- </record>
288
- remove_tag_prefix input.
289
- tag geoip.${tag}
290
- ], 'input.access')
291
- d1.run do
292
- d1.emit({'from' => {'ip' => '66.102.3.80'}})
293
- d1.emit({'message' => 'missing field'})
294
- end
295
- emits = d1.emits
296
- assert_equal 2, emits.length
297
-
298
- assert_equal 'geoip.access', emits[0][0] # tag
299
- assert_equal 'Mountain View', emits[0][2]['from_city']
300
- assert_equal 'United States', emits[0][2]['from_country']
301
- assert_equal 37.4192008972168, emits[0][2]['latitude']
302
- assert_equal -122.05740356445312, emits[0][2]['longitude']
303
- assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['float_concat']
304
- assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['float_array']
305
- float_nest = {"lat" => 37.4192008972168, "lon" => -122.05740356445312 }
306
- assert_equal float_nest, emits[0][2]['float_nest']
307
- assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['string_concat']
308
- assert_equal ["Mountain View", "United States"], emits[0][2]['string_array']
309
- string_nest = {"city" => "Mountain View", "country_name" => "United States"}
310
- assert_equal string_nest, emits[0][2]['string_nest']
311
- assert_equal nil, emits[0][2]['unknown_city']
312
- assert_equal nil, emits[0][2]['undefined']
313
- assert_equal [-122.05740356445312, nil], emits[0][2]['broken_array1']
314
- assert_equal [nil, nil], emits[0][2]['broken_array2']
315
-
316
- assert_equal nil, emits[1][2]['from_city']
317
- assert_equal nil, emits[1][2]['from_country']
318
- assert_equal nil, emits[1][2]['latitude']
319
- assert_equal nil, emits[1][2]['longitude']
320
- assert_equal ',', emits[1][2]['float_concat']
321
- assert_equal [nil, nil], emits[1][2]['float_array']
322
- float_nest = {"lat" => nil, "lon" => nil}
323
- assert_equal float_nest, emits[1][2]['float_nest']
324
- assert_equal ',', emits[1][2]['string_concat']
325
- assert_equal [nil, nil], emits[1][2]['string_array']
326
- string_nest = {"city" => nil, "country_name" => nil}
327
- assert_equal string_nest, emits[1][2]['string_nest']
328
- assert_equal nil, emits[1][2]['unknown_city']
329
- assert_equal nil, emits[1][2]['undefined']
330
- assert_equal [nil, nil], emits[1][2]['broken_array1']
331
- assert_equal [nil, nil], emits[1][2]['broken_array2']
692
+ def test_emit_multiline_v1_config
693
+ d1 = create_driver(%[
694
+ backend_library geoip2_compat
695
+ geoip_lookup_key host
696
+ <record>
697
+ location_properties {
698
+ "city": "${city['host']}",
699
+ "country_code": "${country_code['host']}",
700
+ "latitude": "${latitude['host']}",
701
+ "longitude": "${longitude['host']}"
702
+ }
703
+ </record>
704
+ remove_tag_prefix input.
705
+ tag geoip.${tag}
706
+ ], 'input.access', true)
707
+ d1.run do
708
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
709
+ end
710
+ emits = d1.emits
711
+ assert_equal 1, emits.length
712
+ assert_equal 'geoip.access', emits[0][0] # tag
713
+ location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.419200000000004, "longitude"=>-122.0574 }
714
+ assert_equal location_properties, emits[0][2]['location_properties']
715
+ end
332
716
  end
333
717
 
334
- def test_emit_record_directive_multiple_record
335
- d1 = create_driver(%[
336
- geoip_lookup_key from.ip, to.ip
337
- <record>
338
- from_city ${city['from.ip']}
339
- to_city ${city['to.ip']}
340
- from_country ${country_name['from.ip']}
341
- to_country ${country_name['to.ip']}
342
- string_array [${country_name['from.ip']}, ${country_name['to.ip']}]
343
- </record>
344
- remove_tag_prefix input.
345
- tag geoip.${tag}
346
- ], 'input.access')
347
- d1.run do
348
- d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
349
- d1.emit({'message' => 'missing field'})
350
- end
351
- emits = d1.emits
352
- assert_equal 2, emits.length
353
-
354
- assert_equal 'geoip.access', emits[0][0] # tag
355
- assert_equal 'Mountain View', emits[0][2]['from_city']
356
- assert_equal 'United States', emits[0][2]['from_country']
357
- assert_equal 'Tokorozawa', emits[0][2]['to_city']
358
- assert_equal 'Japan', emits[0][2]['to_country']
359
- assert_equal ['United States','Japan'], emits[0][2]['string_array']
360
-
361
- assert_equal nil, emits[1][2]['from_city']
362
- assert_equal nil, emits[1][2]['to_city']
363
- assert_equal nil, emits[1][2]['from_country']
364
- assert_equal nil, emits[1][2]['to_country']
365
- assert_equal [nil, nil], emits[1][2]['string_array']
366
- end
718
+ sub_test_case "geoip legacy" do
719
+ def test_emit
720
+ d1 = create_driver(%[
721
+ geoip_lookup_key host
722
+ enable_key_city geoip_city
723
+ remove_tag_prefix input.
724
+ tag geoip.${tag}
725
+ ], 'input.access')
726
+ d1.run do
727
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
728
+ d1.emit({'message' => 'missing field'})
729
+ end
730
+ emits = d1.emits
731
+ assert_equal 2, emits.length
732
+ assert_equal 'geoip.access', emits[0][0] # tag
733
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
734
+ assert_equal nil, emits[1][2]['geoip_city']
735
+ end
367
736
 
368
- CONFIG_QUOTED_RECORD = %[
369
- geoip_lookup_key host
370
- <record>
371
- location_properties '{ "country_code" : "${country_code["host"]}", "lat": ${latitude["host"]}, "lon": ${longitude["host"]} }'
372
- location_string ${latitude['host']},${longitude['host']}
373
- location_string2 ${country_code["host"]}
374
- location_array "[${longitude['host']},${latitude['host']}]"
375
- location_array2 '[${longitude["host"]},${latitude["host"]}]'
376
- peculiar_pattern '[GEOIP] message => {"lat":${latitude["host"]}, "lon":${longitude["host"]}}'
377
- </record>
378
- remove_tag_prefix input.
379
- tag geoip.${tag}
380
- ]
381
-
382
- def test_emit_quoted_record
383
- d1 = create_driver(CONFIG_QUOTED_RECORD, 'input.access')
384
- d1.run do
385
- d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
386
- end
387
- emits = d1.emits
388
- assert_equal 1, emits.length
389
- assert_equal 'geoip.access', emits[0][0] # tag
390
- location_properties = { "country_code" => "US", "lat" => 37.4192008972168, "lon"=> -122.05740356445312 }
391
- assert_equal location_properties, emits[0][2]['location_properties']
392
- assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['location_string']
393
- assert_equal 'US', emits[0][2]['location_string2']
394
- assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array']
395
- assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array2']
396
- assert_equal '[GEOIP] message => {"lat":37.4192008972168, "lon":-122.05740356445312}', emits[0][2]['peculiar_pattern']
397
- end
737
+ def test_emit_tag_option
738
+ d1 = create_driver(%[
739
+ geoip_lookup_key host
740
+ <record>
741
+ geoip_city ${city['host']}
742
+ </record>
743
+ remove_tag_prefix input.
744
+ tag geoip.${tag}
745
+ ], 'input.access')
746
+ d1.run do
747
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
748
+ d1.emit({'message' => 'missing field'})
749
+ end
750
+ emits = d1.emits
751
+ assert_equal 2, emits.length
752
+ assert_equal 'geoip.access', emits[0][0] # tag
753
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
754
+ assert_equal nil, emits[1][2]['geoip_city']
755
+ end
398
756
 
399
- def test_emit_v1_config_compatibility
400
- d1 = create_driver(CONFIG_QUOTED_RECORD, 'input.access', true)
401
- d1.run do
402
- d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
403
- end
404
- emits = d1.emits
405
- assert_equal 1, emits.length
406
- assert_equal 'geoip.access', emits[0][0] # tag
407
- location_properties = { "country_code" => "US", "lat" => 37.4192008972168, "lon"=> -122.05740356445312 }
408
- assert_equal location_properties, emits[0][2]['location_properties']
409
- assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['location_string']
410
- assert_equal 'US', emits[0][2]['location_string2']
411
- assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array']
412
- assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array2']
413
- assert_equal '[GEOIP] message => {"lat":37.4192008972168, "lon":-122.05740356445312}', emits[0][2]['peculiar_pattern']
414
- end
757
+ def test_emit_tag_parts
758
+ d1 = create_driver(%[
759
+ geoip_lookup_key host
760
+ <record>
761
+ geoip_city ${city['host']}
762
+ </record>
763
+ tag geoip.${tag_parts[1]}.${tag_parts[2..3]}.${tag_parts[-1]}
764
+ ], '0.1.2.3')
765
+ d1.run do
766
+ d1.emit({'host' => '66.102.3.80'})
767
+ end
768
+ emits = d1.emits
769
+ assert_equal 1, emits.length
770
+ assert_equal 'geoip.1.2.3.3', emits[0][0] # tag
771
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
772
+ end
415
773
 
416
- def test_emit_multiline_v1_config
417
- d1 = create_driver(%[
418
- geoip_lookup_key host
419
- <record>
420
- location_properties {
421
- "city": "${city['host']}",
422
- "country_code": "${country_code['host']}",
423
- "latitude": "${latitude['host']}",
424
- "longitude": "${longitude['host']}"
425
- }
426
- </record>
427
- remove_tag_prefix input.
428
- tag geoip.${tag}
429
- ], 'input.access', true)
430
- d1.run do
431
- d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
432
- end
433
- emits = d1.emits
434
- assert_equal 1, emits.length
435
- assert_equal 'geoip.access', emits[0][0] # tag
436
- location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.4192008972168, "longitude"=>-122.05740356445312 }
437
- assert_equal location_properties, emits[0][2]['location_properties']
774
+ def test_emit_with_dot_key
775
+ d1 = create_driver(%[
776
+ geoip_lookup_key ip.origin, ip.dest
777
+ <record>
778
+ origin_country ${country_code['ip.origin']}
779
+ dest_country ${country_code['ip.dest']}
780
+ </record>
781
+ remove_tag_prefix input.
782
+ tag geoip.${tag}
783
+ ], 'input.access')
784
+ d1.run do
785
+ d1.emit({'ip.origin' => '66.102.3.80', 'ip.dest' => '8.8.8.8'})
786
+ end
787
+ emits = d1.emits
788
+ assert_equal 1, emits.length
789
+ assert_equal 'geoip.access', emits[0][0] # tag
790
+ assert_equal 'US', emits[0][2]['origin_country']
791
+ assert_equal 'US', emits[0][2]['dest_country']
792
+ end
793
+
794
+ def test_emit_nested_attr
795
+ d1 = create_driver(%[
796
+ geoip_lookup_key host.ip
797
+ enable_key_city geoip_city
798
+ remove_tag_prefix input.
799
+ add_tag_prefix geoip.
800
+ ], 'input.access')
801
+ d1.run do
802
+ d1.emit({'host' => {'ip' => '66.102.3.80'}, 'message' => 'valid ip'})
803
+ d1.emit({'message' => 'missing field'})
804
+ end
805
+ emits = d1.emits
806
+ assert_equal 2, emits.length
807
+ assert_equal 'geoip.access', emits[0][0] # tag
808
+ assert_equal 'Mountain View', emits[0][2]['geoip_city']
809
+ assert_equal nil, emits[1][2]['geoip_city']
810
+ end
811
+
812
+ def test_emit_with_unknown_address
813
+ d1 = create_driver(%[
814
+ geoip_lookup_key host
815
+ <record>
816
+ geoip_city ${city['host']}
817
+ geopoint [${longitude['host']}, ${latitude['host']}]
818
+ </record>
819
+ skip_adding_null_record false
820
+ remove_tag_prefix input.
821
+ tag geoip.${tag}
822
+ ], 'input.access')
823
+ d1.run do
824
+ # 203.0.113.1 is a test address described in RFC5737
825
+ d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
826
+ d1.emit({'host' => '0', 'message' => 'invalid ip'})
827
+ end
828
+ emits = d1.emits
829
+ assert_equal 2, emits.length
830
+ assert_equal 'geoip.access', emits[0][0] # tag
831
+ assert_equal nil, emits[0][2]['geoip_city']
832
+ assert_equal 'geoip.access', emits[1][0] # tag
833
+ assert_equal nil, emits[1][2]['geoip_city']
834
+ end
835
+
836
+ def test_emit_with_skip_unknown_address
837
+ d1 = create_driver(%[
838
+ geoip_lookup_key host
839
+ <record>
840
+ geoip_city ${city['host']}
841
+ geopoint [${longitude['host']}, ${latitude['host']}]
842
+ </record>
843
+ skip_adding_null_record true
844
+ remove_tag_prefix input.
845
+ tag geoip.${tag}
846
+ ], 'input.access')
847
+ d1.run do
848
+ # 203.0.113.1 is a test address described in RFC5737
849
+ d1.emit({'host' => '203.0.113.1', 'message' => 'invalid ip'})
850
+ d1.emit({'host' => '0', 'message' => 'invalid ip'})
851
+ d1.emit({'host' => '8.8.8.8', 'message' => 'google public dns'})
852
+ end
853
+ emits = d1.emits
854
+ assert_equal 3, emits.length
855
+ assert_equal 'geoip.access', emits[0][0] # tag
856
+ assert_equal nil, emits[0][2]['geoip_city']
857
+ assert_equal nil, emits[0][2]['geopoint']
858
+ assert_equal 'geoip.access', emits[1][0] # tag
859
+ assert_equal nil, emits[1][2]['geoip_city']
860
+ assert_equal nil, emits[1][2]['geopoint']
861
+ assert_equal 'Mountain View', emits[2][2]['geoip_city']
862
+ assert_equal [-122.08380126953125, 37.38600158691406], emits[2][2]['geopoint']
863
+ end
864
+
865
+ def test_emit_multiple_key
866
+ d1 = create_driver(%[
867
+ geoip_lookup_key from.ip, to.ip
868
+ enable_key_city from_city, to_city
869
+ remove_tag_prefix input.
870
+ add_tag_prefix geoip.
871
+ ], 'input.access')
872
+ d1.run do
873
+ d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
874
+ d1.emit({'message' => 'missing field'})
875
+ end
876
+ emits = d1.emits
877
+ assert_equal 2, emits.length
878
+ assert_equal 'geoip.access', emits[0][0] # tag
879
+ assert_equal 'Mountain View', emits[0][2]['from_city']
880
+ assert_equal 'Tokorozawa', emits[0][2]['to_city']
881
+ assert_equal nil, emits[1][2]['from_city']
882
+ assert_equal nil, emits[1][2]['to_city']
883
+ end
884
+
885
+ def test_emit_multiple_key_multiple_record
886
+ d1 = create_driver(%[
887
+ geoip_lookup_key from.ip, to.ip
888
+ enable_key_city from_city, to_city
889
+ enable_key_country_name from_country, to_country
890
+ remove_tag_prefix input.
891
+ add_tag_prefix geoip.
892
+ ], 'input.access')
893
+ d1.run do
894
+ d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
895
+ d1.emit({'from' => {'ip' => '66.102.3.80'}})
896
+ d1.emit({'message' => 'missing field'})
897
+ end
898
+ emits = d1.emits
899
+ assert_equal 3, emits.length
900
+ assert_equal 'geoip.access', emits[0][0] # tag
901
+ assert_equal 'Mountain View', emits[0][2]['from_city']
902
+ assert_equal 'United States', emits[0][2]['from_country']
903
+ assert_equal 'Tokorozawa', emits[0][2]['to_city']
904
+ assert_equal 'Japan', emits[0][2]['to_country']
905
+
906
+ assert_equal 'Mountain View', emits[1][2]['from_city']
907
+ assert_equal 'United States', emits[1][2]['from_country']
908
+ assert_equal nil, emits[1][2]['to_city']
909
+ assert_equal nil, emits[1][2]['to_country']
910
+
911
+ assert_equal nil, emits[2][2]['from_city']
912
+ assert_equal nil, emits[2][2]['from_country']
913
+ assert_equal nil, emits[2][2]['to_city']
914
+ assert_equal nil, emits[2][2]['to_country']
915
+ end
916
+
917
+ def test_emit_record_directive
918
+ d1 = create_driver(%[
919
+ geoip_lookup_key from.ip
920
+ <record>
921
+ from_city ${city['from.ip']}
922
+ from_country ${country_name['from.ip']}
923
+ latitude ${latitude['from.ip']}
924
+ longitude ${longitude['from.ip']}
925
+ float_concat ${latitude['from.ip']},${longitude['from.ip']}
926
+ float_array [${longitude['from.ip']}, ${latitude['from.ip']}]
927
+ float_nest { "lat" : ${latitude['from.ip']}, "lon" : ${longitude['from.ip']}}
928
+ string_concat ${latitude['from.ip']},${longitude['from.ip']}
929
+ string_array [${city['from.ip']}, ${country_name['from.ip']}]
930
+ string_nest { "city" : ${city['from.ip']}, "country_name" : ${country_name['from.ip']}}
931
+ unknown_city ${city['unknown_key']}
932
+ undefined ${city['undefined']}
933
+ broken_array1 [${longitude['from.ip']}, ${latitude['undefined']}]
934
+ broken_array2 [${longitude['undefined']}, ${latitude['undefined']}]
935
+ </record>
936
+ remove_tag_prefix input.
937
+ tag geoip.${tag}
938
+ ], 'input.access')
939
+ d1.run do
940
+ d1.emit({'from' => {'ip' => '66.102.3.80'}})
941
+ d1.emit({'message' => 'missing field'})
942
+ end
943
+ emits = d1.emits
944
+ assert_equal 2, emits.length
945
+
946
+ assert_equal 'geoip.access', emits[0][0] # tag
947
+ assert_equal 'Mountain View', emits[0][2]['from_city']
948
+ assert_equal 'United States', emits[0][2]['from_country']
949
+ assert_equal 37.4192008972168, emits[0][2]['latitude']
950
+ assert_equal -122.05740356445312, emits[0][2]['longitude']
951
+ assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['float_concat']
952
+ assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['float_array']
953
+ float_nest = {"lat" => 37.4192008972168, "lon" => -122.05740356445312 }
954
+ assert_equal float_nest, emits[0][2]['float_nest']
955
+ assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['string_concat']
956
+ assert_equal ["Mountain View", "United States"], emits[0][2]['string_array']
957
+ string_nest = {"city" => "Mountain View", "country_name" => "United States"}
958
+ assert_equal string_nest, emits[0][2]['string_nest']
959
+ assert_equal nil, emits[0][2]['unknown_city']
960
+ assert_equal nil, emits[0][2]['undefined']
961
+ assert_equal [-122.05740356445312, nil], emits[0][2]['broken_array1']
962
+ assert_equal [nil, nil], emits[0][2]['broken_array2']
963
+
964
+ assert_equal nil, emits[1][2]['from_city']
965
+ assert_equal nil, emits[1][2]['from_country']
966
+ assert_equal nil, emits[1][2]['latitude']
967
+ assert_equal nil, emits[1][2]['longitude']
968
+ assert_equal ',', emits[1][2]['float_concat']
969
+ assert_equal [nil, nil], emits[1][2]['float_array']
970
+ float_nest = {"lat" => nil, "lon" => nil}
971
+ assert_equal float_nest, emits[1][2]['float_nest']
972
+ assert_equal ',', emits[1][2]['string_concat']
973
+ assert_equal [nil, nil], emits[1][2]['string_array']
974
+ string_nest = {"city" => nil, "country_name" => nil}
975
+ assert_equal string_nest, emits[1][2]['string_nest']
976
+ assert_equal nil, emits[1][2]['unknown_city']
977
+ assert_equal nil, emits[1][2]['undefined']
978
+ assert_equal [nil, nil], emits[1][2]['broken_array1']
979
+ assert_equal [nil, nil], emits[1][2]['broken_array2']
980
+ end
981
+
982
+ def test_emit_record_directive_multiple_record
983
+ d1 = create_driver(%[
984
+ geoip_lookup_key from.ip, to.ip
985
+ <record>
986
+ from_city ${city['from.ip']}
987
+ to_city ${city['to.ip']}
988
+ from_country ${country_name['from.ip']}
989
+ to_country ${country_name['to.ip']}
990
+ string_array [${country_name['from.ip']}, ${country_name['to.ip']}]
991
+ </record>
992
+ remove_tag_prefix input.
993
+ tag geoip.${tag}
994
+ ], 'input.access')
995
+ d1.run do
996
+ d1.emit({'from' => {'ip' => '66.102.3.80'}, 'to' => {'ip' => '125.54.15.42'}})
997
+ d1.emit({'message' => 'missing field'})
998
+ end
999
+ emits = d1.emits
1000
+ assert_equal 2, emits.length
1001
+
1002
+ assert_equal 'geoip.access', emits[0][0] # tag
1003
+ assert_equal 'Mountain View', emits[0][2]['from_city']
1004
+ assert_equal 'United States', emits[0][2]['from_country']
1005
+ assert_equal 'Tokorozawa', emits[0][2]['to_city']
1006
+ assert_equal 'Japan', emits[0][2]['to_country']
1007
+ assert_equal ['United States','Japan'], emits[0][2]['string_array']
1008
+
1009
+ assert_equal nil, emits[1][2]['from_city']
1010
+ assert_equal nil, emits[1][2]['to_city']
1011
+ assert_equal nil, emits[1][2]['from_country']
1012
+ assert_equal nil, emits[1][2]['to_country']
1013
+ assert_equal [nil, nil], emits[1][2]['string_array']
1014
+ end
1015
+
1016
+ def config_quoted_record
1017
+ %[
1018
+ geoip_lookup_key host
1019
+ <record>
1020
+ location_properties '{ "country_code" : "${country_code["host"]}", "lat": ${latitude["host"]}, "lon": ${longitude["host"]} }'
1021
+ location_string ${latitude['host']},${longitude['host']}
1022
+ location_string2 ${country_code["host"]}
1023
+ location_array "[${longitude['host']},${latitude['host']}]"
1024
+ location_array2 '[${longitude["host"]},${latitude["host"]}]'
1025
+ peculiar_pattern '[GEOIP] message => {"lat":${latitude["host"]}, "lon":${longitude["host"]}}'
1026
+ </record>
1027
+ remove_tag_prefix input.
1028
+ tag geoip.${tag}
1029
+ ]
1030
+ end
1031
+
1032
+ def test_emit_quoted_record
1033
+ d1 = create_driver(config_quoted_record, 'input.access')
1034
+ d1.run do
1035
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
1036
+ end
1037
+ emits = d1.emits
1038
+ assert_equal 1, emits.length
1039
+ assert_equal 'geoip.access', emits[0][0] # tag
1040
+ location_properties = { "country_code" => "US", "lat" => 37.4192008972168, "lon"=> -122.05740356445312 }
1041
+ assert_equal location_properties, emits[0][2]['location_properties']
1042
+ assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['location_string']
1043
+ assert_equal 'US', emits[0][2]['location_string2']
1044
+ assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array']
1045
+ assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array2']
1046
+ assert_equal '[GEOIP] message => {"lat":37.4192008972168, "lon":-122.05740356445312}', emits[0][2]['peculiar_pattern']
1047
+ end
1048
+
1049
+ def test_emit_v1_config_compatibility
1050
+ d1 = create_driver(config_quoted_record, 'input.access', true)
1051
+ d1.run do
1052
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
1053
+ end
1054
+ emits = d1.emits
1055
+ assert_equal 1, emits.length
1056
+ assert_equal 'geoip.access', emits[0][0] # tag
1057
+ location_properties = { "country_code" => "US", "lat" => 37.4192008972168, "lon"=> -122.05740356445312 }
1058
+ assert_equal location_properties, emits[0][2]['location_properties']
1059
+ assert_equal '37.4192008972168,-122.05740356445312', emits[0][2]['location_string']
1060
+ assert_equal 'US', emits[0][2]['location_string2']
1061
+ assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array']
1062
+ assert_equal [-122.05740356445312, 37.4192008972168], emits[0][2]['location_array2']
1063
+ assert_equal '[GEOIP] message => {"lat":37.4192008972168, "lon":-122.05740356445312}', emits[0][2]['peculiar_pattern']
1064
+ end
1065
+
1066
+ def test_emit_multiline_v1_config
1067
+ d1 = create_driver(%[
1068
+ geoip_lookup_key host
1069
+ <record>
1070
+ location_properties {
1071
+ "city": "${city['host']}",
1072
+ "country_code": "${country_code['host']}",
1073
+ "latitude": "${latitude['host']}",
1074
+ "longitude": "${longitude['host']}"
1075
+ }
1076
+ </record>
1077
+ remove_tag_prefix input.
1078
+ tag geoip.${tag}
1079
+ ], 'input.access', true)
1080
+ d1.run do
1081
+ d1.emit({'host' => '66.102.3.80', 'message' => 'valid ip'})
1082
+ end
1083
+ emits = d1.emits
1084
+ assert_equal 1, emits.length
1085
+ assert_equal 'geoip.access', emits[0][0] # tag
1086
+ location_properties = { "city"=>"Mountain View", "country_code"=>"US", "latitude"=>37.4192008972168, "longitude"=>-122.05740356445312 }
1087
+ assert_equal location_properties, emits[0][2]['location_properties']
1088
+ end
438
1089
  end
439
1090
  end
440
-