Add metadata via config strings (LLNL#595)

* Function to add metadata via ConfigManager

* Add test for ConfigManager metadata import

* Add short documentation for ConfigManager metadata

Author: daboehme

doc/sphinx/CaliperBasics.rst

@@ -613,6 +613,25 @@ Adiak (Adiak support must be enabled in the Caliper build configuration). The
 spot config for the Spot web visualization framework requires that metadata
 attributes are recorded through Adiak.
 
+Finally, metadata can be added through the ``CALI_CONFIG`` and ConfigManager
+configuration strings with the ``metadata`` keyword:
+
+.. code-block:: sh
+
+    $ CALI_CONFIG="runtime-report,print.metadata,metadata(foo=fooval,bar=barval)" ./examples/apps/cxx-example
+    caliper.config        :
+    iterations            : 4
+    cali.caliper.version  : 2.12.0-dev
+    opts:print.metadata   : true
+    opts:output.append    : true
+    opts:order_as_visited : true
+    foo                   : fooval
+    bar                   : barval
+    cali.channel          : runtime-report
+    Path       Time (E) Time (I) Time % (E) Time % (I)
+    main       0.000014 0.000547   2.118374  85.205938
+    ...
+
 Third-party tool support (NVidia NSight, Intel VTune)
 -----------------------------------------------------
 

src/caliper/ChannelController.cpp

@@ -39,12 +39,9 @@ namespace
 void add_channel_metadata(Caliper& c, Channel* channel, const info_map_t& metadata)
 {
     for (const auto &entry : metadata) {
-        std::string key = channel->name();
-        key.append(":");
-        key.append(entry.first);
-
         auto attr =
-            c.create_attribute(key, CALI_TYPE_STRING, CALI_ATTR_GLOBAL | CALI_ATTR_SKIP_EVENTS);
+            c.create_attribute(entry.first, CALI_TYPE_STRING,
+                CALI_ATTR_GLOBAL | CALI_ATTR_SKIP_EVENTS | CALI_ATTR_UNALIGNED);
 
         c.set(channel, attr, Variant(entry.second.c_str()));
     }

src/caliper/ConfigManager.cpp

@@ -91,7 +91,7 @@ merge_new_elements(ConfigManager::arglist_t& to, const ConfigManager::arglist_t&
                     return p.first == v.first;
                 });
 
-        if (it == to.end())
+        if (it == to.end() || p.first == "metadata") // hacky but we want to allow multiple entries for metadata
             to.push_back(p);
     }
 
@@ -180,6 +180,152 @@ expand_variables(const std::string& in, const std::string& val)
     return ret;
 }
 
+ConfigManager::arglist_t
+parse_keyval_list(std::istream& is)
+{
+    ConfigManager::arglist_t ret;
+    char c = 0;
+
+    do {
+        std::string key = util::read_word(is, "=");
+        if (key.empty())
+            return ret;
+
+        c = util::read_char(is);
+        if (c != '=')
+            return ret;
+
+        std::string val = util::read_word(is, ",()");
+        if (!val.empty())
+            ret.push_back(std::make_pair(key, val));
+
+        c = util::read_char(is);
+    } while (is.good() && c == ',');
+
+    if (is.good())
+        is.unget();
+
+    return ret;
+}
+
+std::pair<bool, StringConverter>
+find_key_in_json(const std::vector<std::string>& path, const std::map<std::string, StringConverter>& dict)
+{
+    if (path.empty())
+        return std::make_pair(false, StringConverter());
+
+    auto it = dict.find(path.front());
+    if (it == dict.end())
+        return std::make_pair(false, StringConverter());
+
+    if (path.size() == 1)
+        return std::make_pair(true, it->second);
+
+    StringConverter ret = it->second;
+    for (auto path_it = path.begin()+1; path_it != path.end(); ++path_it) {
+        auto sub_dict = ret.rec_dict();
+        it = sub_dict.find(*path_it);
+        if (it == sub_dict.end())
+            return std::make_pair(false, StringConverter());
+        ret = it->second;
+    }
+
+    return std::make_pair(true, ret);
+}
+
+unsigned
+add_metadata_entries(const std::string& key, const StringConverter& val, info_map_t& info)
+{
+    unsigned num_entries = 0;
+
+    bool is_dict = false;
+    auto dict = val.rec_dict(&is_dict);
+
+    if (is_dict) {
+        std::string prefix = key + ".";
+        for (const auto& p : dict) {
+            info[prefix + p.first] = p.second.to_string();
+            ++num_entries;
+        }
+    } else {
+        info[key] = val.to_string();
+        ++num_entries;
+    }
+
+    return num_entries;
+}
+
+void
+read_metadata_from_json_file(const std::string& filename, const std::string& keys, info_map_t& info)
+{
+    std::ifstream is(filename.c_str(), std::ios::ate);
+
+    if (!is) {
+        Log(0).stream() << "read_metadata_from_json_file(): Cannot open file "
+            << filename << ", quitting\n";
+        return;
+    }
+
+    auto size = is.tellg();
+    std::string str(size, '\0');
+    is.seekg(0);
+    if (!is.read(&str[0], size)) {
+        Log(0).stream() << "read_metadata_from_json_file(): Cannot read file "
+            << filename << ", quitting\n";
+        return;
+    }
+
+    bool ok = false;
+    auto top = StringConverter(str).rec_dict(&ok);
+
+    if (!ok) {
+        Log(0).stream() << "read_metadata_from_json_file(): Cannot parse top-level dict in "
+            << filename << ", quitting\n";
+        return;
+    }
+
+    auto keylist = StringConverter(keys).to_stringlist();
+    if (keylist.empty()) {
+        for (const auto& p : top)
+            keylist.push_back(p.first);
+    }
+
+    for (const std::string& key : keylist) {
+        std::vector<std::string> path = StringConverter(key).to_stringlist(".");
+        auto ret = find_key_in_json(path, top);
+        if (ret.first)
+            add_metadata_entries(key, ret.second, info);
+        else
+            Log(1).stream() << "read_metadata_from_json_file(): Key "
+                << key << " not found\n";
+    }
+}
+
+void
+add_metadata(const std::string& args, info_map_t& info)
+{
+    std::istringstream is(args);
+    auto arglist = parse_keyval_list(is);
+
+    auto it = std::find_if(arglist.begin(), arglist.end(), [](const std::pair<std::string,std::string>& p){
+            return p.first == "file";
+        });
+
+    if (it != arglist.end()) {
+        std::string filename = it->second;
+        std::string keys;
+        it = std::find_if(arglist.begin(), arglist.end(), [](const std::pair<std::string,std::string>& p){
+                return p.first == "keys";
+            });
+        if (it != arglist.end())
+            keys = it->second;
+        read_metadata_from_json_file(filename, keys, info);
+    } else {
+        for (const auto& p : arglist)
+            info[p.first] = p.second;
+    }
+}
+
 } // namespace [anonymous]
 
 
@@ -540,8 +686,15 @@ struct ConfigManager::Options::OptionsImpl
 
     void
     update_channel_metadata(info_map_t& info) {
-        for (const auto &p : args)
-            info[p.first] = p.second;
+        for (const auto &p : args) {
+            if (p.first == "metadata") {
+                ::add_metadata(p.second, info);
+            } else {
+                std::string key = "opts:";
+                key.append(p.first);
+                info[key] = p.second;
+            }
+        }
     }
 
     std::string
@@ -614,19 +767,16 @@ struct ConfigManager::Options::OptionsImpl
 
         for (const auto &argp : args) {
             auto s_it = spec.data.find(argp.first);
-
             if (s_it == spec.data.end())
                 continue;
 
             //   Non-boolean options are enabled if they are present in args.
             // For boolean options, check if they are set to false or true.
             bool enabled = true;
-
             if (s_it->second.type == "bool")
                 enabled = StringConverter(argp.second).to_bool();
             if (enabled) {
                 vec.push_back(argp.first);
-
                 auto tmp = get_inherited_specs(argp.first);
                 vec.insert(vec.end(), tmp.begin(), tmp.end());
             }
@@ -745,8 +895,8 @@ struct ConfigManager::ConfigManagerImpl
     std::map< std::string, arglist_t >
         m_default_parameters_for_spec;
 
-    arglist_t    m_default_parameters;
-    argmap_t     m_extra_vars;
+    arglist_t   m_default_parameters;
+    argmap_t    m_extra_vars;
 
     OptionSpec  m_global_opts;
 
@@ -893,7 +1043,7 @@ struct ConfigManager::ConfigManagerImpl
             add_config_spec(s.spec, s.create, s.check_args, true /* ignore existing */ );
     }
 
-    //   Parse "=value"
+    //   Parse "=value" or "(value)"
     // Returns an empty string if there is no '=', otherwise the string after '='.
     // Sets error if there is a '=' but no word afterwards.
     std::string
@@ -906,8 +1056,12 @@ struct ConfigManager::ConfigManagerImpl
 
             if (val.empty())
                 set_error("Expected value after \"" + key + "=\"", is);
-        }
-        else
+        } else if (c == '(') {
+            val = util::read_nested_text(is, '(', ')');
+            c = util::read_char(is);
+            if (c != ')')
+                set_error("Missing ')' after \"" + key + "\"(", is);
+        } else
             is.unget();
 
         return val;
@@ -931,7 +1085,7 @@ struct ConfigManager::ConfigManagerImpl
             std::string key = util::read_word(is, ",=()\n");
 
             if (!key.empty()) {
-                if (!(opts.contains(key))) {
+                if (!(opts.contains(key)) && key != "metadata") {
                     set_error("Unknown option: " + key);
                     args.clear();
                     return args;
@@ -1121,7 +1275,9 @@ struct ConfigManager::ConfigManagerImpl
                     if (m_error)
                         return ret;
 
-                    if (is_option(key)) {
+                    if (key == "metadata") {
+                        m_default_parameters.push_back(std::make_pair(key, val));
+                    } else if (is_option(key)) {
                         if (val.empty())
                             val = "true";
 

test/ci_app_tests/test_basictrace.py

@@ -151,6 +151,22 @@ def test_globals_selection(self):
         self.assertTrue(cat.has_snapshot_with_keys(
             snapshots, { 'cali.caliper.version' } ) )
 
+    def test_configmanager_metadata_import(self):
+        target_cmd = [ './ci_test_macros', '0', 'hatchet-region-profile(metadata(bla=garbl),output.format=json-split),metadata(file=example_node_info.json,keys=\"host.os,host.name\"),output=stdout' ]
+
+        caliper_config = {
+            'CALI_LOG_VERBOSITY' : '0'
+        }
+
+        obj = json.loads( cat.run_test(target_cmd, caliper_config)[0] )
+
+        self.assertEqual(obj['host.os.name'], 'TestOS')
+        self.assertEqual(obj['host.os.version'], '3.11')
+        self.assertEqual(obj['host.name'], 'test42')
+        self.assertEqual(obj['bla'], 'garbl')
+        self.assertFalse('other' in obj.keys())
+        self.assertFalse('host.cluster' in obj.keys())
+
     def test_lcnodeinfo(self):
         target_cmd = [ './ci_test_basic' ]
         query_cmd = [ '../../src/tools/cali-query/cali-query', '-G', '-e' ]

test/ci_app_tests/test_spot.py

@@ -56,7 +56,7 @@ def test_spot_regionprofile(self):
         self.assertEqual(r['spot.channel'], 'regionprofile')
 
         self.assertEqual('regionprofile', obj['globals']['spot.channels'])
-        self.assertEqual('true', obj['globals']['spot:region.count'])
+        self.assertEqual('true', obj['globals']['opts:region.count'])
 
     def test_spot_timeseries(self):
         target_cmd = [ './ci_test_macros', '0', 'spot(output=stdout,timeseries,timeseries.iteration_interval=15)', '75' ]