LiveKit Community

```Using multi-node routing via redis addr
10.x.0.7:6379

redis:
    address: 10.x.x.1:6379
```
I see 2 different redis IPs here.

I fixed the IP and tried configuring the Redis server with protected-mode is no, but the result was the same.

looks like it's able to connect to Redis, but for some reasons couldn't find the Room? we haven't seen this issue before. how might one reproduce this issue?

Sorry, my wrong, I used sid instead of the name room.
Thanks

Ahh, yeah. The region wasn't being registered on the router. I put a fix in here and added it to a PR that I already had to improve the region routing: <https://github.com/bekriebel/livekit-server/commit/8d2a90260d59d17d4764bebc825c12f43bc989c8>

All good. I found one other issue that I'll be committing a fix for in a sec.

Okay, that fix is pushed now and available in this PR: <https://github.com/livekit/livekit-server/pull/141>. I ran it through some tests and it seems to be working well! Thanks for adding this.

thanks for catching and fixing this bug so quickly!

One minor thing, in pkg/service/server.go, I had already added the Region to the log, so now it's in there twice. Lines 160 and 176.

image.png

i'm investigating livekit-recorder  and  confusing with one recorder per service solution?

Does because gstreamer main loop so we can't have multi recorder for multi room in same process ?

i 'm building a recorder for my framework with gstreamer too. At merging stage, i'm using compositor pipeline but don't know when it finished .Can you help me ?

i'm create *pipeline by `gst_parse_launch`

you’ll need to listen for an EOS event (<https://github.com/livekit/livekit-recorder/blob/main/pkg/pipeline/pipeline_prod.go#L93>) to know when it’s finished

i'm using gstreamer to record h264 to filesink, but when stream quality is down, i got issue all frames be ignore and can't write to file
```qtmux gstqtmux.c:5118:gst_qt_mux_can_renegotiate:&lt;mp4mux1&gt;[00m pad video_0 refused renegotiation to video/x-h264, codec_data=(buffer)0164001effe100216764001eacd941e051bff002c002d6a0a020a80000030008000003019478b16cb001000568ebecb22c, stream-format=(string)avc, alignment=(string)au, level=(string)3, profile=(string)high, width=(int)480, height=(int)640, pixel-aspect-ratio=(fraction)44/45, framerate=(fraction)25/1, interlace-mode=(string)progressive, colorimetry=(string)2:4:5:3, chroma-site=(string)mpeg2, multiview-mode=(string)mono, multiview-flags=(GstVideoMultiviewFlagsSet)0:ffffffff:/right-view-first/left-flipped/left-flopped/right-flipped/right-flopped/half-aspect/mixed-mono```


i think because webrtc auto  change h264 profile base on bandwidth so  break gst mp4mux

I’m not sure how to help with that, our recorder records video from `ximagesrc` instead of directly from webrtc (see <https://github.com/livekit/livekit-recorder/blob/main/pkg/pipeline/input.go>)

I’ll fix that now, here’s the working link:
<https://docs.livekit.io/guides/access-tokens>

Thanks.  Wondering if the server-sdk’s AccessToken constructor should enforce only creating valid tokens.  I just tracked down a bug where the token had a room: { name: ‘string’ }   instead of room: ‘string’. but the error I got was that the livekit-server couldn’t unmarshall the JSON

Nevermind, I see now that you export a type, so I should have been using this with typescript instead and would have clued me in immediately.

Hi Incredible, where are you stuck? What have you tried? What's not working?

1. Generated api keys with generate-keys command
2. Created Access Token with a unique player id
3. Ran the server locally
After this i'm trying to connect with <ws://localhost:7880> from the android demo. But i'm finding a way to actually test if its really working.

<@U02GWB761DK> do you have any error when you are trying to connect?

how did you started docker? ports opened?\

should be docker run --rm -p 7880:7880 -p 7881:7881 -p 7882:7882/udp ...

Oh. Let me check. I just followed the documentation

```docker run --rm   -p 7880:7880   -p 7881:7881   -p 7882:7882/udp   -e LIVEKIT_KEYS="APIPLe3AJA5LApN: T2sUxyVvZkOqDnIqKKjOsxsGxfbPHEQrK54G4jUXoxW"   livekit/livekit-server   --dev   --node-ip=localhost```

Thanks for the inputs. I dropped running from docker and now running from source directly locally. It seems to atleast connect now.

However, from device its getting disconnected on connect. Need to figure out the issue.

is this android emulator? if running from device, ensure that your connection url is set to the right IP, instead of localhost

Thanks <@U01KZ61GV5Z> I set the IP address only. I'm testing on real device.
Once I run on example on device, clicking on connect and video icon does nothing. Logs say its connected to room and followed by disconnected status. Whats its supposed to do?

check the server log. Are you getting an 401 error?

I'm trying to connect on two different devices with same access token. Is it allowed?

Ahh ok don't do that, generate a token for each participant

Oh ok. On one of my colleague's reported it worked fine on her system. But It didn't work on mine with same token.

Anyways, will use a different token.

do you mean HIPAA compliance? I think that depends on how you use it. LiveKit itself is open source software; we do not collect or store any user data. Someone using livekit can most definitely use it in a way that HIPAA compliant

Thanks david.
Bro does livekit support p2p now?

You need to read abit more how SFU server works

Thanks <@U02GTF5KZ6H> I will look into it. So the one i'm referring is P2P and not supported by LiveKit?

<@U02GWB761DK> for p2p better use something like <https://github.com/feross/simple-peer> and <http://socket.io|socket.io> as signaling server

Is it ideal to use P2P and if it fails can I fallback to LiveKit?

LiveKit needed when you need to implement group calls

without SFU server like it, it will be unefficient and overload clients devices, etc.

<https://bloggeek.me/how-many-users-webrtc-call/>

Got it! I'm planning it to use in a game where a connection has max of 2-3 members alone. So is using P2P makes sense?

<@U02GWB761DK> 3 members, means each member will send 3Mbit/s and receive 6Mibt/s from other 2 participants, if we are talking about HD quality, so I think you should be fine.

Great, thanks for sharing! That a lot of info :slightly_smiling_face:
I will try P2P and if i can find a way to see if it fails (need to figure out) then fallback to livekit(SFU)

6Mbit/out and 6Mbit in, something like that

The video in the games will be shown at around 20% of the screen so low res is fine. Going by the numbers it sounds ok to use P2P in my case. Just need to figure out how to find when P2P fails.

add turn server and you should be fine with connectivity

So, to summarise you mean
P2P (max of 2-4 participants) + Fallback with Turn
OR
LiveKit (&gt; 3-4 participants)

I understand. The above assumption sounds fine at a higher level?

But then I tested in Production and it stopped working not only there – but also in Staging:

(I know the test says I'm running 0.13.2 but that's because version.go hasn't been updated to 0.13.3 yet.)

I have not made any changes to the Redis (or any other) configuration.

I've just manually tested reconnecting by physically dis- and then reconnecting a device connected to a room and it looks like there were no issues at all – all signals are back as expected.

oh no.. this is definitely odd.. we'll investigate in the morning

Thank you very much, and let me know if I can somehow help debugging

I just re-ran the test and now resuming the connection worked in Production (3 times in a row so far) but didn't in Staging.

I had tested this a few times against 0.13.4 and it seem to work fine

lmk if you are still getting weird behavior on the resume test..

<@U028SSAKLQ1> there was an issue with the tester itself, it should be working now on any of the server builds

great news, <@U01UB0LHTTQ> – thanks a lot! are you planning on publishing the test source? I‘d love to learn more about how you are testing TURN and re-connecting as I‘m currently working on an end user test suite.

I don’t think we plan on publishing the source (it’s part of our website repo), but I can give you our TURN and reconnection logic.

for turn, we just set iceTransportPolicy to `relay` and see if it can connect:
```this.room = await connect(this.url, this.token, {
    rtcConfig: {
        iceTransportPolicy: 'relay',
    }
});```
and for reconnection, we just do
```    let reconnectingTriggered = false;
    let reconnected = false;
    
    room
      .on(RoomEvent.Reconnecting, () =&gt; {
        reconnectingTriggered = true;
      })
      .on(RoomEvent.Reconnected, () =&gt; {
        reconnected = true;
      });

    room.engine.client.close();
    const onClose = room.engine.client.onClose;
    if (onClose) {
      onClose('');
    } ```
and check if reconnection was triggered and successful

Ha, that's a lot easier than I thought. I did not know about `iceTransportPolicy: 'relay'` – thanks a lot!

Take a look at deployment docs to see if this helps: <https://docs.livekit.io/deploy/vm>

This should work fo any environment that supports cloud-init

you're trying to run the livekit server over SSL?

wondering if it's something common that we should note in the docs

I think it was JSON, I actually just overwrote middlewares for the webhook path

I see the issue, we are expecting the raw json string while it's already decoded for us.

great, thanks for sharing.. I think we can make this a bit simpler to work with.

<@U02J9L45EQK> check out our pre-built helm charts for this. <https://docs.livekit.io/deploy/kubernetes|docs here>

You would want a domain because SSL would not work otherwise. And to use our client SDKs, SSL is required.

can we use the Google-managed SSL certificates?

for the main connection yeah.. not for TURN tho

IIRC, Google doesn't have a network LB that can terminate TLS, so we'd have to terminate ourselves

check out the docker docs for how to mount files from the host OS to your docker container: <https://docs.docker.com/storage/bind-mounts/>

Ohh, maybe this is me having no idea how docker actually works.

yeah, though you'd have to use the server APIs to get that data.

OR generate a token with `hidden: true` so the user doesn't appear in the room to others

Ok that’s what I thought :slightly_smiling_face: So I’ll make a serverless function that makes that call. If I use `hidden: true` can I change it on the fly or should I request another token?

you'd have to request a new token for now. it's not possible to update visibility on the fly today

This is just appearing in logs sometimes (when some of users connecting), I running it from docker image

I assume the user is still connecting ok? I think this might be when TURN is allocated but not used

<@U01KZ61GV5Z> well if I knew which identity causing that error, I would probably ask him if his connection is ok, ill monitor

I'll file a bug for this to track. it might be related to this issue in pion/turn: <https://github.com/pion/turn/issues/206>

<@U01KZ61GV5Z> yes, I also have this in logs

turn ERROR: 2021/10/20 18:55:24 error when handling datagram: failed to handle Allocate-request from 212.225.225.45:21336: relay already allocated for 5-TUPLE

ok, the ticket mentions FF on Android. we'll see if we can reproduce

This is what that guys said also, not sure if that helps or even related.

I think word repeated related to microphone somehow.

Probably freezes and cropped image related to that error.

They were doing 4 participants call and I dont know which participant exactly fired that error.

"Testing on PC and Mobile.

*Yes, I observed that there are times when a participant's voice is repeated for a few seconds ... word, word, word and it returns to normal.*

*We have had some camera and camera freezes with cropped image, which have been resolved with a page refresh.*

*But in general the quality of the calls is great"*

Google Cloud Run does not work with UDP services, so that won't work with livekit

see <https://docs.livekit.io/deploy/vm> for deploying to a virtual machine

Hi David,
Thanks for the reply. Does AWS Fargate work with livekit?

Screenshot 2021-10-24 at 21.30.15.png

Screenshot 2021-10-24 at 21.26.37.png

it's possible for this effect to run before connection has succeeded.. you'd want a nil check there.

also, it's possible for the room to be disconnected first.. when that happens `useRoom` will return undefined for `room`

The Go SDK works with this.. though it's possible to use the client-sdk in a Node.js environment (a community member is doing so here: <https://github.com/jibon57/livekit-recorder-example>)

Another way is to send the same updates to your web server as well as publishing it as data.. though I guess it's possible for them to become out of sync (due to network failures)

Have you looked at Room &amp; Participant metadata? They'd let you attach arbitrary state onto the objects and keep them synchronized.

how about implementing it as a micro service as Grant mentioned, maybe using webhooks to get a notification when a room has been started, so you can trigger a worker to join the room and capture the datachannels in realtime

I plan to use webrtc data channels in a similar fashion, to send electrocardiogram curves for real time remote visualization and storage, I already made a POC on ion-sfu and works fine, and slowly migrating it to livekit

<@U02EN4Y8DCM> Did you get Yjs to work with livekit?

I’m trying to do the same for <https://colllab.so/|colllab.so>

I'm afraid not, we decided a centralized CRDT as a service like LiveBlocks was better for our product.

However if you don't need server-side data, it's mostly simple using the data channel. The only problem I found was that LiveBlocks only supports a single channel, so if you're passing more messages than YJS ones you have to figure out how  to sort each message to the right place on the client.

see this thread: <https://livekit-users.slack.com/archives/C01KVTJH6BX/p1643747740953139?thread_ts=1643385222.104579&amp;cid=C01KVTJH6BX>

I should also note I’m using Node, I saw the Go server SDK supports webrtc. Perhaps I should look into that as a Go microservice

Screenshot 2021-10-26 at 07.02.12.png

Hi <@U01KZ61GV5Z> please can I get help with this , I noticed whenever I tried building the docker image file  it failed with some errors as well.

Hey <@U0296US2YJX>, do your errors when buliding the docker image look like this?
```#20 2.075 W: GPG error: <http://archive.ubuntu.com/ubuntu> hirsute-backports InRelease: At least one invalid signature was encountered.
#20 2.075 E: The repository '<http://archive.ubuntu.com/ubuntu> hirsute-backports InRelease' is not signed.
------
executor failed running [/bin/sh -c apt-get update &amp;&amp;     apt-get install -y curl unzip wget gnupg xvfb pulseaudio gstreamer1.0-pulseaudio]: exit code: 100```

I was running into this last week, and reinstalling docker fixed it for me

Yes, those were the errors I was getting.

Okay I’ll try reinstalling docker and let you know how it goes thanks <@U01UB0LHTTQ>

Screenshot 2021-10-26 at 20.32.43.png

<@U01UB0LHTTQ> I reinstalled docker and I didn’t get any error from that, but when I tried connecting to a room via the terminal I get the error below

that error is safe to ignore, we aren’t using vaapi/the wayland plugin

Screenshot 2021-10-26 at 20.46.58.png

<@U01UB0LHTTQ> Okay, but I think it’s affecting  the recorder from changing it’s state to “Playing”

As seen in the image below

I just published some updates to the recorder, can you try upgrading to v0.3.3?

if that still doesn’t work, if you share your config/request I can try to reproduce

Okay, thank you,  let me do that right away

Screenshot 2021-10-26 at 21.09.31.png

<@U01UB0LHTTQ> I just upgraded to v0.3.3 , and the previous error went away now and I’m getting the error below

Ps: I’m using the recorder’s service mode and accessing the livekit server via a golang server

you’ll need to update livekit-cli and/or server-sdk-go as well, there was a breaking protocol change. Note that the recorder config now uses
```file_output:
    local: true/false (will default to true if you don't supply s3 config)
    s3: (required if using s3 output)
        access_key: s3 access key
        secret: s3 access secret
        region: s3 region
        bucket: s3 bucket```
and the requests now use
```"filepath": "path/filename.mp4"```
instead of the old `s3_path` and `file` fields

Screenshot 2021-10-26 at 21.16.50.png

Okay I’ll make the updates now, but just to clarify is the golang code below still on track? <@U01UB0LHTTQ>

ah, I’ll need to update the docs.
```StartRecordingRequest_File{
    File: ...```
will need to change to
```StartRecordingRequest_Filepath{
    Filepath: ...```
once you update the sdk

Screenshot 2021-10-26 at 22.08.16.png

<@U01UB0LHTTQ> I’ve update my server-go-sdk and i’m not getting the previous errors,

Although calling the startRecord function in my go server returns a 400 error

This is my config file below

Screenshot 2021-10-26 at 22.13.29.png

Screenshot 2021-10-26 at 22.22.40.png

can you double check that your recorder is running version 0.3.3? It can’t decode the request, but your request looks correct

ah nevermind, it looks like livekit-server needs to be updated to unmarshal the twirp request

I just pushed the update, try pulling the latest livekit-server

Can I pull the latest livekit server image from docker?

just pushed 0.13.6, it should push to docker soon

Screenshot 2021-10-26 at 23.47.58.png

I updated my livekit server and got the same error as before

Here’s my config to replicate error

Recorder config.yaml

# main TCP port for RoomService and RTC endpoint
# for production setups, this port should be placed behind a load balancer with TLS
api_key: APIbF9mHSKNpGW8
api_secret: Up9ZLritRB6OkuWeFrzCpHG9ZHmSzG304IRLlZ6UsdH
ws_url: <http://localhost:7880>

# log level, valid values: debug, info, warning, error
log_level: info

# when redis is set, LiveKit will automatically operate in a fully distributed fashion
# clients could connect to any node and be routed to the same room
redis:
 address: 192.168.65.2:6379
file_output:
  local: true







To run recorder

docker run --name my-recorder --rm --network host \
  -e SERVICE_MODE=1 \
  -e LIVEKIT_RECORDER_CONFIG=“$(cat config.yaml)” \
  livekit/livekit-recorder

Livekit Server config.yaml

# main TCP port for RoomService and RTC endpoint
# for production setups, this port should be placed behind a load balancer with TLS
port: 7880

# log level, valid values: debug, info, warning, error
log_level: info

# when redis is set, LiveKit will automatically operate in a fully distributed fashion
# clients could connect to any node and be routed to the same room
redis:
 address: 192.168.65.2:6379
 # db: 0
 # username: myuser
 # password: mypassword






To run server

docker run --rm \
 -p 7880:7880 \
 -p 7881:7881 \
 -p 7882:7882/udp \
 -e LIVEKIT_KEYS=“APIbF9mHSKNpGW8: Up9ZLritRB6OkuWeFrzCpHG9ZHmSzG304IRLlZ6UsdH” \-e LIVEKIT_CONFIG=“$(cat config.yaml)” \
 livekit/livekit-server \
 --dev \
 --node-ip=192.168.100.8

My function to start recorder

func StartRecord(c *fiber.Ctx) error {
    recordingClient := lksdk.NewRecordingServiceClient(“<http://localhost:7880>”, os.Getenv(“LIVEKIT_API_KEY”), os.Getenv(“LIVEKIT_API_SECRET”))

    req := &amp;livekit.StartRecordingRequest{
        Input: &amp;livekit.StartRecordingRequest_Template{
            Template: &amp;livekit.RecordingTemplate{
                Layout: “speaker-dark”,
                Room: &amp;livekit.RecordingTemplate_Token{
                    Token: “eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2MzUyOTE5NzksImlzcyI6IkFQSWJGOW1IU0tOcEdXOCIsImp0aSI6IlJlY29yZGVyIiwibmJmIjoxNjM1Mjg4Mzc5LCJzdWIiOiJSZWNvcmRlciIsInZpZGVvIjp7ImNhblN1YnNjcmliZSI6dHJ1ZSwiaGlkZGVuIjp0cnVlLCJyb29tIjoiR2FtZU9mVGhyb25lcyIsInJvb21Kb2luIjp0cnVlfX0.9AsWNOnQ5VaWMvr0AWMzq2aiajGgLuW5uXPk4mn_P-0”,
                },
            },
        },
        Output: &amp;livekit.StartRecordingRequest_Filepath{
            Filepath: “/output/test.mp4",
        },

    }

    resp, err := recordingClient.StartRecording(context.Background(), req)

    fmt.Println(err)
    if err != nil {
        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
            “success”:  false,
            “message”: err,
        })
    }

    fmt.Println(resp)
    recordingID := resp.RecordingId
        return c.Status(fiber.StatusOK).JSON(fiber.Map{
            “success”: true,
            “message”: recordingID,
        })

}

I’m not having any luck reproducing this error message

can you change `"info"` to `"debug"` in your recorder config.yaml, and send the full log output?

Also, try using `livekit/livekit-recorder:v0.3.3` in your docker run command to make sure it's using the correct version

<@U01UB0LHTTQ> I’m running this on a mac os

I’ll try these updates and let you know how it goes

Screenshot 2021-10-27 at 06.39.44.png

<@U01UB0LHTTQ> following the steps you suggested above I got the recorder to work but it crashed with this message below

`can't record fast enough` is usually a sign of not enough CPUs available - it needs about 2.5 on average, check your docker resource settings and make sure your limits are set to at least 3 CPUs and 1G memory

Screenshot 2021-10-27 at 07.15.10.png

<@U01UB0LHTTQ> I upgraded the cpu and memory in docker resource and I’m not getting the above error anymore. But I can’t find the recorded .mp4 file when using the file path below

it’s writing the file inside the docker container, you can either `docker cp &lt;container_name&gt;:/micra.mp4 .` , or you can change `Filepath: "/micra.mp4"` to `Filepath: "/out/micra.mp4"` and add `-v ~/livekit-recordings:/out` to your docker run command. this will write the file to `~/livekit-recordings/micra.mp4`

Screenshot 2021-10-27 at 07.42.24.png

<@U01UB0LHTTQ> I’m getting the video file now but there’s nothing inside, it’s showing size zero bytes

what do the logs look like? could mean the docker container was killed before the filesink received the EOS

Screenshot 2021-10-27 at 08.33.44.png

<@U01UB0LHTTQ> when I called the startRecord function this was the log response I got

Okay I restarted the livekit-recorder and It’s working fine now. Files and content are in the right place.
Thank you so much <@U01UB0LHTTQ>

Screenshot 2021-10-27 at 09.20.29.png

<@U01UB0LHTTQ> to store the file on aws s3 bucket is the code below valid?

with config.yaml as

`api_key: API34coZJbDNDQt`
`api_secret: 8fstva2xLXeCSTgffTYNfJ1W6GJRcQD51TcGarODnbZA`
`ws_url: <http://localhost:7880>`

`log_level: debug`
`redis:`
 `address: 192.168.65.2:6379`
`file_output:`
  `s3:`
    `access_key: XXXXXXXXXXX`
    `secret: XXXXXXXXXX`
    `region: us-east-2`
    `bucket: &lt;bucket_name&gt;`

Screenshot 2021-10-27 at 10.11.59.png

No worries the docs helped. Currently Uploading to s3 bucket successfully. Thank you once again.

Screenshot 2021-11-02 at 13.24.13.png

Hi <@U01UB0LHTTQ> so I launched the livekit server on digital ocean, and tried testing it out but got some errors.

Screenshot 2021-11-02 at 13.23.44.png

I ran the following commands
```systemctl status docker.service
systemctl status nginx.service
systemctl status docker.livekit-server@v0.13.service```
all are active

Screenshot 2021-11-02 at 13.22.31.png

This is my firewall inbound configuration. <@U01UB0LHTTQ>

can you post the full `started LiveKit server` log line? It should say which ports it’s trying to use

Screenshot 2021-11-02 at 14.21.05.png

Screenshot 2021-11-02 at 14.26.09.png

<@U01UB0LHTTQ> this is the full log line highlighted

yes that’s the line, but there’s more. The full line might look like `2021-10-28T22:11:11.222-0700	INFO	livekit	service/server.go:176	starting LiveKit server	{"addr": ":7880", "nodeID": "ND_2b3J6aFf", "nodeIP": "192.168.0.116", "version": "0.13.5", "rtc.portTCP": 7881, "rtc.portUDP": 7882}`

Screenshot 2021-11-02 at 14.40.40.png

ports look right, <@U02BBTRGF98> any ideas here?

the service statuses look good. SSL cert is a good thing to check. also check your nginx logs in `/var/log/nginx`

Screenshot 2021-11-03 at 05.15.08.png

Okay, so I created a new droplet and set it up all over again, <@U01KZ61GV5Z> yes, I have ssl certs setup just like in the docs. I ran the following highlighted commands after setup and these were the results. <@U01UB0LHTTQ> <@U02BBTRGF98>

<https://docs.livekit.io/deploy#domain-ssl-certificates-and-load-balancer>

Oh,  my ssl is self signed <@U01KZ61GV5Z>

How do I get an ssl  certificate signed by a certificate authority ?

Screenshot 2021-11-03 at 16.30.02.png

<@U01KZ61GV5Z> <@U01UB0LHTTQ> <@U02BBTRGF98> the ssl certificate was the problem, I was able to get one signed by a certificate authority and the basic connection worked. Thank you.

I updated to `0.13.4` on the js client, and it looks like local track publication upon joining behaves differently.  At the point where the `connect` call returns, the local participant has 0 tracks, but I'm not seeing any callbacks get invoked either for track subscriptions/etc.

hey <@U02HS7BES0H> , it'd be helpful to :thread: these conversations.

you would not get "subscription" events for local tracks.. as the local participant is the publisher. a local track is always considered subscribed

But it appears that you never get `TrackSubscribed` callbacks for those local tracks.

Ok. So it appears that if I listen to `LocalTrackPublished`, I should check `.isSubscribed` on the pub to see if I need to synthesize the TrackSubscribed callback myself.

agreed. we'll update the docs on the new event shortly. it's actually pretty simple.. when either `LocalTrackPublished` or `TrackSubscribed` is fired, a local track or a remote track is ready to be rendered.