メトリクス集計 - トップメトリクス（Top metrics） - 《Elasticsearchガイドv8.15》日本語

トップメトリクス集約
ソート
メトリクス
欠損
サイズ
例

トップメトリクス集約

top_metrics 集約は、最も大きいまたは最も小さい「ソート」値を持つドキュメントからメトリクスを選択します。たとえば、これは s の最大値を持つドキュメントの m フィールドの値を取得します:

Python

resp = client.bulk(
   index="test",
   refresh=True,
   operations=[
   {
   "index": {}
   },
   {
   "s": 1,
   "m": 3.1415
   },
   {
   "index": {}
   },
   {
   "s": 2,
   "m": 1
   },
   {
   "index": {}
   },
   {
   "s": 3,
   "m": 2.71828
   }
   ],
)
print(resp)
resp1 = client.search(
   index="test",
   filter_path="aggregations",
   aggs={
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "s": "desc"
   }
   }
   }
   },
)
print(resp1)

Ruby

response = client.bulk(
  index: 'test',
  refresh: true,
  body: [
   {
   index: {}
   },
   {
   s: 1,
   m: 3.1415
   },
   {
   index: {}
   },
   {
   s: 2,
   m: 1
   },
   {
   index: {}
   },
   {
   s: 3,
   m: 2.71828
   }
  ]
)
puts response
response = client.search(
  index: 'test',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   s: 'desc'
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.bulk({
  index: "test",
  refresh: "true",
  operations: [
   {
   index: {},
   },
   {
   s: 1,
   m: 3.1415,
   },
   {
   index: {},
   },
   {
   s: 2,
   m: 1,
   },
   {
   index: {},
   },
   {
   s: 3,
   m: 2.71828,
   },
  ],
});
console.log(response);
const response1 = await client.search({
  index: "test",
  filter_path: "aggregations",
  aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   s: "desc",
   },
   },
   },
  },
});
console.log(response1);

コンソール

POST /test/_bulk?refresh
{"index": {}}
{"s": 1, "m": 3.1415}
{"index": {}}
{"s": 2, "m": 1.0}
{"index": {}}
{"s": 3, "m": 2.71828}
POST /test/_search?filter_path=aggregations
{
  "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"s": "desc"}
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "tm": {
   "top": [ {"sort": [3], "metrics": {"m": 2.718280076980591 } } ]
   }
  }
}

top_metrics は、精神的には top_hits にかなり似ていますが、より制限されているため、少ないメモリで作業を行うことができ、しばしば高速です。

ソート

メトリクスリクエストの sort フィールドは、検索リクエストの sort フィールドとまったく同じように機能しますが、次の点を除いて:

バイナリ、フラット化、IP、キーワード、またはテキストフィールドには使用できません。
単一のソート値のみをサポートしているため、どのドキュメントが同点で勝つかは指定されていません。

集約が返すメトリクスは、検索リクエストによって返される最初のヒットです。したがって、

"sort": {"s": "desc"}
最高の s を持つドキュメントからメトリクスを取得します。
"sort": {"s": "asc"}
最低の s を持つドキュメントからメトリクスを取得します。
"sort": {"_geo_distance": {"location": "POINT (-78.6382 35.7796)"}}
35.7796, -78.6382 に 最も近い location を持つドキュメントからメトリクスを取得します。
"sort": "_score"
最高のスコアを持つドキュメントからメトリクスを取得します。

メトリクス

metrics は、返す「トップ」ドキュメントのフィールドを選択します。"metrics": {"field": "m"} のように単一のメトリクスをリクエストするか、"metrics": [{"field": "m"}, {"field": "i"} のようにメトリクスのリストをリクエストすることで複数のメトリクスをリクエストできます。

metrics.field は次のフィールドタイプをサポートしています:

キーワードを除いて、対応するタイプのランタイムフィールドもサポートされています。metrics.field は配列値を持つフィールドをサポートしていません。配列値に対する top_metric 集約は、一貫性のない結果を返す可能性があります。

次の例は、いくつかのフィールドタイプに対して top_metrics 集約を実行します。

Python

resp = client.indices.create(
   index="test",
   mappings={
   "properties": {
   "d": {
   "type": "date"
   }
   }
   },
)
print(resp)
resp1 = client.bulk(
   index="test",
   refresh=True,
   operations=[
   {
   "index": {}
   },
   {
   "s": 1,
   "m": 3.1415,
   "i": 1,
   "d": "2020-01-01T00:12:12Z",
   "t": "cat"
   },
   {
   "index": {}
   },
   {
   "s": 2,
   "m": 1,
   "i": 6,
   "d": "2020-01-02T00:12:12Z",
   "t": "dog"
   },
   {
   "index": {}
   },
   {
   "s": 3,
   "m": 2.71828,
   "i": -12,
   "d": "2019-12-31T00:12:12Z",
   "t": "chicken"
   }
   ],
)
print(resp1)
resp2 = client.search(
   index="test",
   filter_path="aggregations",
   aggs={
   "tm": {
   "top_metrics": {
   "metrics": [
   {
   "field": "m"
   },
   {
   "field": "i"
   },
   {
   "field": "d"
   },
   {
   "field": "t.keyword"
   }
   ],
   "sort": {
   "s": "desc"
   }
   }
   }
   },
)
print(resp2)

Ruby

response = client.indices.create(
  index: 'test',
  body: {
   mappings: {
   properties: {
   d: {
   type: 'date'
   }
   }
   }
  }
)
puts response
response = client.bulk(
  index: 'test',
  refresh: true,
  body: [
   {
   index: {}
   },
   {
   s: 1,
   m: 3.1415,
   i: 1,
   d: '2020-01-01T00:12:12Z',
   t: 'cat'
   },
   {
   index: {}
   },
   {
   s: 2,
   m: 1,
   i: 6,
   d: '2020-01-02T00:12:12Z',
   t: 'dog'
   },
   {
   index: {}
   },
   {
   s: 3,
   m: 2.71828,
   i: -12,
   d: '2019-12-31T00:12:12Z',
   t: 'chicken'
   }
  ]
)
puts response
response = client.search(
  index: 'test',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   tm: {
   top_metrics: {
   metrics: [
   {
   field: 'm'
   },
   {
   field: 'i'
   },
   {
   field: 'd'
   },
   {
   field: 't.keyword'
   }
   ],
   sort: {
   s: 'desc'
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "test",
  mappings: {
   properties: {
   d: {
   type: "date",
   },
   },
  },
});
console.log(response);
const response1 = await client.bulk({
  index: "test",
  refresh: "true",
  operations: [
   {
   index: {},
   },
   {
   s: 1,
   m: 3.1415,
   i: 1,
   d: "2020-01-01T00:12:12Z",
   t: "cat",
   },
   {
   index: {},
   },
   {
   s: 2,
   m: 1,
   i: 6,
   d: "2020-01-02T00:12:12Z",
   t: "dog",
   },
   {
   index: {},
   },
   {
   s: 3,
   m: 2.71828,
   i: -12,
   d: "2019-12-31T00:12:12Z",
   t: "chicken",
   },
  ],
});
console.log(response1);
const response2 = await client.search({
  index: "test",
  filter_path: "aggregations",
  aggs: {
   tm: {
   top_metrics: {
   metrics: [
   {
   field: "m",
   },
   {
   field: "i",
   },
   {
   field: "d",
   },
   {
   field: "t.keyword",
   },
   ],
   sort: {
   s: "desc",
   },
   },
   },
  },
});
console.log(response2);

コンソール

PUT /test
{
  "mappings": {
   "properties": {
   "d": {"type": "date"}
   }
  }
}
POST /test/_bulk?refresh
{"index": {}}
{"s": 1, "m": 3.1415, "i": 1, "d": "2020-01-01T00:12:12Z", "t": "cat"}
{"index": {}}
{"s": 2, "m": 1.0, "i": 6, "d": "2020-01-02T00:12:12Z", "t": "dog"}
{"index": {}}
{"s": 3, "m": 2.71828, "i": -12, "d": "2019-12-31T00:12:12Z", "t": "chicken"}
POST /test/_search?filter_path=aggregations
{
  "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": [
   {"field": "m"},
   {"field": "i"},
   {"field": "d"},
   {"field": "t.keyword"}
   ],
   "sort": {"s": "desc"}
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "tm": {
   "top": [ {
   "sort": [3],
   "metrics": {
   "m": 2.718280076980591,
   "i": -12,
   "d": "2019-12-31T00:12:12.000Z",
   "t.keyword": "chicken"
   }
   } ]
   }
  }
}

欠損

missing パラメータは、欠損値を持つドキュメントがどのように扱われるかを定義します。デフォルトでは、キーコンポーネントのいずれかが欠損している場合、ドキュメント全体が無視されます。missing パラメータを使用することで、欠損コンポーネントを値があるかのように扱うことが可能です。

Python

resp = client.indices.create(
   index="my-index",
   mappings={
   "properties": {
   "nr": {
   "type": "integer"
   },
   "state": {
   "type": "keyword"
   }
   }
   },
)
print(resp)
resp1 = client.bulk(
   index="my-index",
   refresh=True,
   operations=[
   {
   "index": {}
   },
   {
   "nr": 1,
   "state": "started"
   },
   {
   "index": {}
   },
   {
   "nr": 2,
   "state": "stopped"
   },
   {
   "index": {}
   },
   {
   "nr": 3,
   "state": "N/A"
   },
   {
   "index": {}
   },
   {
   "nr": 4
   }
   ],
)
print(resp1)
resp2 = client.search(
   index="my-index",
   filter_path="aggregations",
   aggs={
   "my_top_metrics": {
   "top_metrics": {
   "metrics": {
   "field": "state",
   "missing": "N/A"
   },
   "sort": {
   "nr": "desc"
   }
   }
   }
   },
)
print(resp2)

Ruby

response = client.indices.create(
  index: 'my-index',
  body: {
   mappings: {
   properties: {
   nr: {
   type: 'integer'
   },
   state: {
   type: 'keyword'
   }
   }
   }
  }
)
puts response
response = client.bulk(
  index: 'my-index',
  refresh: true,
  body: [
   {
   index: {}
   },
   {
   nr: 1,
   state: 'started'
   },
   {
   index: {}
   },
   {
   nr: 2,
   state: 'stopped'
   },
   {
   index: {}
   },
   {
   nr: 3,
   state: 'N/A'
   },
   {
   index: {}
   },
   {
   nr: 4
   }
  ]
)
puts response
response = client.search(
  index: 'my-index',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   my_top_metrics: {
   top_metrics: {
   metrics: {
   field: 'state',
   missing: 'N/A'
   },
   sort: {
   nr: 'desc'
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "my-index",
  mappings: {
   properties: {
   nr: {
   type: "integer",
   },
   state: {
   type: "keyword",
   },
   },
  },
});
console.log(response);
const response1 = await client.bulk({
  index: "my-index",
  refresh: "true",
  operations: [
   {
   index: {},
   },
   {
   nr: 1,
   state: "started",
   },
   {
   index: {},
   },
   {
   nr: 2,
   state: "stopped",
   },
   {
   index: {},
   },
   {
   nr: 3,
   state: "N/A",
   },
   {
   index: {},
   },
   {
   nr: 4,
   },
  ],
});
console.log(response1);
const response2 = await client.search({
  index: "my-index",
  filter_path: "aggregations",
  aggs: {
   my_top_metrics: {
   top_metrics: {
   metrics: {
   field: "state",
   missing: "N/A",
   },
   sort: {
   nr: "desc",
   },
   },
   },
  },
});
console.log(response2);

コンソール

PUT /my-index
{
  "mappings": {
   "properties": {
   "nr":    { "type": "integer" },
   "state":  { "type": "keyword"  }
   }
  }
}
POST /my-index/_bulk?refresh
{"index": {}}
{"nr": 1, "state": "started"}
{"index": {}}
{"nr": 2, "state": "stopped"}
{"index": {}}
{"nr": 3, "state": "N/A"}
{"index": {}}
{"nr": 4}
POST /my-index/_search?filter_path=aggregations
{
  "aggs": {
   "my_top_metrics": {
   "top_metrics": {
   "metrics": {
   "field": "state",
   "missing": "N/A"},
   "sort": {"nr": "desc"}
   }
   }
  }
}


	テキストコンテンツに集約を使用する場合、それは `keyword` タイプフィールドである必要があります、またはそのフィールドでフィールドデータを有効にする必要があります。
	このドキュメントには欠損した `state` フィールド値があります。
	`missing` パラメータは、`state` フィールドに欠損値がある場合、それが `N/A` 値を持つかのように扱われるべきであることを定義します。

リクエストは次の応答を生成します:

コンソール-結果

{
  "aggregations": {
   "my_top_metrics": {
   "top": [
   {
   "sort": [
   4
   ],
   "metrics": {
   "state": "N/A"
   }
   }
   ]
   }
  }
}

サイズ

top_metrics は、サイズパラメータを使用して、上位のいくつかのドキュメントのメトリクスを返すことができます:

Python

resp = client.bulk(
   index="test",
   refresh=True,
   operations=[
   {
   "index": {}
   },
   {
   "s": 1,
   "m": 3.1415
   },
   {
   "index": {}
   },
   {
   "s": 2,
   "m": 1
   },
   {
   "index": {}
   },
   {
   "s": 3,
   "m": 2.71828
   }
   ],
)
print(resp)
resp1 = client.search(
   index="test",
   filter_path="aggregations",
   aggs={
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "s": "desc"
   },
   "size": 3
   }
   }
   },
)
print(resp1)

Ruby

response = client.bulk(
  index: 'test',
  refresh: true,
  body: [
   {
   index: {}
   },
   {
   s: 1,
   m: 3.1415
   },
   {
   index: {}
   },
   {
   s: 2,
   m: 1
   },
   {
   index: {}
   },
   {
   s: 3,
   m: 2.71828
   }
  ]
)
puts response
response = client.search(
  index: 'test',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   s: 'desc'
   },
   size: 3
   }
   }
   }
  }
)
puts response

Js

const response = await client.bulk({
  index: "test",
  refresh: "true",
  operations: [
   {
   index: {},
   },
   {
   s: 1,
   m: 3.1415,
   },
   {
   index: {},
   },
   {
   s: 2,
   m: 1,
   },
   {
   index: {},
   },
   {
   s: 3,
   m: 2.71828,
   },
  ],
});
console.log(response);
const response1 = await client.search({
  index: "test",
  filter_path: "aggregations",
  aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   s: "desc",
   },
   size: 3,
   },
   },
  },
});
console.log(response1);

コンソール

POST /test/_bulk?refresh
{"index": {}}
{"s": 1, "m": 3.1415}
{"index": {}}
{"s": 2, "m": 1.0}
{"index": {}}
{"s": 3, "m": 2.71828}
POST /test/_search?filter_path=aggregations
{
  "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"s": "desc"},
   "size": 3
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "tm": {
   "top": [
   {"sort": [3], "metrics": {"m": 2.718280076980591 } },
   {"sort": [2], "metrics": {"m": 1.0 } },
   {"sort": [1], "metrics": {"m": 3.1414999961853027 } }
   ]
   }
  }
}

デフォルトの size は 1 です。最大デフォルトサイズは 10 です。集約の作業ストレージは「密」であり、各バケットに size スロットを割り当てます。10 は 非常に 保守的なデフォルトの最大値であり、top_metrics_max_size インデックス設定を変更することで必要に応じて引き上げることができます。しかし、大きなサイズはかなりのメモリを消費する可能性があることを知っておいてください。特に、大きな用語集約のように多くのバケットを作成する集約の内部にある場合はそうです。引き上げたい場合は、次のようにします:

Python

resp = client.indices.put_settings(
   index="test",
   settings={
   "top_metrics_max_size": 100
   },
)
print(resp)

Ruby

response = client.indices.put_settings(
  index: 'test',
  body: {
   top_metrics_max_size: 100
  }
)
puts response

Js

const response = await client.indices.putSettings({
  index: "test",
  settings: {
   top_metrics_max_size: 100,
  },
});
console.log(response);

コンソール

PUT /test/_settings
{
  "top_metrics_max_size": 100
}

size が 1 より大きい場合、top_metrics 集約はソートの ターゲット になれません。

例

用語との併用

この集約は、terms 集約内で非常に便利で、たとえば、各サーバーによって報告された最後の値を見つけるために使用されるべきです。

Python

resp = client.indices.create(
   index="node",
   mappings={
   "properties": {
   "ip": {
   "type": "ip"
   },
   "date": {
   "type": "date"
   }
   }
   },
)
print(resp)
resp1 = client.bulk(
   index="node",
   refresh=True,
   operations=[
   {
   "index": {}
   },
   {
   "ip": "192.168.0.1",
   "date": "2020-01-01T01:01:01",
   "m": 1
   },
   {
   "index": {}
   },
   {
   "ip": "192.168.0.1",
   "date": "2020-01-01T02:01:01",
   "m": 2
   },
   {
   "index": {}
   },
   {
   "ip": "192.168.0.2",
   "date": "2020-01-01T02:01:01",
   "m": 3
   }
   ],
)
print(resp1)
resp2 = client.search(
   index="node",
   filter_path="aggregations",
   aggs={
   "ip": {
   "terms": {
   "field": "ip"
   },
   "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "date": "desc"
   }
   }
   }
   }
   }
   },
)
print(resp2)

Ruby

response = client.indices.create(
  index: 'node',
  body: {
   mappings: {
   properties: {
   ip: {
   type: 'ip'
   },
   date: {
   type: 'date'
   }
   }
   }
  }
)
puts response
response = client.bulk(
  index: 'node',
  refresh: true,
  body: [
   {
   index: {}
   },
   {
   ip: '192.168.0.1',
   date: '2020-01-01T01:01:01',
   m: 1
   },
   {
   index: {}
   },
   {
   ip: '192.168.0.1',
   date: '2020-01-01T02:01:01',
   m: 2
   },
   {
   index: {}
   },
   {
   ip: '192.168.0.2',
   date: '2020-01-01T02:01:01',
   m: 3
   }
  ]
)
puts response
response = client.search(
  index: 'node',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   ip: {
   terms: {
   field: 'ip'
   },
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   date: 'desc'
   }
   }
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.indices.create({
  index: "node",
  mappings: {
   properties: {
   ip: {
   type: "ip",
   },
   date: {
   type: "date",
   },
   },
  },
});
console.log(response);
const response1 = await client.bulk({
  index: "node",
  refresh: "true",
  operations: [
   {
   index: {},
   },
   {
   ip: "192.168.0.1",
   date: "2020-01-01T01:01:01",
   m: 1,
   },
   {
   index: {},
   },
   {
   ip: "192.168.0.1",
   date: "2020-01-01T02:01:01",
   m: 2,
   },
   {
   index: {},
   },
   {
   ip: "192.168.0.2",
   date: "2020-01-01T02:01:01",
   m: 3,
   },
  ],
});
console.log(response1);
const response2 = await client.search({
  index: "node",
  filter_path: "aggregations",
  aggs: {
   ip: {
   terms: {
   field: "ip",
   },
   aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   date: "desc",
   },
   },
   },
   },
   },
  },
});
console.log(response2);

コンソール

PUT /node
{
  "mappings": {
   "properties": {
   "ip": {"type": "ip"},
   "date": {"type": "date"}
   }
  }
}
POST /node/_bulk?refresh
{"index": {}}
{"ip": "192.168.0.1", "date": "2020-01-01T01:01:01", "m": 1}
{"index": {}}
{"ip": "192.168.0.1", "date": "2020-01-01T02:01:01", "m": 2}
{"index": {}}
{"ip": "192.168.0.2", "date": "2020-01-01T02:01:01", "m": 3}
POST /node/_search?filter_path=aggregations
{
  "aggs": {
   "ip": {
   "terms": {
   "field": "ip"
   },
   "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"date": "desc"}
   }
   }
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "ip": {
   "buckets": [
   {
   "key": "192.168.0.1",
   "doc_count": 2,
   "tm": {
   "top": [ {"sort": ["2020-01-01T02:01:01.000Z"], "metrics": {"m": 2 } } ]
   }
   },
   {
   "key": "192.168.0.2",
   "doc_count": 1,
   "tm": {
   "top": [ {"sort": ["2020-01-01T02:01:01.000Z"], "metrics": {"m": 3 } } ]
   }
   }
   ],
   "doc_count_error_upper_bound": 0,
   "sum_other_doc_count": 0
   }
  }
}

top_hits とは異なり、このメトリクスの結果でバケットをソートできます:

Python

resp = client.search(
   index="node",
   filter_path="aggregations",
   aggs={
   "ip": {
   "terms": {
   "field": "ip",
   "order": {
   "tm.m": "desc"
   }
   },
   "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "date": "desc"
   }
   }
   }
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'node',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   ip: {
   terms: {
   field: 'ip',
   order: {
   'tm.m' => 'desc'
   }
   },
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   date: 'desc'
   }
   }
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "node",
  filter_path: "aggregations",
  aggs: {
   ip: {
   terms: {
   field: "ip",
   order: {
   "tm.m": "desc",
   },
   },
   aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   date: "desc",
   },
   },
   },
   },
   },
  },
});
console.log(response);

コンソール

POST /node/_search?filter_path=aggregations
{
  "aggs": {
   "ip": {
   "terms": {
   "field": "ip",
   "order": {"tm.m": "desc"}
   },
   "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"date": "desc"}
   }
   }
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "ip": {
   "buckets": [
   {
   "key": "192.168.0.2",
   "doc_count": 1,
   "tm": {
   "top": [ {"sort": ["2020-01-01T02:01:01.000Z"], "metrics": {"m": 3 } } ]
   }
   },
   {
   "key": "192.168.0.1",
   "doc_count": 2,
   "tm": {
   "top": [ {"sort": ["2020-01-01T02:01:01.000Z"], "metrics": {"m": 2 } } ]
   }
   }
   ],
   "doc_count_error_upper_bound": 0,
   "sum_other_doc_count": 0
   }
  }
}

混合ソートタイプ

top_metrics を異なるインデックス間で異なるタイプを持つフィールドでソートすると、やや驚くべき結果が得られます: 浮動小数点フィールドは常に整数フィールドとは独立してソートされます。

Python

resp = client.bulk(
   index="test",
   refresh=True,
   operations=[
   {
   "index": {
   "_index": "test1"
   }
   },
   {
   "s": 1,
   "m": 3.1415
   },
   {
   "index": {
   "_index": "test1"
   }
   },
   {
   "s": 2,
   "m": 1
   },
   {
   "index": {
   "_index": "test2"
   }
   },
   {
   "s": 3.1,
   "m": 2.71828
   }
   ],
)
print(resp)
resp1 = client.search(
   index="test*",
   filter_path="aggregations",
   aggs={
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "s": "asc"
   }
   }
   }
   },
)
print(resp1)

Ruby

response = client.bulk(
  index: 'test',
  refresh: true,
  body: [
   {
   index: {
   _index: 'test1'
   }
   },
   {
   s: 1,
   m: 3.1415
   },
   {
   index: {
   _index: 'test1'
   }
   },
   {
   s: 2,
   m: 1
   },
   {
   index: {
   _index: 'test2'
   }
   },
   {
   s: 3.1,
   m: 2.71828
   }
  ]
)
puts response
response = client.search(
  index: 'test*',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   s: 'asc'
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.bulk({
  index: "test",
  refresh: "true",
  operations: [
   {
   index: {
   _index: "test1",
   },
   },
   {
   s: 1,
   m: 3.1415,
   },
   {
   index: {
   _index: "test1",
   },
   },
   {
   s: 2,
   m: 1,
   },
   {
   index: {
   _index: "test2",
   },
   },
   {
   s: 3.1,
   m: 2.71828,
   },
  ],
});
console.log(response);
const response1 = await client.search({
  index: "test*",
  filter_path: "aggregations",
  aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   s: "asc",
   },
   },
   },
  },
});
console.log(response1);

コンソール

POST /test/_bulk?refresh
{"index": {"_index": "test1"}}
{"s": 1, "m": 3.1415}
{"index": {"_index": "test1"}}
{"s": 2, "m": 1}
{"index": {"_index": "test2"}}
{"s": 3.1, "m": 2.71828}
POST /test*/_search?filter_path=aggregations
{
  "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"s": "asc"}
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "tm": {
   "top": [ {"sort": [3.0999999046325684], "metrics": {"m": 2.718280076980591 } } ]
   }
  }
}

これはエラーよりは良いですが、おそらく あなたが目指していたものではありません。いくつかの精度を失いますが、次のようにして整数フィールドを浮動小数点に明示的にキャストできます:

Python

resp = client.search(
   index="test*",
   filter_path="aggregations",
   aggs={
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "s": {
   "order": "asc",
   "numeric_type": "double"
   }
   }
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'test*',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   s: {
   order: 'asc',
   numeric_type: 'double'
   }
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "test*",
  filter_path: "aggregations",
  aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   s: {
   order: "asc",
   numeric_type: "double",
   },
   },
   },
   },
  },
});
console.log(response);

コンソール

POST /test*/_search?filter_path=aggregations
{
  "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"s": {"order": "asc", "numeric_type": "double"}}
   }
   }
  }
}

どのように返されるか:

Js

{
  "aggregations": {
   "tm": {
   "top": [ {"sort": [1.0], "metrics": {"m": 3.1414999961853027 } } ]
   }
  }
}

パイプライン集約での使用

top_metrics は、バケットごとに単一の値を消費するパイプライン集約で使用できます。たとえば、SQLのHAVING句を使用するのと同様に、バケットフィルタリングを適用する bucket_selector です。これには、size を 1 に設定し、ラッピング集約器に渡す (単一の) メトリクスの正しいパスを指定する必要があります。たとえば:

Python

resp = client.search(
   index="test*",
   filter_path="aggregations",
   aggs={
   "ip": {
   "terms": {
   "field": "ip"
   },
   "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {
   "field": "m"
   },
   "sort": {
   "s": "desc"
   },
   "size": 1
   }
   },
   "having_tm": {
   "bucket_selector": {
   "buckets_path": {
   "top_m": "tm[m]"
   },
   "script": "params.top_m < 1000"
   }
   }
   }
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'test*',
  filter_path: 'aggregations',
  body: {
   aggregations: {
   ip: {
   terms: {
   field: 'ip'
   },
   aggregations: {
   tm: {
   top_metrics: {
   metrics: {
   field: 'm'
   },
   sort: {
   s: 'desc'
   },
   size: 1
   }
   },
   having_tm: {
   bucket_selector: {
   buckets_path: {
   top_m: 'tm[m]'
   },
   script: 'params.top_m < 1000'
   }
   }
   }
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "test*",
  filter_path: "aggregations",
  aggs: {
   ip: {
   terms: {
   field: "ip",
   },
   aggs: {
   tm: {
   top_metrics: {
   metrics: {
   field: "m",
   },
   sort: {
   s: "desc",
   },
   size: 1,
   },
   },
   having_tm: {
   bucket_selector: {
   buckets_path: {
   top_m: "tm[m]",
   },
   script: "params.top_m < 1000",
   },
   },
   },
   },
  },
});
console.log(response);

コンソール

POST /test*/_search?filter_path=aggregations
{
  "aggs": {
   "ip": {
   "terms": {
   "field": "ip"
   },
   "aggs": {
   "tm": {
   "top_metrics": {
   "metrics": {"field": "m"},
   "sort": {"s": "desc"},
   "size": 1
   }
   },
   "having_tm": {
   "bucket_selector": {
   "buckets_path": {
   "top_m": "tm[m]"
   },
   "script": "params.top_m < 1000"
   }
   }
   }
   }
  }
}

bucket_path は top_metrics 名 tm と、集約値を提供するメトリクスのキーワードである m を使用します。