1 # <a id="language-reference"></a> Language Reference
3 ## <a id="object-definition"></a> Object Definition
5 Icinga 2 features an object-based configuration format. You can define new
6 objects using the `object` keyword:
8 object Host "host1.example.org" {
11 address = "192.168.0.1"
15 In general you need to write each statement on a new line. Expressions started
16 with `{`, `(` and `[` extend until the matching closing character and can be broken
17 up into multiple lines.
19 Alternatively you can write multiple statements on a single line by separating
20 them with a semicolon:
22 object Host "host1.example.org" {
23 display_name = "host1"
25 address = "192.168.0.1"; address6 = "::1"
28 Each object is uniquely identified by its type (`Host`) and name
29 (`host1.example.org`). Some types have composite names, e.g. the
30 `Service` type which uses the `host_name` attribute and the name
31 you specified to generate its object name.
33 Exclamation marks (!) are not permitted in object names.
35 Objects can contain a comma-separated list of property
36 declarations. Instead of commas semicolons may also be used.
37 The following data types are available for property values:
39 All objects have at least the following attributes:
41 Attribute | Description
42 ---------------------|-----------------------------
43 name | The name of the object. This attribute can be modified in the object definition to override the name specified with the `object` directive.
44 type | The type of the object.
46 ## <a id="expressions"></a> Expressions
48 The following expressions can be used on the right-hand side of assignments.
50 ### <a id="numeric-literals"></a> Numeric Literals
52 A floating-point number.
58 ### <a id="duration-literals"></a> Duration Literals
60 Similar to floating-point numbers except for the fact that they support
61 suffixes to help with specifying time durations.
67 Supported suffixes include ms (milliseconds), s (seconds), m (minutes),
68 h (hours) and d (days).
70 Duration literals are converted to seconds by the config parser and
71 are treated like numeric literals.
73 ### <a id="string-literals"></a> String Literals
81 Certain characters need to be escaped. The following escape sequences
84 Character | Escape sequence
85 --------------------------|------------------------------------
89 <CARRIAGE-RETURN> | \\r
90 <LINE-FEED> | \\n
92 <FORM-FEED> | \\f
94 In addition to these pre-defined escape sequences you can specify
95 arbitrary ASCII characters using the backslash character (\\) followed
96 by an ASCII character in octal encoding.
98 ### <a id="multiline-string-literals"></a> Multi-line String Literals
100 Strings spanning multiple lines can be specified by enclosing them in
110 Unlike in ordinary strings special characters do not have to be escaped
111 in multi-line string literals.
113 ### <a id="boolean-literals"></a> Boolean Literals
115 The keywords `true` and `false` are used to denote truth values.
117 ### <a id="null-value"></a> Null Value
119 The `null` keyword can be used to specify an empty value.
121 ### <a id="dictionary"></a> Dictionary
123 An unordered list of key-value pairs. Keys must be unique and are
124 compared in a case-sensitive manner.
126 Individual key-value pairs must either be comma-separated or on separate lines.
127 The comma after the last key-value pair is optional.
132 address = "192.168.0.1"
136 Identifiers may not contain certain characters (e.g. space) or start
137 with certain characters (e.g. digits). If you want to use a dictionary
138 key that is not a valid identifier, you can enclose the key in double
141 ### <a id="array"></a> Array
143 An ordered list of values.
145 Individual array elements must be comma-separated.
146 The comma after the last element is optional.
152 An array may simultaneously contain values of different types, such as
155 ### <a id="expression-operators"></a> Operators
157 The following operators are supported in expressions. The operators are by descending precedence.
159 Operator | Precedence | Examples (Result) | Description
160 ---------|------------|-----------------------------------------------|--------------------------------
161 () | 1 | (3 + 3) * 5 | Groups sub-expressions
162 () | 1 | Math.random() | Calls a function
163 [] | 1 | a[3] | Array subscript
164 . | 1 | a.b | Element access
165 ! | 2 | !"Hello" (false), !false (true) | Logical negation of the operand
166 ~ | 2 | ~true (false) | Bitwise negation of the operand
167 + | 2 | +3 | Unary plus
168 - | 2 | -3 | Unary minus
169 * | 3 | 5m * 10 (3000) | Multiplies two numbers
170 / | 3 | 5m / 5 (60) | Divides two numbers
171 % | 3 | 17 % 12 (5) | Remainder after division
172 + | 4 | 1 + 3 (4), "hello " + "world" ("hello world") | Adds two numbers; concatenates strings
173 - | 4 | 3 - 1 (2) | Subtracts two numbers
174 << | 5 | 4 << 8 (1024) | Left shift
175 >> | 5 | 1024 >> 4 (64) | Right shift
176 < | 6 | 3 < 5 (true) | Less than
177 > | 6 | 3 > 5 (false) | Greater than
178 <= | 6 | 3 <= 3 (true) | Less than or equal
179 >= | 6 | 3 >= 3 (true) | Greater than or equal
180 in | 7 | "foo" in [ "foo", "bar" ] (true) | Element contained in array
181 !in | 7 | "foo" !in [ "bar", "baz" ] (true) | Element not contained in array
182 == | 8 | "hello" == "hello" (true), 3 == 5 (false) | Equal to
183 != | 8 | "hello" != "world" (true), 3 != 3 (false) | Not equal to
184 & | 9 | 7 & 3 (3) | Binary AND
185 ^ | 10 | 17 ^ 12 (29) | Bitwise XOR
186 | | 11 | 2 | 3 (3) | Binary OR
187 && | 13 | true && false (false), 3 && 7 (7), 0 && 7 (0) | Logical AND
188 || | 14 | true || false (true), 0 || 7 (7)| Logical OR
189 = | 12 | a = 3 | Assignment
190 => | 15 | x => x * x (function with arg x) | Lambda, for loop
192 ### <a id="function-calls"></a> Function Calls
194 Functions can be called using the `()` operator:
196 const MyGroups = [ "test1", "test" ]
199 check_interval = len(MyGroups) * 1m
202 A list of available functions is available in the [Library Reference](18-library-reference.md#library-reference) chapter.
204 ## <a id="dictionary-operators"></a> Assignments
206 In addition to the `=` operator shown above a number of other operators
207 to manipulate attributes are supported. Here's a list of all
210 ### <a id="operator-assignment"></a> Operator =
212 Sets an attribute to the specified value.
221 In this example `a` has the value `7` after both instructions are executed.
223 ### <a id="operator-additive-assignment"></a> Operator +=
225 The += operator is a shortcut. The following expression:
239 ### <a id="operator-substractive-assignment"></a> Operator -=
241 The -= operator is a shortcut. The following expression:
255 ### <a id="operator-multiply-assignment"></a> Operator \*=
257 The *= operator is a shortcut. The following expression:
271 ### <a id="operator-dividing-assignment"></a> Operator /=
273 The /= operator is a shortcut. The following expression:
287 ## <a id="indexer"></a> Indexer
289 The indexer syntax provides a convenient way to set dictionary elements.
297 Example (alternative syntax):
300 hello["key"] = "world"
303 This is equivalent to writing:
311 If the `hello` attribute does not already have a value, it is automatically initialized to an empty dictionary.
313 ## <a id="template-imports"></a> Template Imports
315 Objects can import attributes from other objects.
319 template Host "default-host" {
323 template Host "test-host" {
324 import "default-host"
329 object Host "localhost" {
332 address = "127.0.0.1"
336 The `default-host` and `test-host` objects are marked as templates
337 using the `template` keyword. Unlike ordinary objects templates are not
338 instantiated at run-time. Parent objects do not necessarily have to be
339 templates, however in general they are.
341 The `vars` dictionary for the `localhost` object contains all three
342 custom attributes and the custom attribute `colour` has the value `"blue"`.
344 Parent objects are resolved in the order they're specified using the
347 Default templates which are automatically imported into all object definitions
348 can be specified using the `default` keyword:
350 template CheckCommand "plugin-check-command" default {
354 Default templates are imported before any other user-specified statement in an
355 object definition is evaluated.
357 If there are multiple default templates the order in which they are imported
360 ## <a id="constants"></a> Constants
362 Global constants can be set using the `const` keyword:
364 const VarName = "some value"
366 Once defined a constant can be accessed from any file. Constants cannot be changed
369 Icinga 2 provides a number of special global constants. Some of them can be overridden using the `--define` command line parameter:
371 Variable |Description
372 --------------------|-------------------
373 PrefixDir |**Read-only.** Contains the installation prefix that was specified with cmake -DCMAKE_INSTALL_PREFIX. Defaults to "/usr/local".
374 SysconfDir |**Read-only.** Contains the path of the sysconf directory. Defaults to PrefixDir + "/etc".
375 ZonesDir |**Read-only.** Contains the path of the zones.d directory. Defaults to SysconfDir + "/zones.d".
376 LocalStateDir |**Read-only.** Contains the path of the local state directory. Defaults to PrefixDir + "/var".
377 RunDir |**Read-only.** Contains the path of the run directory. Defaults to LocalStateDir + "/run".
378 PkgDataDir |**Read-only.** Contains the path of the package data directory. Defaults to PrefixDir + "/share/icinga2".
379 StatePath |**Read-write.** Contains the path of the Icinga 2 state file. Defaults to LocalStateDir + "/lib/icinga2/icinga2.state".
380 ObjectsPath |**Read-write.** Contains the path of the Icinga 2 objects file. Defaults to LocalStateDir + "/cache/icinga2/icinga2.debug".
381 PidPath |**Read-write.** Contains the path of the Icinga 2 PID file. Defaults to RunDir + "/icinga2/icinga2.pid".
382 Vars |**Read-write.** Contains a dictionary with global custom attributes. Not set by default.
383 NodeName |**Read-write.** Contains the cluster node name. Set to the local hostname by default.
384 UseVfork |**Read-write.** Whether to use vfork(). Only available on *NIX. Defaults to true.
385 EventEngine |**Read-write.** The name of the socket event engine, can be "poll" or "epoll". The epoll interface is only supported on Linux.
386 AttachDebugger |**Read-write.** Whether to attach a debugger when Icinga 2 crashes. Defaults to false.
387 RunAsUser |**Read-write.** Defines the user the Icinga 2 daemon is running as. Used in the `init.conf` configuration file.
388 RunAsGroup |**Read-write.** Defines the group the Icinga 2 daemon is running as. Used in the `init.conf` configuration file.
389 PlatformName |**Read-only.** The name of the operating system, e.g. "Ubuntu".
390 PlatformVersion |**Read-only.** The version of the operating system, e.g. "14.04.3 LTS".
391 PlatformKernel |**Read-only.** The name of the operating system kernel, e.g. "Linux".
392 PlatformKernelVersion|**Read-only.** The version of the operating system kernel, e.g. "3.13.0-63-generic".
393 BuildCompilerName |**Read-only.** The name of the compiler Icinga was built with, e.g. "Clang".
394 BuildCompilerVersion|**Read-only.** The version of the compiler Icinga was built with, e.g. "7.3.0.7030031".
395 BuildHostName |**Read-only.** The name of the host Icinga was built on, e.g. "acheron".
397 ## <a id="apply"></a> Apply
399 The `apply` keyword can be used to create new objects which are associated with
400 another group of objects.
402 apply Service "ping" to Host {
403 import "generic-service"
405 check_command = "ping4"
407 assign where host.name == "localhost"
410 In this example the `assign where` condition is a boolean expression which is
411 evaluated for all objects of type `Host` and a new service with name "ping"
412 is created for each matching host. [Expression operators](17-language-reference.md#expression-operators)
413 may be used in `assign where` conditions.
415 The `to` keyword and the target type may be omitted if there is only one target
416 type, e.g. for the `Service` type.
418 Depending on the object type used in the `apply` expression additional local
419 variables may be available for use in the `where` condition:
421 Source Type | Target Type | Variables
422 ------------------|-------------|--------------
423 Service | Host | host
424 Dependency | Host | host
425 Dependency | Service | host, service
426 Notification | Host | host
427 Notification | Service | host, service
428 ScheduledDowntime | Host | host
429 ScheduledDowntime | Service | host, service
431 Any valid config attribute can be accessed using the `host` and `service`
432 variables. For example, `host.address` would return the value of the host's
433 "address" attribute -- or null if that attribute isn't set.
435 More usage examples are documented in the [monitoring basics](3-monitoring-basics.md#using-apply-expressions)
438 ## <a id="apply-for"></a> Apply For
440 [Apply](17-language-reference.md#apply) rules can be extended with the
441 [for loop](17-language-reference.md#for-loops) keyword.
443 apply Service "prefix-" for (key => value in host.vars.dictionary) to Host {
444 import "generic-service"
446 check_command = "ping4"
447 vars.host_value = value
451 Any valid config attribute can be accessed using the `host` and `service`
452 variables. The attribute must be of the Array or Dictionary type. In this example
453 `host.vars.dictionary` is of the Dictionary type which needs a key-value-pair
456 In this example all generated service object names consist of `prefix-` and
457 the value of the `key` iterator. The prefix string can be omitted if not required.
459 The `key` and `value` variables can be used for object attribute assignment, e.g. for
460 setting the `check_command` attribute or custom attributes as command parameters.
462 `apply for` rules are first evaluated against all objects matching the `for loop` list
463 and afterwards the `assign where` and `ignore where` conditions are evaluated.
465 It is not necessary to check attributes referenced in the `for loop` expression
466 for their existance using an additional `assign where` condition.
468 More usage examples are documented in the [monitoring basics](3-monitoring-basics.md#using-apply-for)
471 ## <a id="group-assign"></a> Group Assign
473 Group objects can be assigned to specific member objects using the `assign where`
474 and `ignore where` conditions.
476 object HostGroup "linux-servers" {
477 display_name = "Linux Servers"
479 assign where host.vars.os == "Linux"
482 In this example the `assign where` condition is a boolean expression which is evaluated
483 for all objects of the type `Host`. Each matching host is added as member to the host group
484 with the name "linux-servers". Membership exclusion can be controlled using the `ignore where`
485 condition. [Expression operators](17-language-reference.md#expression-operators) may be used in `assign where` and
486 `ignore where` conditions.
488 Source Type | Variables
489 ------------------|--------------
491 ServiceGroup | host, service
495 ## <a id="boolean-values"></a> Boolean Values
497 The `assign where`, `ignore where`, `if` and `while` statements, the `!` operator as
498 well as the `bool()` function convert their arguments to a boolean value based on the
501 Description | Example Value | Boolean Value
502 ---------------------|-------------------|--------------
503 Empty value | null | false
505 Non-zero integer | -23945 | true
506 Empty string | "" | false
507 Non-empty string | "Hello" | true
508 Empty array | [] | false
509 Non-empty array | [ "Hello" ] | true
510 Empty dictionary | {} | false
511 Non-empty dictionary | { key = "value" } | true
513 For a list of supported expression operators for `assign where` and `ignore where`
514 statements, see [expression operators](17-language-reference.md#expression-operators).
516 ## <a id="comments"></a> Comments
518 The Icinga 2 configuration format supports C/C++-style and shell-style comments.
525 object Host "localhost" {
526 check_interval = 30 // this is also a comment.
527 retry_interval = 15 # yet another comment
530 ## <a id="includes"></a> Includes
532 Other configuration files can be included using the `include` directive.
533 Paths must be relative to the configuration file that contains the
538 include "some/other/file.conf"
539 include "conf.d/*.conf"
541 Wildcard includes are not recursive.
543 Icinga also supports include search paths similar to how they work in a
548 Note the use of angle brackets instead of double quotes. This causes the
549 config compiler to search the include search paths for the specified
550 file. By default $PREFIX/share/icinga2/include is included in the list of search
551 paths. Additional include search paths can be added using
552 [command-line options](11-cli-commands.md#config-include-path).
554 Wildcards are not permitted when using angle brackets.
556 ## <a id="recursive-includes"></a> Recursive Includes
558 The `include_recursive` directive can be used to recursively include all
559 files in a directory which match a certain pattern.
563 include_recursive "conf.d", "*.conf"
564 include_recursive "templates"
566 The first parameter specifies the directory from which files should be
567 recursively included.
569 The file names need to match the pattern given in the second parameter.
570 When no pattern is specified the default pattern "*.conf" is used.
572 ## <a id="zone-includes"></a> Zone Includes
574 The `include_zones` recursively includes all subdirectories for the
577 In addition to that it sets the `zone` attribute for all objects created
578 in these subdirectories to the name of the subdirectory.
582 include_zones "etc", "zones.d", "*.conf"
583 include_zones "puppet", "puppet-zones"
585 The first parameter specifies a tag name for this directive. Each `include_zones`
586 invocation should use a unique tag name. When copying the zones' configuration
587 files Icinga uses the tag name as the name for the destination directory in
588 `/var/lib/icinga2/api/config`.
590 The second parameter specifies the directory which contains the subdirectories.
592 The file names need to match the pattern given in the third parameter.
593 When no pattern is specified the default pattern "*.conf" is used.
595 ## <a id="library"></a> Library directive
597 The `library` directive can be used to manually load additional
598 libraries. Libraries can be used to provide additional object types and
605 ## <a id="functions"></a> Functions
607 Functions can be defined using the `function` keyword.
611 function multiply(a, b) {
615 When encountering the `return` keyword further execution of the function is terminated and
616 the specified value is supplied to the caller of the function:
620 In this example the `multiply` function we declared earlier is invoked with two arguments (3 and 5).
621 The function computes the product of those arguments and makes the result available to the
624 When no value is supplied for the `return` statement the function returns `null`.
626 Functions which do not have a `return` statement have their return value set to the value of the
627 last expression which was performed by the function. For example, we could have also written our
628 `multiply` function like this:
630 function multiply(a, b) {
634 Anonymous functions can be created by omitting the name in the function definition. The
635 resulting function object can be used like any other value:
637 var fn = function() { 3 }
641 ## <a id="lambdas"></a> Lambda Expressions
643 Functions can also be declared using the alternative lambda syntax.
649 Multiple statements can be used by putting the function body into braces:
656 Just like with ordinary functions the return value is the value of the last statement.
658 For lambdas which take exactly one argument the braces around the arguments can be omitted:
662 ## <a id="nullary-lambdas"></a> Abbreviated Lambda Syntax
664 Lambdas which take no arguments can also be written using the abbreviated lambda syntax.
670 This creates a new function which returns the value 3.
672 ## <a id="variable-scopes"></a> Variable Scopes
674 When setting a variable Icinga checks the following scopes in this order whether the variable
675 already exists there:
681 The local scope contains variables which only exist during the invocation of the current function,
682 object or apply statement. Local variables can be declared using the `var` keyword:
684 function multiply(a, b) {
689 Each time the `multiply` function is invoked a new `temp` variable is used which is in no way
690 related to previous invocations of the function.
692 When setting a variable which has not previously been declared as local using the `var` keyword
693 the `this` scope is used.
695 The `this` scope refers to the current object which the function or object/apply statement
698 object Host "localhost" {
702 In this example the `this` scope refers to the "localhost" object. The `check_interval` attribute
703 is set for this particular host.
705 You can explicitly access the `this` scope using the `this` keyword:
707 object Host "localhost" {
708 var check_interval = 5m
710 /* This explicitly specifies that the attribute should be set
711 * for the host, if we had omitted `this.` the (poorly named)
712 * local variable `check_interval` would have been modified instead.
714 this.check_interval = 1m
717 Similarly the keywords `locals` and `globals` are available to access the local and global scope.
719 Functions also have a `this` scope. However unlike for object/apply statements the `this` scope for
720 a function is set to whichever object was used to invoke the function. Here's an example:
725 function init(word) {
730 /* Let's invoke the init() function */
733 We're using `hm.init` to invoke the function which causes the value of `hm` to become the `this`
734 scope for this function call.
736 ## <a id="closures"></a> Closures
738 By default `function`s, `object`s and `apply` rules do not have access to variables declared
739 outside of their scope (except for global variables).
741 In order to access variables which are defined in the outer scope the `use` keyword can be used:
743 function MakeHelloFunction(name) {
744 return function() use(name) {
745 log("Hello, " + name)
749 In this case a new variable `name` is created inside the inner function's scope which has the
750 value of the `name` function argument.
752 Alternatively a different value for the inner variable can be specified:
754 function MakeHelloFunction(name) {
755 return function() use (greeting = "Hello, " + name) {
760 ## <a id="conditional-statements"></a> Conditional Statements
762 Sometimes it can be desirable to only evaluate statements when certain conditions are met. The if/else
763 construct can be used to accomplish this.
777 An if/else construct can also be used in place of any other value. The value of an if/else statement
778 is the value of the last statement which was evaluated for the branch which was taken:
781 log("Taking the 'true' branch")
784 log("Taking the 'false' branch")
788 This example prints the log message "Taking the 'true' branch" and the `a` variable is set to 21 (7 * 3).
790 The value of an if/else construct is null if the condition evaluates to false and no else branch is given.
792 ## <a id="while-loops"></a> While Loops
794 The `while` statement checks a condition and executes the loop body when the condition evaluates to `true`.
795 This is repeated until the condition is no longer true.
806 The `continue` and `break` keywords can be used to control how the loop is executed: The `continue` keyword
807 skips over the remaining expressions for the loop body and begins the next loop evaluation. The `break` keyword
808 breaks out of the loop.
810 ## <a id="for-loops"></a> For Loops
812 The `for` statement can be used to iterate over arrays and dictionaries.
816 var list = [ "a", "b", "c" ]
822 The loop body is evaluated once for each item in the array. The variable `item` is declared as a local
823 variable just as if the `var` keyword had been used.
825 Iterating over dictionaries can be accomplished in a similar manner:
827 var dict = { a = 3, b = 7 }
829 for (key => value in dict) {
830 log("Key: " + key + ", Value: " + value)
833 The `continue` and `break` keywords can be used to control how the loop is executed: The `continue` keyword
834 skips over the remaining expressions for the loop body and begins the next loop evaluation. The `break` keyword
835 breaks out of the loop.
837 ## <a id="constructor"></a> Constructors
839 In order to create a new value of a specific type constructor calls may be used.
843 var pd = PerfdataValue()
847 You can also try to convert an existing value to another type by specifying it as an argument for the constructor call.
851 var s = String(3) /* Sets s to "3". */
853 ## <a id="throw"></a> Exceptions
855 Built-in commands may throw exceptions to signal errors such as invalid arguments. User scripts can throw exceptions
856 using the `throw` keyword.
860 throw "An error occurred."
862 There is currently no way for scripts to catch exceptions.
864 ## <a id="breakpoints"></a> Breakpoints
866 The `debugger` keyword can be used to insert a breakpoint. It may be used at any place where an assignment would also be a valid expression.
868 By default breakpoints have no effect unless Icinga is started with the `--script-debugger` command-line option. When the script debugger is enabled Icinga stops execution of the script when it encounters a breakpoint and spawns a console which lets the user inspect the current state of the execution environment.
870 ## <a id="types"></a> Types
872 All values have a static type. The `typeof` function can be used to determine the type of a value:
874 typeof(3) /* Returns an object which represents the type for numbers */
876 The following built-in types are available:
878 Type | Examples | Description
879 -----------|-------------------|------------------------
880 Number | 3.7 | A numerical value.
881 Boolean | true, false | A boolean value.
882 String | "hello" | A string.
883 Array | [ "a", "b" ] | An array.
884 Dictionary | { a = 3 } | A dictionary.
886 Depending on which libraries are loaded additional types may become available. The `icinga`
887 library implements a whole bunch of other [object types](9-object-types.md#object-types),
888 e.g. Host, Service, CheckCommand, etc.
890 Each type has an associated type object which describes the type's semantics. These
891 type objects are made available using global variables which match the type's name:
893 /* This logs 'true' */
894 log(typeof(3) == Number)
896 The type object's `prototype` property can be used to find out which methods a certain type
899 /* This returns: ["contains","find","len","lower","replace","reverse","split","substr","to_string","trim","upper"] */
900 keys(String.prototype)
902 Additional documentation on type methods is available in the
903 [library reference](18-library-reference.md#library-reference).
905 ## <a id="location-information"></a> Location Information
907 The location of the currently executing script can be obtained using the
908 `current_filename` and `current_line` keywords.
912 log("Hello from '" + current_filename + "' in line " + current_line)
914 ## <a id="reserved-keywords"></a> Reserved Keywords
916 These keywords are reserved and must not be used as constants or custom attributes.
946 You can escape reserved keywords using the `@` character. The following example
947 tries to set `vars.include` which references a reserved keyword and generates
950 [2014-09-15 17:24:00 +0200] critical/config: Location:
951 /etc/icinga2/conf.d/hosts/localhost.conf(13): vars.sla = "24x7"
952 /etc/icinga2/conf.d/hosts/localhost.conf(14):
953 /etc/icinga2/conf.d/hosts/localhost.conf(15): vars.include = "some cmdb export field"
955 /etc/icinga2/conf.d/hosts/localhost.conf(16): }
956 /etc/icinga2/conf.d/hosts/localhost.conf(17):
958 Config error: in /etc/icinga2/conf.d/hosts/localhost.conf: 15:8-15:14: syntax error, unexpected include (T_INCLUDE), expecting T_IDENTIFIER
959 [2014-09-15 17:24:00 +0200] critical/config: 1 errors, 0 warnings.
961 You can escape the `include` keyword by prefixing it with an additional `@` character:
963 object Host "localhost" {
964 import "generic-host"
966 address = "127.0.0.1"
972 vars.@include = "some cmdb export field"