1PMSERIES(1)                 General Commands Manual                PMSERIES(1)
2
3
4

NAME

6       pmseries - display information about performance metric timeseries
7

SYNOPSIS

9       pmseries  [-adFiIlLmMnqsStvV?]   [-c config] [-g pattern] [-h host] [-p
10       port] [-w window] [-Z timezone] [query | labels  ...  |  series  ...  |
11       source ... ]
12

DESCRIPTION

14       pmseries  displays  various types of information about performance met‐
15       rics available through the scalable timeseries facilities of  the  Per‐
16       formance Co-Pilot (PCP) and the Redis distributed data store.
17
18       By  default pmseries communicates with a local redis-server(1), however
19       the -h and -p options can be used to specify  an  alternate  Redis  in‐
20       stance.   If  this instance is a node of a Redis cluster, all other in‐
21       stances in the cluster will be discovered and used automatically.
22
23       pmseries runs in several different modes - either  querying  timeseries
24       identifiers,  metadata or values (already stored in Redis), or manually
25       loading timeseries into Redis.  The latter mode is generally only  used
26       for  loading previously collected (inactive) archives, since pmproxy(1)
27       automatically performs this function for "live" (actively growing)  lo‐
28       cal  pmlogger(1)  instances,  when  running  in its default time series
29       mode.  See the TIMESERIES LOADING section below and the -L  option  for
30       further details.
31
32       Without  command line options specifying otherwise, pmseries will issue
33       a timeseries query to find matching timeseries and values.   All  time‐
34       series  are  identified  using a unique SHA-1 hash which is always dis‐
35       played in a 40-hexdigit human readable form.  These hashes  are  formed
36       using the metadata associated with every metric.
37
38       Importantly, this includes all metric metadata (labels, names, descrip‐
39       tors).  Metric labels in particular are (as far as possible) unique for
40       every  machine  - on Linux for example the labels associated with every
41       metric include the unique /etc/machine-id,  the  hostname,  domainname,
42       and other automatically generated machine labels, as well as any admin‐
43       istrator-defined labels from /etc/pcp/labels.  These labels can be  re‐
44       ported with pminfo(1) and the pmcd.labels metric.
45
46       See   pmLookupLabels(3),   pmLookupInDom(3),  pmLookupName(3)  and  pm‐
47       LookupDesc(3) for detailed information about metric  labels  and  other
48       metric metadata used in each timeseries identifier hash calculation.
49
50       The timeseries identifiers provide a higher level (and machine indepen‐
51       dent) identifier than the traditional PCP  performance  metric  identi‐
52       fiers  (pmID),  instance domain identifiers (pmInDom) and metric names.
53       See PCPIntro(1) for more details about these  traditional  identifiers.
54       However, pmseries uses timeseries identifiers in much the same way that
55       pminfo(1) uses the lower level indom,  metric  identifiers  and  metric
56       names.
57
58       The  default  mode of pmseries operation (i.e. with no command line op‐
59       tions) depends on the arguments it is presented.  If all non-option ar‐
60       guments  appear to be timeseries identifiers (in 40 hex digit form) pm‐
61       series will report metadata for these timeseries - refer to the -a  op‐
62       tion for details.  Otherwise, the parameters will be treated as a time‐
63       series query.
64

TIMESERIES QUERIES

66       Query expressions are formed using  the  pmseries  query  language  de‐
67       scribed below, but can be as simple as a metric name.
68
69       The  following is an example of querying timeseries from all hosts that
70       match a metric name pattern (globbed):
71
72         $ pmseries kernel.all.cpu*
73         1d7b0bb3f6aec0f49c54f5210885464a53629b60
74         379db729afd63fb9eff436625bd6c55a7adc5cfd
75         3dd3b45bb05f96636043e5d58b52b441ce542285
76         [...]
77         ed2bf325ff6dc7589ec966698e5404b67252306a
78         dcb2a032a308b5717bf605ba8f8737e9c6e1ed19
79
80       To identify timeseries expression operands, the query language uses the
81       general syntax:
82
83         [metric.name] '{metadata qualifiers}' '[time specification]'
84
85       The  metric.name component restricts the timeseries query to any match‐
86       ing PCP metric name (the list of metric names for a PCP archive or live
87       host  is reported by pminfo(1) with no arguments beyond --host or --ar‐
88       chive).  The pmseries syntax extends on that of pminfo and  allows  for
89       glob(7)  based  pattern matching within the metric name.  The above de‐
90       scribes operands available as the leaves of pmseries expressions, which
91       may  include  functions,  arithmetic operators and other features.  See
92       the EXPRESSIONS section below for further details.
93

METADATA QUALIFIERS AND METADATA OPERATORS

95       Metadata qualifiers are enclosed by ``curly'' braces ({}), and  further
96       restrict the query results to timeseries operands with various metadata
97       properties.  These qualifiers are based on metric  or  instance  names,
98       and metric label values, and take the general form metadata.name OPERA‐
99       TOR value, such as:
100
101         instance.name == "cpu0"
102         metric.name != "kernel.all.pswitch"
103
104       When using label names, the metadata qualifier is optional and  can  be
105       dropped, such as:
106
107         label.hostname == "www.acme.com"
108         hostname == "www.acme.com"
109
110       For  metric and instance names only the string operators apply, but for
111       metric label values all operators are available.  The set of  available
112       operators is:
113
114   Boolean operators
115       All  string  (label,  metrics and instances) and numeric (label) values
116       can be tested for equality ("==") or inequality ("!=").
117
118   String operators
119       Strings can be subject to pattern matching in the form of glob matching
120       ("~~"), regular expression matching ("=~"), and regular expression non-
121       matching ("!~").  The ":" operator is equivalent to "~~" -  i.e.,  glob
122       matching.
123
124   Relational operators (numeric label values only)
125       Numeric  label  values  can  be subject to the less than ("<"), greater
126       than (">"), less than or equal ("<="), greater than  or  equal  (">="),
127       equal ("==") and not equal ("!=") operators.
128
129   Logical operators
130       Multiple metadata qualifiers can be combined with the logical operators
131       for AND ("&&") and OR ("||") as in  many  programming  languages.   The
132       comma (",") character is equivalent to logical AND ("&&").
133

TIME SPECIFICATION

135       The  final (optional) component of a query allows the user to specify a
136       specific time window of interest.  Any time specification  will  result
137       in  values being returned for all matching timeseries only for the time
138       window specified.
139
140       The specification is ``square'' bracket ([]) enclosed, and consists  of
141       one  or more comma-separated components.  Each component specifies some
142       aspect related to time, taking the general form: keyword:  value,  such
143       as:
144
145         samples:10
146
147   Sample count
148       The  number  of  samples to return, specified via either the samples or
149       (equivalent) count keyword.  The value provided must be a positive  in‐
150       teger.   If  no  end time is explicitly set (see ``Time window'' later)
151       then the most recent samples will be returned.
152
153   Sample interval
154       An interval between successive samples can be requested using  the  in‐
155       terval or (equivalent) delta keyword.  The value provided should be ei‐
156       ther a numeric or string value that will  be  parsed  by  pmParseInter‐
157       val(3), such as 5 (seconds) or 2min (minutes).
158
159   Time window
160       Start  and  end  times,  and alignments, affecting the returned values.
161       The keywords match the parameters to the pmParseTimeWindow(3)  function
162       which will be used to parse them, and are: start or (equivalent) begin,
163       finish or (equivalent) end, align and offset.
164
165   Time zones
166       The resulting timestamps can be returned having been  evaluated  for  a
167       specific  timezone, using the timezone or hostzone keywords.  The value
168       associated with timezone will be interpreted by pmNewZone(3).   A  true
169       or false value should be associated with hostzone, and when set to true
170       this has the same effect as described by pmNewContextZone(3).
171

EXPRESSIONS

173       As described above, operands are the leaves of a query expression tree.
174
175         [metric.name] '{metadata qualifiers}' '[time specification]'
176       Note in most of the query expression examples below, the metadata qual‐
177       ifiers  have been omitted for brevity.  In all cases, multiple time se‐
178       ries may qualify, particularly for the hostname label.
179
180       In the simple case, a query expression consists of a single operand and
181       may  just  be a metric name.  In the more general case, a query expres‐
182       sion is either an operand or the argument to a function, or  two  oper‐
183       ands in a binary arithmetic or logical expression.  Most functions take
184       a single argument (an expression), though some require additional argu‐
185       ments, e.g.  rescale.
186
187         operand | expr operator expr | func(expr[, arg])
188
189       This  grammar  shows expressions may be nested, e.g. using the addition
190       (+) operator as an example,
191
192         func1(func2(expr))
193         func1(expr) + func2(expr)
194         expr + func(expr)
195         func(expr) + expr
196         expr + expr
197
198       Rules governing compatibility of operands in  an  expression  generally
199       depend  on  the function and/or operators and are described below indi‐
200       vidually.  An important rule is that if any time windows are specified,
201       then  all  operands  must  cover the same number of samples, though the
202       time windows may differ individually.  If no  time  windows  or  sample
203       counts  are  given, then pmseries will return a series identifier (SID)
204       instead of a series of timestamps and values.  This SID may be used  in
205       subsequent  /series/values?series=SID  RESTAPI calls, along with a spe‐
206       cific time window.
207
208   Arithmetic Operators
209       pmseries support addition, subtraction, division and multiplication  on
210       each  value  in the time series of a binary pair of operands.  No unary
211       or ternary operators are supported (yet).  In all cases,  the  instance
212       domain  and  the  number of samples of time series operands must be the
213       same.  The metadata (units and dimensions)  must  also  be  compatible.
214       Depending  on  the  function, the result will usually have the same in‐
215       stance domain and (unless noted otherwise), the same units as the oper‐
216       ands.   The  metadata dimensions (space, time, count) of the result may
217       differ (see below).
218
219       Expression operands may have different qualifiers, e.g. you can perform
220       binary  arithmetic  on  metrics  qualified by different labels (such as
221       hostname), or metric names.  For example, to add the  two  most  recent
222       samples  of  the  process  context  switch (pswitch) counter metric for
223       hosts node88 and node89, and then perform rate conversion:
224
225         $ pmseries 'rate(kernel.all.pswitch{hostname:node88}[count:2] +
226                          kernel.all.pswitch{hostname:node89}[count:2])'
227         1cf1a85d5978640ef94c68264d3ae8866cc11f7c
228             [Tue Nov 10 14:39:48.771868000 2020] 71.257509 8e0a59304eb99237b89593a3e839b5bb8b9a9924
229
230       Note the resulting time series of values has one less sample  than  the
231       expression operand passed to the rate function.
232
233       Other rules for arithmetic expressions:
234
235       1. if both operands have the semantics of a counter, then only addition
236       and subtraction are allowed
237
238       2. if the left operand is a counter and the right operand is not,  then
239       only multiplication or division are allowed
240
241       3.  if  the  left  operand  is not a counter and the right operand is a
242       counter, then only multiplication is allowed.
243
244       4. addition and subtraction - the dimensions of the result are the same
245       as the dimensions of the operands.
246
247       5. multiplication - the dimensions of the result are the sum of the di‐
248       mensions of the operands.
249
250       6. division - the dimensions of the result are the  difference  of  the
251       dimensions of the operands.
252
253   Functions
254       Expression  functions operate on vectors of time series values, and may
255       be nested with other functions or expressions as described above.  When
256       an  operand  has multiple instances, there will generally be one result
257       for each series of instances.  For example, the result for
258
259         $ pmseries 'min_sample(kernel.all.load[count:100])'
260
261       will be the smallest value of the 100  most  recent  samples,  treating
262       each of the three load average instances as a separate time series.  As
263       an example, for the two most recent samples for each of the  three  in‐
264       stances of the load average metric:
265
266         $ pmseries 'kernel.all.load[count:2]'
267         726a325c4c1ba4339ecffcdebd240f441ea77848
268             [Tue Nov 10 11:52:30.833379000 2020] 1.100000e+00 a7c96e5e2e0431a12279756d11590fa9fed8f306
269             [Tue Nov 10 11:52:30.833379000 2020] 9.900000e-01 ee9b506935fd0976a893dc27242926f49326b9a1
270             [Tue Nov 10 11:52:30.833379000 2020] 1.070000e+00 d5e1c360d13064c461169091997e1e8be7488133
271             [Tue Nov 10 11:52:20.827134000 2020] 1.120000e+00 a7c96e5e2e0431a12279756d11590fa9fed8f306
272             [Tue Nov 10 11:52:20.827134000 2020] 9.900000e-01 ee9b506935fd0976a893dc27242926f49326b9a1
273             [Tue Nov 10 11:52:20.827134000 2020] 1.070000e+00 d5e1c360d13064c461169091997e1e8be7488133
274
275       Using the min_sample function :
276
277         $ pmseries 'min_sample(kernel.all.load[count:2])'
278         11b965bc5f9598034ed9139fb3a78c6c0b7065ba
279             [Tue Nov 10 11:52:30.833379000 2020] 1.100000e+00 a7c96e5e2e0431a12279756d11590fa9fed8f306
280             [Tue Nov 10 11:52:30.833379000 2020] 9.900000e-01 ee9b506935fd0976a893dc27242926f49326b9a1
281             [Tue Nov 10 11:52:30.833379000 2020] 1.070000e+00 d5e1c360d13064c461169091997e1e8be7488133
282
283       For singular metrics (with no instance domain), a single value will re‐
284       sult, e.g. for the five most recent samples of  the  context  switching
285       metric:
286
287         $ pmseries 'kernel.all.pswitch[count:5]'
288         d7832c4fba33bcc980b1a1b614e0508043288480
289             [Tue Nov 10 12:44:59.380666000 2020] 460774294
290             [Tue Nov 10 12:44:49.382070000 2020] 460747232
291             [Tue Nov 10 12:44:39.378545000 2020] 460722370
292             [Tue Nov 10 12:44:29.379029000 2020] 460697388
293             [Tue Nov 10 12:44:19.379096000 2020] 460657412
294
295         $ pmseries 'min_sample(kernel.all.pswitch[count:5])'
296         1b6e92fb5bc012372f54452734dd03f0f131fa06
297             [Tue Nov 10 12:44:19.379096000 2020] 460657412 d7832c4fba33bcc980b1a1b614e0508043288480
298
299
300       Some  pmseries  functions  provide  operations across both time and in‐
301       stances domain. For example, max_inst(expr)  finds  the  maximum  value
302       across  instances while max_sample(expr) finds the maximum value across
303       time.
304
305       Future versions of pmseries may provide functions that perform aggrega‐
306       tion, interpolation, filtering or transforms in other ways.
307
308   Function Reference
309       max_inst(expr)  the  maximum value in the time series for each instance
310       of expr.  For backwards compatibility, the synonym max is equivalent to
311       max_inst.
312
313       max_sample(expr)  the  maximum value in the time series for each sample
314       of expr across time.
315
316       min_inst(expr) the minimum value in the time series for  each  instance
317       of expr.  For backwards compatibility, the synonym min is equivalent to
318       min_inst.
319
320       min_sample(expr) the minimum value in the time series for  each  sample
321       of expr across time.
322
323       sum_inst(expr)  sum  of the values in the time series for each instance
324       of expr.  For backwards compatibility, the synonym sum is equivalent to
325       sum_inst.
326
327       sum_sample(expr)  sum  of the values in the time series for each sample
328       of expr across time.
329
330       avg_inst(expr) average of the values in the time series  for  each  in‐
331       stance of expr.  For backwards compatibility, the synonym avg is equiv‐
332       alent to avg_inst.
333
334       avg_sample(expr) average of the values in the time series for each sam‐
335       ple of expr across time.
336
337       rate(expr) the rate with respect to time of each sample.  The given ex‐
338       pr must have counter semantics and the result will have instant  seman‐
339       tics (the time dimension reduced by one).  In addition, the result will
340       have one less sample than the operand - this is because the first  sam‐
341       ple cannot be rate converted (two samples are required).
342
343       rescale(expr,scale)  rescale the values in the time series for each in‐
344       stance of expr to scale (units).  Note that expr should have instant or
345       discrete  semantics (not counter - rate conversion should be done first
346       if needed).  The time, space and  count  dimensions  between  expr  and
347       scale  must  be  compatible.  Example: rate convert the read throughput
348       counter for each disk instance and then rescale to mbytes  per  second.
349       Note  the  native  units  of disk.dev.read_bytes is a counter of kbytes
350       read from each device instance since boot.
351
352         $ pmseries 'rescale(rate(disk.dev.read_bytes[count:4]), "mbytes/s")'
353
354       abs(expr) the absolute value of each value in the time series for  each
355       instance of expr.  This has no effect if the type of expr is unsigned.
356
357       floor(expr)  rounded  down to the nearest integer value of the time se‐
358       ries for each instance of expr.
359
360       round(expr) rounded up or down to the nearest integer for each value in
361       the time series for each instance of expr.
362
363       log(expr)  logarithm of the values in the time series for each instance
364       of expr
365
366       sqrt(expr) square root of the values in the time series  for  each  in‐
367       stance of expr
368
369       stdev_inst(expr)  standard  deviation  of the values in the time series
370       for each instance of expr.
371
372       stdev_sample(expr) standard deviation of the values in the time  series
373       for each sample of expr across time.
374
375       topk_inst(expr,k) the top k values in the time series for each instance
376       of expr.
377
378       topk_sample(expr,k) the top k values in the time series for each sample
379       of expr across time.
380
381       nth_percentile_inst(expr,percentile_value)  the  nth  percentile of the
382       values in the time series for each instance of  expr.  Note  that  per‐
383       centile_value has value in the range 0 to 100.
384
385       nth_percentile_sample(expr,percentile_value)  the nth percentile of the
386       values in the time series for each sample of expr  across  time.   Note
387       that percentile_value has value in the range 0 to 100.
388
389
390   Compatibility
391       All operands in an expression must have the same number of samples, but
392       not necessarily the same time window. e.g. you could subtract some met‐
393       ric  time  series from today from that of yesterday by giving different
394       time windows and different metrics or  qualifiers,  ensuring  the  same
395       number of samples are given as the operands.
396
397       Operands  in an expression must either all have a time window, or none.
398       If no operands have a time window, then instead of  a  series  of  time
399       stamps  and  values,  the result will be a time series identifier (SID)
400       that may be passed to the /series/values?series=SID REST API  function,
401       along with a time window.  For further details, see PMWEBAPI(3).
402
403       If  the  semantics of both operands in an arithmetic expression are not
404       counter (i.e. PM_SEM_INSTANT or PM_SEM_DISCRETE) then the  result  will
405       have  semantics PM_SEM_INSTANT unless both operands are PM_SEM_DISCRETE
406       in which case the result is also PM_SEM_DISCRETE.
407

TIMESERIES METADATA

409       Using command line options, pmseries can be requested to provide  meta‐
410       data  (metric  names,  instance  names, labels, descriptors) associated
411       with either individual timeseries or a group of timeseries,  for  exam‐
412       ple:
413
414         $ pmseries -a dcb2a032a308b5717bf605ba8f8737e9c6e1ed19
415
416         dcb2a032a308b5717bf605ba8f8737e9c6e1ed19
417             PMID: 60.0.21
418             Data Type: 64-bit unsigned int  InDom: PM_INDOM_NULL 0xffffffff
419             Semantics: counter  Units: millisec
420             Source: f5ca7481da8c038325d15612bb1c6473ce1ef16f
421             Metric: kernel.all.cpu.nice
422             labels {"agent":"linux","domainname":"localdomain",\
423                     "groupid":1000,"hostname":"shard",\
424                     "latitude":-25.28496,"longitude":152.87886,\
425                     "machineid":"295b16e3b6074cc8bdbda8bf96f6930a",\
426                     "userid":1000}
427
428       The complete set of pmseries metadata reporting options are:
429
430       -a, --all
431            Convenience  option  to  report  all  metadata for the given time‐
432            series, equivalent to -deilms.
433
434       -d, --desc
435            Metric descriptions detailing the PMID, data type, data semantics,
436            units,  scale  and  associated instance domain.  This option has a
437            direct pminfo(1) equivalent.
438
439       -F, --fast
440            Query or load series metadata only, not values.
441
442       -g pattern, --glob=pattern
443            Provide a glob(7) pattern to restrict the report provided  by  the
444            -i, -l, -m, and -S.
445
446       -i, --instances
447            Metric descriptions detailing the PMID, data type, data semantics,
448            units, scale and associated instance domain.
449
450       -I, --fullindom
451            Print the InDom in verbose mode.  This option has a  direct  pmin‐
452            fo(1) equivalent.
453
454       -l, --labels
455            Print  label  sets  associated with metrics and instances.  Labels
456            are optional metric metadata described in  detail  in  pmLookupLa‐
457            bels(3).  This option has a direct pminfo(1) equivalent.
458
459       -m, --metrics
460            Print metric names.
461
462       -M, --fullpmid
463            Print  the  PMID  in verbose mode.  This option has a direct pmin‐
464            fo(1) equivalent.
465
466       -n, --names
467            Print comma-separated label names only (not values) for the labels
468            associated with metrics and instances.
469
470       -s, --series
471            Print  timeseries  identifiers  associated with metrics, instances
472            and sources.  These unique identifiers are calculated from intrin‐
473            sic  (non-optional)  labels  and  other metric metadata associated
474            with each PMAPI context (sources),  metrics  and  instances.   Ar‐
475            chive,  local context or pmcd(1) connections for the same host all
476            produce the same source identifier.   This  option  has  a  direct
477            pminfo(1) equivalent.  See also pmLookupLabels(3) and the -l/--la‐
478            bels option.
479

TIMESERIES SOURCES

481       A source is a unique identifier (represented externally  as  a  40-byte
482       hexadecimal  SHA-1  hash) that represents both the live host and/or ar‐
483       chives from which each timeseries originated.  The context for a source
484       identifier (obtained with -s) can be reported with:
485
486       -S, --sources
487            Print  names for timeseries sources.  These names are either host‐
488            names or fully qualified archive paths.
489
490       It is important to note that live and archive sources can and will gen‐
491       erate  the same SHA-1 source identifier hash, provided that the context
492       labels remain the same for that host (labels are stored in PCP archives
493       and can also be fetched live from pmcd(1)).
494

TIMESERIES LOADING

496       Timeseries metadata and data are loaded either automatically by a local
497       pmproxy(1), or manually using a specially crafted  pmseries  query  and
498       the -L/--load option:
499
500         $ pmseries --load "{source.path: \"$PCP_LOG_DIR/pmlogger/acme\"}"
501         pmseries: [Info] processed 2275 archive records from [...]
502
503       This  query  must  specify a source archive path, but can also restrict
504       the import to specific timeseries (using metric names, labels, etc) and
505       to a specific time window using the time specification component of the
506       query language.
507
508       As a convenience, if the argument to load is a valid file path  as  de‐
509       termined by access(2), then a short-hand form can be used:
510
511         $ pmseries --load $PCP_LOG_DIR/pmlogger/acme.0
512
513       NOTE:  Timeseries  loading  is append-only (timestamp-wise) and if more
514       than stream.maxlen entries  (defined  in  $PCP_SYSCONF_DIR/pmseries/pm‐
515       series.conf)  are  loaded  for  a  given metric, the oldest entries are
516       dropped.
517

OPTIONS

519       The available command line options, in addition to timeseries  metadata
520       and sources options described above, are:
521
522       -c config, --config=config
523            Specify the config file to use.
524
525       -h host, --host=host
526            Connect Redis server at host, rather than the one the localhost.
527
528       -L, --load
529            Load timeseries metadata and data into the Redis cluster.
530
531       -p port, --port=port
532            Connect Redis server at port, rather than the default 6379.
533
534       -q, --query
535            Perform a timeseries query.  This is the default action.
536
537       -t, --times
538            Report  time  stamps  numerically (in milliseconds) instead of the
539            default human readable form.
540
541       -v, --values
542            Report all of the known values for given label name(s), or  report
543            values for the given series identifiers.
544
545       -w, --window
546            Provide  a time specification that will be applied to values being
547            returned when returning values via use of series identifiers (i.e.
548            when  not  using a query string).  The time specification uses the
549            same square-bracket enclosed form described earlier in the  ``TIME
550            SPECIFICATION'' section.
551
552       -V, --version
553            Display version number and exit.
554
555       -Z timezone, --timezone=timezone
556            Use  timezone for the date and time.  Timezone is in the format of
557            the environment variable TZ as described in environ(7).
558
559       -?, --help
560            Display usage message and exit.
561

EXAMPLES

563       The following sample query shows several fundamental aspects of the pm‐
564       series query language:
565
566         $ pmseries 'kernel.all.load{hostname:"toium"}[count:2]'
567
568         eb713a9cf472f775aa59ae90c43cd7f960f7870f
569             [Thu Nov 14 05:57:06.082861000 2019] 1.0e-01 b84040ffccd54f839b65140cf139bab51cbbcf62
570             [Thu Nov 14 05:57:06.082861000 2019] 6.8e-01 a60b5b3bf25e71071c41934fa4d7d251f765f30c
571             [Thu Nov 14 05:57:06.082861000 2019] 6.4e-01 e1974a062375e6e62370ffadf5b0650dad739480
572             [Thu Nov 14 05:57:16.091546000 2019] 1.6e-01 b84040ffccd54f839b65140cf139bab51cbbcf62
573             [Thu Nov 14 05:57:16.091546000 2019] 6.7e-01 a60b5b3bf25e71071c41934fa4d7d251f765f30c
574             [Thu Nov 14 05:57:16.091546000 2019] 6.4e-01 e1974a062375e6e62370ffadf5b0650dad739480
575
576       This  query returns the two most recent values for all instances of the
577       kernel.all.load metric with a label.hostname matching the  regular  ex‐
578       pression  "toium".  This is a set-valued metric (i.e., a metric with an
579       ``instance domain'' which in this case consists of three instances:  1,
580       5  and  15 minute averages).  The first column returned is a timestamp,
581       then a floating point value, and finally an instance  identifier  time‐
582       series  hash  (two values returned for three instances, so six rows are
583       returned).  The metadata for these timeseries can then be further exam‐
584       ined:
585
586         $ pmseries -a eb713a9cf472f775aa59ae90c43cd7f960f7870f
587
588         eb713a9cf472f775aa59ae90c43cd7f960f7870f
589             PMID: 60.2.0
590             Data Type: float  InDom: 60.2 0xf000002
591             Semantics: instant  Units: none
592             Source: 0e89c1192db79326900d82131c31399524f0b3ee
593             Metric: kernel.all.load
594             inst [1 or "1 minute"] series b84040ffccd54f839b65140cf139bab51cbbcf62
595             inst [5 or "5 minute"] series a60b5b3bf25e71071c41934fa4d7d251f765f30c
596             inst [15 or "15 minute"] series e1974a062375e6e62370ffadf5b0650dad739480
597             inst [1 or "1 minute"] labels {"agent":"linux","hostname":"toium"}
598             inst [5 or "5 minute"] labels {"agent":"linux","hostname":"toium"}
599             inst [15 or "15 minute"] labels {"agent":"linux","hostname":"toium"}
600

PCP ENVIRONMENT

602       Environment variables with the prefix PCP_ are used to parameterize the
603       file and directory names used by PCP.  On each installation,  the  file
604       /etc/pcp.conf  contains  the  local  values  for  these variables.  The
605       $PCP_CONF variable may be used to specify an alternative  configuration
606       file, as described in pcp.conf(5).
607
608       For environment variables affecting PCP tools, see pmGetOptions(3).
609

SEE ALSO

611       PCPIntro(1),   pmcd(1),  pminfo(1),  pmproxy(1),  redis-server(1),  ac‐
612       cess(2), PMAPI(3), PMWEBAPI(3), pmLookupDesc(3), pmLookupInDom(3),  pm‐
613       LookupLabels(3),  pmLookupName(3),  pmNewContextZone(3),  pmNewZone(3),
614       pmParseInterval(3),  pmParseTimeWindow(3),   pcp.conf(5),   environ(7),
615       glob(7) and regex(7).
616
617
618
619Performance Co-Pilot                  PCP                          PMSERIES(1)
Impressum