_avg_mean`. The naming is a bit weird, `avg_mean` means average through the episode, averaged between episodes, and `avg_min` is average through the episode and minimum between episodes (same as the `episode_reward_{mean,max,min}` semantics). You can change this to whatever fits your needs in `CustomCallbacks.on_episode_end`. Also, this adds the non-aggregated data to the histograms, not just the aggregated data to the scalars.
And one more thing, I’m using this with Tune, I’m not sure how the callbacks are handled if you’re running plain RLlib, but I think it should work regardless.
I hope that helps, let me know if something is not clear.
---
### Author:  [@Lars\_Simon\_Zehnder](https://discuss.ray.io/u/Lars_Simon_Zehnder)
#### Post date: [January 12, 2022, 8:19pm UTC](https://discuss.ray.io/t/log-or-record-custom-env-data-via-rllib/4674/3 "2022-01-12T20:19:32Z")
@klausk55 ,
depending on what data you want to store (pickled objects might not work with the following) you can use RLlib’s build-in Offline-API. The only thing you have to do for logging the data to JSON files is to define
```auto
"output": "path/to/the/folder/of/output/files"
```
in your Trainer `config`.
RLlib then uses the `JsonWriter` object to write out observations, actions, rewards, etc. for each timestep.
If you need to store more than the standard output you can use the `info` object returned by the environment’s `step()` function. Simply store your additional data in a dictionary and returned it in your step function and the Offline-API will record it in the JSON output file:
```auto
def step(self, action):
...
info_dict = {
"data_1": myObject1,
"data_2": myObject2,
}
return obs, reward, done, info_dict
```
---
### Author:  [@klausk55](https://discuss.ray.io/u/klausk55)
#### Post date: [January 13, 2022, 9:33am UTC](https://discuss.ray.io/t/log-or-record-custom-env-data-via-rllib/4674/4 "2022-01-13T09:33:13Z")
Thanks @Lars_Simon_Zehnder also for your idea! I guess this is a simple and very fast way to store some data from the env. Provided that we are talking about the same, I have this already in use and it generates all these _output-…json_ files in my log\_dir. In my case, they contain the data of MultiAgentBatches with the size of rollout\_fragment\_length.
To me, @vakker00’s suggestion is not as straightforward as yours, but it should allow for more flexiblity and customization (e.g. tracking and logging something throughout an episode).
---
### Author:  [@klausk55](https://discuss.ray.io/u/klausk55)
#### Post date: [January 14, 2022, 10:07am UTC](https://discuss.ray.io/t/log-or-record-custom-env-data-via-rllib/4674/6 "2022-01-14T10:07:15Z")
Maybe also helpful and interesting for others:
> [@On another topic](https://discuss.ray.io/t/4689/3):
>
> Hello Vince,
>
> I agree that Tune brings a lots of convenience with it, but debugging seems to be difficult with Tune, at least to me. Maybe I just don’t know how to debug right with Tune?! 😅
>
> Yesterday I’ve opened this new [topic](https://discuss.ray.io/t/are-custom-loggercallbacks-only-intended-for-use-with-ray-tune-or-also-for-use-with-plain-rllib/4690) here, but in the meantime I’m quite sure that with plain RLlib you can’t use this Tune `LoggerCallback` functionality.
> You’re right that I can access `episode_media` in the result dict returned from `train()`. What I now do is that I had defined a custom logger by sub-classing `tune.logger.py::Logger`, see the RLlib [example](https://github.com/ray-project/ray/blob/c0f12022785f4b7b8ca1deb1ba2720c8652b99d8/rllib/examples/custom_logger.py) on github.
> Here are some code snippets how I do this, first I define a custom logger class
>
> ```auto
> from typing import Dict
>
> import json
>
> import os
>
> from ray.tune.utils.util import SafeFallbackEncoder
> from ray.tune.logger import Logger
>
> EXPR_TRACK_FILE = "episode_tracking.json"
>
> class CustomLogger(Logger):
> """Logs custom results in json format."""
>
> def _init(self):
> self.update_config(self.config)
> logger_config = self.config.get("logger_config")
> filename = EXPR_TRACK_FILE
> if logger_config:
> filename = logger_config.get("filename") or filename
> local_file = os.path.join(self.logdir, filename)
> self.local_out = open(local_file, "a")
>
> def on_result(self, result: Dict):
> tracking_data = result["episode_media"]
> if not tracking_data:
> return
> json.dump(tracking_data, self, cls=SafeFallbackEncoder)
> self.write("\n")
> self.local_out.flush()
>
> def write(self, b):
> self.local_out.write(b)
>
> def flush(self):
> if not self.local_out.closed:
> self.local_out.flush()
>
> def close(self):
> self.local_out.close()
>
> def update_config(self, config: Dict):
> self.config = config
>
> ```
>
> Then I need a logger creator function for the Trainer where I define the loggers I want
>
> ```auto
> def custom_logger_creator(config):
> """Creates a Unified logger with a default logdir prefix
> containing the agent name and the env id
> """
> timestr = datetime.today().strftime("%Y-%m-%d_%H-%M-%S")
> logdir_prefix = "{}_{}_{}".format("PPO", "HSP", timestr)
> if not os.path.exists(CUSTOM_RESULTS_DIR):
> os.makedirs(CUSTOM_RESULTS_DIR)
> logdir = tempfile.mkdtemp(
> prefix=logdir_prefix, dir=CUSTOM_RESULTS_DIR)
> loggers = list(DEFAULT_LOGGERS)
> loggers.append(CustomLogger)
> return UnifiedLogger(config, logdir, loggers=loggers)
>
> ```
>
> And finally give this logger creator to my Trainer
>
> ```auto
> trainer = PPOTrainer(
> env="EPPSimulator",
> logger_creator=custom_logger_creator,
> config=custom_config)
>
> ```
>
> Inside the `train()` call there is the line `self.log_result(result)` where all included loggers are applied to the result dict.
>
> Your help and examples were amazing, thanks a lot for one more time!