Module: Wavefront::Validators

Included in:
CoreApi, Write, Writer::Core
Defined in:
lib/wavefront-sdk/validators.rb

Overview

A module of mixins to validate input. The Wavefront documentation lays down restrictions on types and sizes of various inputs, which we will check on the user’s behalf. Most of the information used in this file comes from community.wavefront.com/docs/DOC-1031 Some comes from the Swagger API documentation, some has come directly from Wavefront engineers.

rubocop:disable Metrics/ModuleLength

Instance Method Summary collapse

Instance Method Details

#uuid?(str) ⇒ Bool

Is the given string a UUID? These are used for various item IDs.

Parameters:

Returns:

  • (Bool) 


23
24
25
 
# File 'lib/wavefront-sdk/validators.rb', line 23

def uuid?(str)
  str.is_a?(String) && str =~ /([a-f\d]{8}(-[a-f\d]{4}){3}-[a-f\d]{12})/
end

#wf_account_id?(id) ⇒ Boolean

Ensure the given argument is a valid User or SystemAccount ID.

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidAccountId if the ID is not valid



590
591
592
593
594
595
596
597
598
 
# File 'lib/wavefront-sdk/validators.rb', line 590

def (id)
  true if wf_user_id?(id)
rescue Wavefront::Exception::InvalidUserId
  begin
    true if wf_serviceaccount_id?(id)
  rescue Wavefront::Exception::InvalidServiceAccountId
    raise Wavefront::Exception::InvalidAccountId, id
  end
end

#wf_alert_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront alert ID. Alerts are identified by the epoch-nanosecond at which they were created.

Parameters:

  • id (String) —

    the alert ID to validate

Returns:

  • (Boolean) —

    True if the alert ID is valid

Raises:

  • Wavefront::Exception::InvalidAlertId if the alert ID is not valid



227
228
229
230
231
232
 
# File 'lib/wavefront-sdk/validators.rb', line 227

def wf_alert_id?(id)
  id = id.to_s if id.is_a?(Numeric)
  return true if id.is_a?(String) && id.match(/^\d{13}$/)

  raise Wavefront::Exception::InvalidAlertId, id
end

#wf_alert_severity?(severity) ⇒ Boolean

Ensure the given argument is a valid alert severity

Parameters:

  • severity (String) —

    severity

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidAlertSeverity if not valid



327
328
329
330
331
 
# File 'lib/wavefront-sdk/validators.rb', line 327

def wf_alert_severity?(severity)
  return true if %w[INFO SMOKE WARN SEVERE].include?(severity)

  raise Wavefront::Exception::InvalidAlertSeverity, severity
end

#wf_apitoken_id?(id) ⇒ Boolean

Ensure the given argument is a valid API token ID

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidApiTokenId if the token ID is not valid



540
541
542
543
544
 
# File 'lib/wavefront-sdk/validators.rb', line 540

def wf_apitoken_id?(id)
  return true if uuid?(id)

  raise Wavefront::Exception::InvalidApiTokenId, id
end

#wf_aws_external_id?(id) ⇒ Boolean

Ensure the given argument is a valid AWS external ID, used in the AWS cloud integration. not valid

Parameters:

  • id (String) —

    the external ID to validate

Returns:

  • (Boolean) —

    true if the external ID is valid

Raises:

  • Wavefront::Exception::InvalidAwsExternalId if the external ID is



650
651
652
653
654
 
# File 'lib/wavefront-sdk/validators.rb', line 650

def wf_aws_external_id?(id)
  return true if id.is_a?(String) && id =~ /^[a-z0-9A-Z]{16}$/

  raise Wavefront::Exception::InvalidAwsExternalId, id
end

#wf_cloudintegration_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront cloud integration ID

Parameters:

  • id (String) —

    the integration name to validate

Returns:

  • (Boolean) —

    True if the integration name is valid

Raises:

  • Wavefront::Exception::InvalidCloudIntegrationId if the integration ID is not valid



242
243
244
245
246
 
# File 'lib/wavefront-sdk/validators.rb', line 242

def wf_cloudintegration_id?(id)
  return true if uuid?(id)

  raise Wavefront::Exception::InvalidCloudIntegrationId, id
end

#wf_dashboard_id?(id) ⇒ Boolean

There doesn’t seem to be a public statement on what’s allowed in a dashboard name. For now I’m going to assume up to 255 word characters.

Parameters:

  • id (String) —

    the dashboard ID to validate

Returns:

  • (Boolean) —

    true if the dashboard ID is valid

Raises:

  • Wavefront::Exception::InvalidDashboardID if the dashboard ID is not valid



257
258
259
260
261
 
# File 'lib/wavefront-sdk/validators.rb', line 257

def wf_dashboard_id?(id)
  return true if id.is_a?(String) && id.size < 256 && id.match(/^[\w-]+$/)

  raise Wavefront::Exception::InvalidDashboardId, id
end

#wf_derivedmetric_id?(id) ⇒ Boolean

Ensure the given argument is a valid derived metric ID. IDs are the millisecond epoch timestamp at which the derived metric was created.

Parameters:

Returns:

  • (Boolean) —

    True if the ID is valid

Raises:

  • Wavefront::Exception::InvalidDerivedMetricId



271
272
273
274
275
276
 
# File 'lib/wavefront-sdk/validators.rb', line 271

def wf_derivedmetric_id?(id)
  id = id.to_s if id.is_a?(Numeric)
  return true if id.is_a?(String) && id =~ /^\d{13}$/

  raise Wavefront::Exception::InvalidDerivedMetricId, id
end

#wf_distribution?(dist) ⇒ Boolean

Validate a distribution description

Parameters:

  • dist (Hash) —

    description of distribution

Returns:

  • (Boolean) —

    true if valid

Raises:

  • whichever exception is thrown first when validating each component of the distribution.



460
461
462
463
464
465
466
467
 
# File 'lib/wavefront-sdk/validators.rb', line 460

def wf_distribution?(dist)
  wf_metric_name?(dist[:path])
  wf_distribution_values?(dist[:value])
  wf_epoch?(dist[:ts]) if dist[:ts]
  wf_source_id?(dist[:source]) if dist[:source]
  wf_point_tags?(dist[:tags]) if dist[:tags]
  true
end

#wf_distribution_count?(count) ⇒ Boolean

Ensure the given argument is a valid distribution count.

Parameters:

  • count (Numeric)

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidDistributionCount if the count is not valid



529
530
531
532
533
 
# File 'lib/wavefront-sdk/validators.rb', line 529

def wf_distribution_count?(count)
  return true if count.is_a?(Integer) && count.positive?

  raise Wavefront::Exception::InvalidDistributionCount, count
end

#wf_distribution_interval?(interval) ⇒ Boolean

Ensure the given argument is a valid distribution interval.

Parameters:

  • interval (Symbol)

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidDistributionInterval if the interval is not valid



518
519
520
521
522
 
# File 'lib/wavefront-sdk/validators.rb', line 518

def wf_distribution_interval?(interval)
  return true if %i[m h d].include?(interval)

  raise Wavefront::Exception::InvalidDistributionInterval, interval
end

#wf_distribution_values?(vals) ⇒ Boolean

Validate an array of distribution values

Parameters:

Returns:

  • (Boolean) —

    true if valid

Raises:

  • whichever exception is thrown first when validating each component of the distribution.



478
479
480
481
482
483
484
 
# File 'lib/wavefront-sdk/validators.rb', line 478

def wf_distribution_values?(vals)
  vals.each do |times, val|
    wf_distribution_count?(times)
    wf_value?(val)
  end
  true
end

#wf_epoch?(timestamp) ⇒ Boolean

Ensure the given argument is a valid epoch timestamp. Again, no range checking.

Parameters:

Returns:

  • (Boolean) —

    True if the timestamp is valid

Raises:

  • Wavefront::Exception::InvalidMaintenanceWindow



125
126
127
128
129
 
# File 'lib/wavefront-sdk/validators.rb', line 125

def wf_epoch?(timestamp)
  return true if timestamp.is_a?(Numeric)

  raise Wavefront::Exception::InvalidTimestamp, timestamp
end

#wf_event_id?(id) ⇒ Boolean

Ensure the given argument is a valid event ID. Event IDs are an epoch-millisecond timestamp followed by a : followed by the name of the event.

Parameters:

  • id (String) —

    the event ID to validate

Returns:

  • (Boolean) —

    true if the event ID is valid

Raises:

  • Wavefront::Exception::InvalidEventID if the event ID is not valid



287
288
289
290
291
 
# File 'lib/wavefront-sdk/validators.rb', line 287

def wf_event_id?(id)
  return true if id.is_a?(String) && id =~ /^\d{13}:.+/

  raise Wavefront::Exception::InvalidEventId, id
end

#wf_granularity?(granularity) ⇒ Boolean

Ensure the given argument is a valid query granularity

Parameters:

  • granularity (String) —

    granularity

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidGranularity if not valid



352
353
354
355
356
 
# File 'lib/wavefront-sdk/validators.rb', line 352

def wf_granularity?(granularity)
  return true if %w[d h m s].include?(granularity.to_s)

  raise Wavefront::Exception::InvalidGranularity, granularity
end

#wf_ingestionpolicy_id?(id) ⇒ Boolean

Ensure the given argument is a valid ingestion policy ID

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidIngestionPolicyId if the ID is not valid



579
580
581
582
583
 
# File 'lib/wavefront-sdk/validators.rb', line 579

def wf_ingestionpolicy_id?(id)
  return true if id.is_a?(String) && id =~ /^[a-z0-9\-_]+-\d{13}$/

  raise Wavefront::Exception::InvalidIngestionPolicyId, id
end

#wf_integration_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront integration ID. These appear to be lower-case strings.

Parameters:

  • id (String) —

    the integration ID to validate

Returns:

  • (Boolean) —

    True if the integration name is valid

Raises:

  • Wavefront::Exception::InvalidIntegrationId if the integration ID is not valid



507
508
509
510
511
 
# File 'lib/wavefront-sdk/validators.rb', line 507

def wf_integration_id?(id)
  return true if id.is_a?(String) && id =~ /^[a-z0-9]+$/

  raise Wavefront::Exception::InvalidIntegrationId, id
end

#wf_link_id?(id) ⇒ Boolean

Ensure the given argument is a valid external Link ID

Parameters:

  • id (String) —

    the external link ID to validate

Returns:

  • (Boolean) —

    True if the link ID is valid

Raises:

  • Wavefront::Exception::InvalidExternalLinkId if the link ID is not valid



300
301
302
303
304
 
# File 'lib/wavefront-sdk/validators.rb', line 300

def wf_link_id?(id)
  return true if id.is_a?(String) && id =~ /^\w{16}$/

  raise Wavefront::Exception::InvalidExternalLinkId, id
end

#wf_link_template?(template) ⇒ Boolean

Ensure the given argument is a valid external link template

Returns:

  • (Boolean) —

    true if it is valid

Raises:

  • Wavefront::Exception::InvalidTemplate if not



32
33
34
35
36
37
38
39
 
# File 'lib/wavefront-sdk/validators.rb', line 32

def wf_link_template?(template)
  if template.is_a?(String) &&
     template.start_with?('http://', 'https://')
    return true
  end

  raise Wavefront::Exception::InvalidLinkTemplate, template
end

#wf_maintenance_window_id?(id) ⇒ Boolean

Ensure the given argument is a valid maintenance window ID. IDs are the millisecond epoch timestamp at which the window was created.

Parameters:

Returns:

  • (Boolean) —

    True if the ID is valid

Raises:

  • Wavefront::Exception::InvalidMaintenanceWindowId



314
315
316
317
318
319
 
# File 'lib/wavefront-sdk/validators.rb', line 314

def wf_maintenance_window_id?(id)
  id = id.to_s if id.is_a?(Numeric)
  return true if id.is_a?(String) && id =~ /^\d{13}$/

  raise Wavefront::Exception::InvalidMaintenanceWindowId, id
end

#wf_message_id?(id) ⇒ Boolean

Ensure the given argument is a valid message ID

Parameters:

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidMessageId if not valid



339
340
341
342
343
 
# File 'lib/wavefront-sdk/validators.rb', line 339

def wf_message_id?(id)
  return true if id.is_a?(String) && id =~ /^\w+::\w+$/

  raise Wavefront::Exception::InvalidMessageId, id
end

#wf_metric_name?(metric) ⇒ Boolean

Ensure the given argument is a valid Wavefront metric name, or path.

is not valid.

Parameters:

  • metric (String) —

    the metric name to validate

Returns:

  • (Boolean) —

    True if the metric name is valid

Raises:

  • Wavefront::Exception::InvalidMetricName if metric name



49
50
51
52
53
54
55
56
57
 
# File 'lib/wavefront-sdk/validators.rb', line 49

def wf_metric_name?(metric)
  if metric.is_a?(String) && metric.size < 1024 &&
     (metric.match(/^#{DELTA}?[\w\-.]+$/o) ||
      metric.match(%r{^"#{DELTA}?[\w\-./,]+"$}o))
    return true
  end

  raise Wavefront::Exception::InvalidMetricName, metric
end

#wf_metricspolicy_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront metrics policy ID

Parameters:

  • id (String) —

    the metrics policy ID to validate

Returns:

  • (Boolean) —

    true if the role ID is valid

Raises:

  • Wavefront::Exception::InvalidMetricsPolicyId if the ID is not valid



662
663
664
665
666
 
# File 'lib/wavefront-sdk/validators.rb', line 662

def wf_metricspolicy_id?(id)
  return true if uuid?(id)

  raise Wavefront::Exception::InvalidMetricsPolicyId, id
end

#wf_monitoredapplication_id?(id) ⇒ Boolean

Ensure the given argument is a valid monitored application ID

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidMonitoredApplicationId if the ID is not valid



616
617
618
619
620
 
# File 'lib/wavefront-sdk/validators.rb', line 616

def wf_monitoredapplication_id?(id)
  return true if id.is_a?(String) && id.size < 256 && id =~ /^[a-z0-9\-_]+$/

  raise Wavefront::Exception::InvalidMonitoredApplicationId, id
end

#wf_monitoredcluster_id?(id) ⇒ Boolean

Ensure the given argument is a valid monitored cluster ID

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidMonitoredClusterId if the ID is not valid



605
606
607
608
609
 
# File 'lib/wavefront-sdk/validators.rb', line 605

def wf_monitoredcluster_id?(id)
  return true if id.is_a?(String) && id.size < 256 && id =~ /^[a-z0-9\-_]+$/

  raise Wavefront::Exception::InvalidMonitoredClusterId, id
end

#wf_ms_ts?(timestamp) ⇒ Boolean

Ensure the given argument is a valid millisecond epoch timestamp. We do no checking of the value, because who am I to say that the user doesn’t want to send a point relating to 1ms after the epoch, or a thousand years in the future?

Parameters:

  • timestamp (Integer) —

    the timestamp name to validate

Returns:

  • (Boolean) —

    True if the value is valid

Raises:

  • Wavefront::Exception::InvalidTimestamp



112
113
114
115
116
 
# File 'lib/wavefront-sdk/validators.rb', line 112

def wf_ms_ts?(timestamp)
  return true if timestamp.is_a?(Numeric)

  raise Wavefront::Exception::InvalidTimestamp, timestamp
end

#wf_name?(name) ⇒ Boolean

Ensure the given argument is a valid name, for instance for an event. Names can contain, AFAIK, word characters.

raise Wavefront::Exception::InvalidName if name is not valid

Parameters:

  • name (String) —

    the name to validate

Returns:

  • (Boolean) —

    true if the name is valid

Raises:



66
67
68
69
70
 
# File 'lib/wavefront-sdk/validators.rb', line 66

def wf_name?(name)
  return true if name.is_a?(String) && name.size < 1024 && name =~ /^\w+$/

  raise Wavefront::Exception::InvalidName, name
end

#wf_notificant_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront notificant ID.

Parameters:

  • id (String) —

    the notificant ID to validate

Returns:

  • (Boolean) —

    True if the notificant ID is valid

Raises:

  • Wavefront::Exception::InvalidNotificantId if the notificant ID is not valid



493
494
495
496
497
 
# File 'lib/wavefront-sdk/validators.rb', line 493

def wf_notificant_id?(id)
  return true if id.is_a?(String) && id =~ /^\w{16}$/

  raise Wavefront::Exception::InvalidNotificantId, id
end

#wf_permission?(id) ⇒ Boolean

Ensure the given argument is a Wavefront permission

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidApiTokenId if the ID is not valid



562
563
564
565
566
567
568
569
570
571
572
 
# File 'lib/wavefront-sdk/validators.rb', line 562

def wf_permission?(id)
  if %w[alerts_management batch_query_priority embedded_charts
        dashboard_management derived_metrics_management ingestion
        events_management external_links_management
        application_management metrics_management agent_management
        host_tag_management user_management].include?(id)
    return true
  end

  raise Wavefront::Exception::InvalidPermission, id
end

#wf_point?(point) ⇒ Boolean

Validate a point so it conforms to the standard described in community.wavefront.com/docs/DOC-1031

Parameters:

  • point (Hash) —

    description of point

Returns:

  • (Boolean) —

    true if valid

Raises:

  • whichever exception is thrown first when validating each component of the point.



445
446
447
448
449
450
451
452
 
# File 'lib/wavefront-sdk/validators.rb', line 445

def wf_point?(point)
  wf_metric_name?(point[:path])
  wf_value?(point[:value])
  wf_epoch?(point[:ts]) if point[:ts]
  wf_source_id?(point[:source]) if point[:source]
  wf_point_tags?(point[:tags]) if point[:tags]
  true
end

#wf_point_tag?(key, val) ⇒ Boolean

Validate a single point tag, probably on behalf of #wf_point_tags?

Parameters:

Returns:

  • (Boolean) —

    nil

Raises:

  • Wavefront::Exception::InvalidTag if any tag is not valid



196
197
198
199
200
201
202
203
 
# File 'lib/wavefront-sdk/validators.rb', line 196

def wf_point_tag?(key, val)
  if key && val && (key.size + val.size < 254) &&
     key =~ /^[\w\-.:]+$/ && val !~ /\\$/
    return false
  end

  raise Wavefront::Exception::InvalidTag, "#{key}=#{val}"
end

#wf_point_tags?(tags) ⇒ Boolean

Ensure a hash of key:value point tags are value. Not to be confused with source tags.

Parameters:

  • tags (Hash) —

    a hash of key:value tags

Returns:

  • (Boolean) —

    True if all tags are valid

Raises:

  • Wavefront::Exception::InvalidTag if any tags in the has do not validate



184
185
186
187
188
 
# File 'lib/wavefront-sdk/validators.rb', line 184

def wf_point_tags?(tags)
  raise Wavefront::Exception::InvalidTag unless tags.is_a?(Hash)

  tags.each { |k, v| wf_point_tag?(k, v) }
end

#wf_proxy_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront proxy ID

Parameters:

  • id (String) —

    the proxy ID to validate

Returns:

  • (Boolean) —

    True if the proxy ID is valid

Raises:

  • Wavefront::Exception::InvalidProxyId if the proxy ID is not valid



212
213
214
215
216
 
# File 'lib/wavefront-sdk/validators.rb', line 212

def wf_proxy_id?(id)
  return true if uuid?(id)

  raise Wavefront::Exception::InvalidProxyId, id
end

#wf_role_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront role ID

Parameters:

  • id (String) —

    the role ID to validate

Returns:

  • (Boolean) —

    true if the role ID is valid

Raises:

  • Wavefront::Exception::InvalidRoleId if the role ID is not valid



637
638
639
640
641
 
# File 'lib/wavefront-sdk/validators.rb', line 637

def wf_role_id?(id)
  return true if uuid?(id)

  raise Wavefront::Exception::InvalidRoleId, id
end

#wf_sampling_value?(value) ⇒ Boolean

Ensure the given value is a valid sampling rate.

Parameters:

  • rate (Float)

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidSamplingValue



626
627
628
629
630
 
# File 'lib/wavefront-sdk/validators.rb', line 626

def wf_sampling_value?(value)
  return true if value.is_a?(Numeric) && value.between?(0, 0.05)

  raise Wavefront::Exception::InvalidSamplingValue, value
end

#wf_savedsearch_entity?(id) ⇒ Boolean

Ensure the given argument is a valid saved search entity type.

Parameters:

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidSavedSearchEntity if not valid



377
378
379
380
381
382
383
 
# File 'lib/wavefront-sdk/validators.rb', line 377

def wf_savedsearch_entity?(id)
  return true if %w[DASHBOARD ALERT MAINTENANCE_WINDOW
                    NOTIFICANT EVENT SOURCE EXTERNAL_LINK AGENT
                    CLOUD_INTEGRATION].include?(id)

  raise Wavefront::Exception::InvalidSavedSearchEntity, id
end

#wf_savedsearch_id?(id) ⇒ Boolean

Ensure the given argument is a valid saved search ID.

Parameters:

  • id (String) —

    saved search ID

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidSavedSearchId if not valid



364
365
366
367
368
 
# File 'lib/wavefront-sdk/validators.rb', line 364

def wf_savedsearch_id?(id)
  return true if id.is_a?(String) && id =~ /^\w{8}$/

  raise Wavefront::Exception::InvalidSavedSearchId, id
end

#wf_serviceaccount_id?(id) ⇒ Boolean

Ensure the given argument is a valid service account ID

Parameters:

Returns:

  • (Boolean)

Raises:

  • Wavefront::Exception::InvalidApiTokenId if the ID is not valid



551
552
553
554
555
 
# File 'lib/wavefront-sdk/validators.rb', line 551

def wf_serviceaccount_id?(id)
  return true if id.is_a?(String) && id.start_with?('sa::')

  raise Wavefront::Exception::InvalidServiceAccountId, id
end

#wf_source_id?(source) ⇒ Boolean

Ensure the given argument is a valid Wavefront source name

Parameters:

  • source (String) —

    the source name to validate

Returns:

  • (Boolean) —

    True if the source name is valid

Raises:

  • Wavefront::Exception::InvalidSourceId if the source name is not valid



392
393
394
395
396
397
398
399
 
# File 'lib/wavefront-sdk/validators.rb', line 392

def wf_source_id?(source)
  if source.is_a?(String) && source.match(/^[\w.-]+$/) &&
     source.size < 1024
    return true
  end

  raise Wavefront::Exception::InvalidSourceId, source
end

#wf_spansamplingpolicy_id?(id) ⇒ Boolean

Ensure the given argument is a valid Wavefront Span Sampling Policy ID. So far as I can tell they’re just strings.

Parameters:

  • id (String) —

    the span sampling policy ID to validate

Returns:

  • (Boolean) —

    true if the ID is valid

Raises:

  • Wavefront::Exception::InvalidSpanSamplingPolicyId if the ID is not valid



675
676
677
678
679
 
# File 'lib/wavefront-sdk/validators.rb', line 675

def wf_spansamplingpolicy_id?(id)
  return true if id.is_a?(String)

  raise Wavefront::Exception::InvalidSpanSamplingPolicyId, id
end

#wf_string?(str) ⇒ Boolean

Ensure the given argument is a valid string, for a tag name.

Parameters:

  • str (String) —

    the string name to validate

Returns:

  • (Boolean) —

    True if the string is valid

Raises:

  • Wavefront::Exception::InvalidString if string is not valid.



78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/wavefront-sdk/validators.rb', line 78

def wf_string?(str)
  #
  # Only allows PCRE "word" characters, spaces, full-stops and
  # commas in tags and descriptions. This might be too restrictive,
  # but if it is, this is the only place we need to change it.
  #
  if str.is_a?(String) && str.size < 1024 && str =~ /^[-\w .,]*$/
    return true
  end

  raise Wavefront::Exception::InvalidString, str
end

#wf_tag?(*tags) ⇒ Boolean

Ensure one, or an array, of tags are valid. These tags are used as source tags, or tags for maintenance windows etc. They can contain letters, numbers, -, _ and :, and must be less than 256 characters long

Parameters:

Returns:

  • (Boolean) —

    True if all tags are valid

Raises:

  • Wavefront::Exception::InvalidTag



140
141
142
143
144
145
146
147
148
 
# File 'lib/wavefront-sdk/validators.rb', line 140

def wf_tag?(*tags)
  Array(*tags).each do |tag|
    unless tag.is_a?(String) && tag.size < 255 && tag =~ /^[\w:\-.]+$/
      raise Wavefront::Exception::InvalidTag, tag
    end
  end

  true
end

#wf_trace?(trace) ⇒ Boolean

@

Returns:

  • (Boolean) 


470
 
# File 'lib/wavefront-sdk/validators.rb', line 470

def wf_trace?(trace); end

#wf_ts?(timestamp) ⇒ Boolean

Ensure the given argument is a valid timestamp

Parameters:

  • timestamp (DateTime) —

    the timestamp name to validate

Returns:

  • (Boolean) —

    True if the value is valid

Raises:

  • Wavefront::Exception::InvalidTimestamp



97
98
99
100
101
 
# File 'lib/wavefront-sdk/validators.rb', line 97

def wf_ts?(timestamp)
  return true if timestamp.is_a?(Time) || timestamp.is_a?(Date)

  raise Wavefront::Exception::InvalidTimestamp, timestamp
end

#wf_user_id?(user) ⇒ Boolean

Ensure the given argument is a valid user.

Parameters:

  • user (String) —

    user identifier

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidUserId if not valid



407
408
409
410
411
 
# File 'lib/wavefront-sdk/validators.rb', line 407

def wf_user_id?(user)
  return true if user.is_a?(String) && user.length < 256 && !user.empty?

  raise Wavefront::Exception::InvalidUserId, user
end

#wf_usergroup_id?(gid) ⇒ Boolean

Ensure the given argument is a valid user group.

Parameters:

  • gid (String) —

    user group identiier

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidUserGroupId if not valid



419
420
421
422
423
 
# File 'lib/wavefront-sdk/validators.rb', line 419

def wf_usergroup_id?(gid)
  return true if uuid?(gid)

  raise Wavefront::Exception::InvalidUserGroupId, gid
end

#wf_value?(value) ⇒ Boolean

Ensure the given argument is a valid Wavefront value. Can be any form of Numeric, including standard notation.

Parameters:

  • value (Numeric) —

    the source name to validate

Returns:

  • (Boolean) —

    True if the value is valid

Raises:

  • Wavefront::Exception::InvalidValue if the value is not valid



157
158
159
160
161
 
# File 'lib/wavefront-sdk/validators.rb', line 157

def wf_value?(value)
  return true if value.is_a?(Numeric)

  raise Wavefront::Exception::InvalidMetricValue, value
end

#wf_version?(version) ⇒ Boolean

Ensure the given argument is a valid version number

Parameters:

  • version (Integer) —

    the version number to validate

Returns:

  • (Boolean) —

    True if the version is valid

Raises:

  • Wavefront::Exception::InvalidVersion if the ID is not valid



169
170
171
172
173
174
 
# File 'lib/wavefront-sdk/validators.rb', line 169

def wf_version?(version)
  version = version.to_i if version.is_a?(String) && version =~ /^\d+$/
  return true if version.is_a?(Integer) && version.positive?

  raise Wavefront::Exception::InvalidVersion, version
end

#wf_webhook_id?(id) ⇒ Boolean

Ensure the given argument is a valid webhook ID.

Parameters:

Returns:

  • (Boolean) —

    true if valid

Raises:

  • Wavefront::Exceptions::InvalidWebhook if not valid



431
432
433
434
435
 
# File 'lib/wavefront-sdk/validators.rb', line 431

def wf_webhook_id?(id)
  return true if id.is_a?(String) && id =~ /^[a-zA-Z0-9]{16}$/

  raise Wavefront::Exception::InvalidWebhookId, id
end