Check this thread and external table project.

can't figure out how to check if the child process (in $zchild) is still running.  

Append 2 commands to your main command.

First one, execute before your main command to create a file with a name equal to process id.

Second one, execute after your main command. It deletes the file.

In your IRIS process check if the file exists.

Ugly but it works.

1. If it's a one-off thing redefine your property setter:

Class Test.RO Extends %Persistent
{

Property RecordCreatedTime As %TimeStamp [ InitialExpression = {$ZDATETIME($ZTIMESTAMP, 3, 1, 3)} ];

Method RecordCreatedTimeSet(value As %TimeStamp) As %Status
{
	if i%RecordCreatedTime="" {
		set i%RecordCreatedTime=value
	}
	quit $$$OK
}

/// do ##class(Test.RO).test()
ClassMethod test()
{
	set obj = ..%New()
	write obj.RecordCreatedTime,!
	
	set obj.RecordCreatedTime = "2000-01-01 00:00:01"
	write obj.RecordCreatedTime,!
}
}

It's also automatically set during object creation courtesy of InitialExpression, you can remove it if you want to set the value yourself.

2. If you have the same immutable property or a set of immutable properties you can write an abstract class:

Class Test.Base [Abstract]
{

Property RecordCreatedTime As %TimeStamp [ InitialExpression = {$ZDATETIME($ZTIMESTAMP, 3, 1, 3)} ];

Method RecordCreatedTimeSet(value As %TimeStamp) As %Status
{
	if i%RecordCreatedTime="" {
		set i%RecordCreatedTime=value
	}
	quit $$$OK
}
}

And add it to inheritance whenever you need:

Class Test.RO Extends (%Persistent, Test.Base)
{
}

3. Finally if you have a lot of immutable properties and they are all different you'll need a custom datatype. Custom datatype defines method generators for getters, setters and all other property methods. Let's inherit from %String so we only need to redefine a setter:

Class Test.ROString Extends %String
{

/// Generate Setter
Method Set(%val) [ CodeMode = objectgenerator, NoContext ]
{
	quit:%mode'="propertymethod" $$$OK
	do %code.WriteLine($c(9) _ "if i%" _ $g(%member) _ "="""" {")
	do %code.WriteLine($c(9,9) _ "set i%" _ $g(%member) _ "=%val")
	do %code.WriteLine($c(9) _ "}")
	do %code.WriteLine($c(9) _ "quit $$$OK")
	quit $$$OK
}

}

Now we create a property of Test.ROString type:

Class Test.RO Extends %Persistent
{
Property RecordCreatedTime As Test.ROString [ InitialExpression = {$ZDATETIME($ZTIMESTAMP, 3, 1, 3)} ];
}

And it would be immutable. In fact if we check a generated setter:

zRecordCreatedTimeSet(%val) public {
    if i%RecordCreatedTime="" {
        set i%RecordCreatedTime=%val
    }
    quit 1 }

It would look quite similar to what I have wrote in (1), only automatically generated.

You can't call native api methods which write to device as is.

If you need to call some piece of code which writes to device use this wrapper:

/// Executes and returns device output 
/// pObj - OREF or class
/// pMethod - instance or class method to execute respectively
/// pArgs - additional arguments
ClassMethod OutputToStr(pObj, pMethod, pArgs...) As %String [ ProcedureBlock = 0 ]
{
	set tOldIORedirected = ##class(%Device).ReDirectIO()
	set tOldMnemonic = ##class(%Device).GetMnemonicRoutine()
	set tOldIO = $io
	try {
		set str=""

		//Redirect IO to the current routine - makes use of the labels defined below
		use $io::("^"_$ZNAME)

		//Enable redirection
		do ##class(%Device).ReDirectIO(1)

		if $isobject(pObj) {
			do $Method(pObj,pMethod,pArgs...)
		} elseif $$$comClassDefined(pObj) {
			do $ClassMethod(pObj,pMethod,pArgs...)
		}
	} catch ex {
		set str = ""
	}

	//Return to original redirection/mnemonic routine settings
	if (tOldMnemonic '= "") {
		use tOldIO::("^"_tOldMnemonic)
	} else {
		use tOldIO
	}
	do ##class(%Device).ReDirectIO(tOldIORedirected)

	quit str

	//Labels that allow for IO redirection
	//Read Character - we don't care about reading
rchr(c)      quit
	//Read a string - we don't care about reading
rstr(sz,to)  quit
	//Write a character - call the output label
wchr(s)      do output($char(s))  quit
	//Write a form feed - call the output label
wff()        do output($char(12))  quit
	//Write a newline - call the output label
wnl()        do output($char(13,10))  quit
	//Write a string - call the output label
wstr(s)      do output(s)  quit
	//Write a tab - call the output label
wtab(s)      do output($char(9))  quit
	//Output label - this is where you would handle what you actually want to do.
	//  in our case, we want to write to str
output(s)    set str=str_s   quit
}

So in your case it would be something like:

IRISObject data  = (IRISObject) iris.classMethodObject(CACHE_CLASS_NAME, method, _args);
String string = iris.classMethodString("SomeClass", "OutputToStr", data, "ToJSON")
data.close();

If you check Ens.Util.Log class where logs are stored, you'll notice that Text property is limited to 32 000 characters, so logging anything larger than that is impossible.

There are several approaches you can take:

• Logging to files as described by @Jeffrey Drumm. I'd add that you can use %File:TempFilename to obtain a random but valid filename to write to. Alternatively use session id and timestamp to create the filename, with each session having a separate folder.
• Logging to streams. Use %Stream.GblChrCompress to save on space. JSON is very compressible.
• Use a debugging business operation. Create a business operation which accepts everything and either defers or just does nothing. Send a copy of your stream there. This way you get immediate access to a content from the Visual Trace.